source: libcaca/trunk/csharp/Cucul.cs @ 2046

Last change on this file since 2046 was 2046, checked in by Sam Hocevar, 13 years ago
  • Started Cucul# cleanup: added missing functions, used get/set attributes when meaningful, removed deprecated bindings.
  • Property svn:keywords set to Id
File size: 21.3 KB
Line 
1/*
2 *  libcucul   .NET bindings for libcucul
3 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
4 *                All Rights Reserved
5 *
6 *  $Id: Cucul.cs 2046 2007-11-24 15:00:21Z sam $
7 *
8 *  This library is free software. It comes without any warranty, to
9 *  the extent permitted by applicable law. You can redistribute it
10 *  and/or modify it under the terms of the Do What The Fuck You Want
11 *  To Public License, Version 2, as published by Sam Hocevar. See
12 *  http://sam.zoy.org/wtfpl/COPYING for more details.
13 */
14
15using System;
16using System.Runtime.InteropServices;
17using System.Security;
18
19namespace Cucul
20{
21    /* Static libcucul stuff that does not fit in any object */
22    public static class Libcucul
23    {
24        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
25         SuppressUnmanagedCodeSecurity]
26        private static extern int cucul_rand(int min, int max);
27
28        public static int Rand(int min, int max)
29        {
30            return cucul_rand(min, max);
31        }
32
33        public const int BLACK = 0x00,
34                         BLUE = 0x01,
35                         GREEN = 0x02,
36                         CYAN = 0x03,
37                         RED = 0x04,
38                         MAGENTA = 0x05,
39                         BROWN = 0x06,
40                         LIGHTGRAY = 0x07,
41                         DARKGRAY = 0x08,
42                         LIGHTBLUE = 0x09,
43                         LIGHTGREEN = 0x0a,
44                         LIGHTCYAN = 0x0b,
45                         LIGHTRED = 0x0c,
46                         LIGHTMAGENTA = 0x0d,
47                         YELLOW = 0x0e,
48                         WHITE = 0x0f,
49                         DEFAULT = 0x10,
50                         TRANSPARENT = 0x20;
51
52        public const int BOLD = 0x01,
53                         ITALICS = 0x02,
54                         UNDERLINE = 0x04,
55                         BLINK = 0x08;
56    }
57
58    public unsafe class CuculCanvas : IDisposable
59    {
60        public readonly IntPtr _cv;
61
62        /* libcucul basic functions */
63
64        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
65         SuppressUnmanagedCodeSecurity]
66        private static extern IntPtr cucul_create_canvas(int w, int h);
67        public CuculCanvas()
68        {
69            _cv = cucul_create_canvas(0, 0);
70        }
71
72        public CuculCanvas(int w, int h)
73        {
74            _cv = cucul_create_canvas(w, h);
75        }
76
77        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
78         SuppressUnmanagedCodeSecurity]
79        private static extern int cucul_free_canvas(IntPtr cv);
80        public void Dispose()
81        {
82           cucul_free_canvas(_cv);
83           GC.SuppressFinalize(this);
84        }
85
86        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
87         SuppressUnmanagedCodeSecurity]
88        private static extern int cucul_set_canvas_size(IntPtr cv,
89                                                        int w, int h);
90        public void setSize(int w, int h)
91        {
92            cucul_set_canvas_size(_cv, w, h);
93        }
94
95        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
96         SuppressUnmanagedCodeSecurity]
97        private static extern int cucul_get_canvas_width(IntPtr cv);
98        public int width
99        {
100            get { return cucul_get_canvas_width(_cv); }
101            set { cucul_set_canvas_size(_cv, value,
102                                        cucul_get_canvas_height(_cv)); }
103        }
104
105        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
106         SuppressUnmanagedCodeSecurity]
107        private static extern int cucul_get_canvas_height(IntPtr cv);
108        public int height
109        {
110            get { return cucul_get_canvas_height(_cv); }
111            set { cucul_set_canvas_size(_cv, cucul_get_canvas_width(_cv),
112                                        value); }
113        }
114
115        /* canvas drawing */
116
117        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
118         SuppressUnmanagedCodeSecurity]
119        private static extern int cucul_gotoxy(IntPtr cv, int x, int y);
120        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
121         SuppressUnmanagedCodeSecurity]
122        private static extern int cucul_get_cursor_x(IntPtr cv);
123        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
124         SuppressUnmanagedCodeSecurity]
125        private static extern int cucul_get_cursor_y(IntPtr cv);
126        public int cursorX
127        {
128            get { return cucul_get_cursor_x(_cv); }
129            set { cucul_gotoxy(_cv, value, cucul_get_cursor_y(_cv)); }
130        }
131
132        public int cursorY
133        {
134            get { return cucul_get_cursor_y(_cv); }
135            set { cucul_gotoxy(_cv, cucul_get_cursor_x(_cv), value); }
136        }
137
138        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
139         SuppressUnmanagedCodeSecurity]
140        private static extern int cucul_put_char(IntPtr cv,
141                                                 int x, int y, int c);
142        public int putChar(int x, int y, int c)
143        {
144            return cucul_put_char(_cv, x, y, c);
145        }
146
147        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
148         SuppressUnmanagedCodeSecurity]
149        private static extern int cucul_get_char(IntPtr cv, int x, int y);
150        public int getChar(int x, int y)
151        {
152            return cucul_get_char(_cv, x, y);
153        }
154
155        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
156         SuppressUnmanagedCodeSecurity]
157        private static extern int cucul_put_str(IntPtr cv,
158                                                int x, int y, string c);
159        public int putStr(int x, int y, string c)
160        {
161            return cucul_put_str(_cv, x, y, c);
162        }
163
164        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
165         SuppressUnmanagedCodeSecurity]
166        private static extern int cucul_get_attr(IntPtr cv, int x, int y);
167        public int getAttr(int x, int y)
168        {
169            return cucul_get_attr(_cv, x, y);
170        }
171
172        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
173         SuppressUnmanagedCodeSecurity]
174        private static extern int cucul_set_attr(IntPtr cv, int a);
175        public int setAttr(int a)
176        {
177            return cucul_set_attr(_cv, a);
178        }
179
180        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
181         SuppressUnmanagedCodeSecurity]
182        private static extern int cucul_put_attr(IntPtr cv,
183                                                 int x, int y, int a);
184        public int putAttr(int x, int y, int a)
185        {
186            return cucul_put_attr(_cv, x, y, a);
187        }
188
189        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
190         SuppressUnmanagedCodeSecurity]
191        private static extern int cucul_set_color_ansi(IntPtr cv,
192                                                       byte fg, byte bg);
193        public int setColorAnsi(int fg, int bg)
194        {
195            return cucul_set_color_ansi(_cv, (byte)fg, (byte)bg);
196        }
197
198        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
199         SuppressUnmanagedCodeSecurity]
200        private static extern int cucul_set_color_argb(IntPtr cv,
201                                                       int fg, int bg);
202        public int setColorArgb(int fg, int bg)
203        {
204            return cucul_set_color_argb(_cv, fg, bg);
205        }
206
207        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
208         SuppressUnmanagedCodeSecurity]
209        private static extern int cucul_clear_canvas(IntPtr cv);
210        public int Clear()
211        {
212            return cucul_clear_canvas(_cv);
213        }
214
215        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
216         SuppressUnmanagedCodeSecurity]
217        private static extern int cucul_set_canvas_handle(IntPtr cv,
218                                                          int x, int y);
219        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
220         SuppressUnmanagedCodeSecurity]
221        private static extern int cucul_get_canvas_handle_x(IntPtr cv);
222        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
223         SuppressUnmanagedCodeSecurity]
224        private static extern int cucul_get_canvas_handle_y(IntPtr cv);
225        public int handleX
226        {
227            get { return cucul_get_canvas_handle_x(_cv); }
228            set { cucul_set_canvas_handle(_cv, value,
229                                          cucul_get_canvas_handle_y(_cv)); }
230        }
231
232        public int handleY
233        {
234            get { return cucul_get_canvas_handle_y(_cv); }
235            set { cucul_set_canvas_handle(_cv, cucul_get_canvas_handle_x(_cv),
236                                          value); }
237        }
238
239        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
240         SuppressUnmanagedCodeSecurity]
241        private static extern int cucul_blit(IntPtr cv, int x, int y,
242                                             IntPtr cv1, IntPtr cv2);
243        public int Blit(int x, int y, CuculCanvas canvas)
244        {
245            return cucul_blit(_cv, x, y, canvas._cv, IntPtr.Zero);
246        }
247
248        public int Blit(int x, int y, CuculCanvas cv, CuculCanvas mask)
249        {
250            return cucul_blit(_cv, x, y, cv._cv, mask._cv);
251        }
252
253        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
254         SuppressUnmanagedCodeSecurity]
255        private static extern int cucul_set_canvas_boundaries(IntPtr cv,
256                                                              int x, int y,
257                                                              int h,  int w);
258        public int setBoundaries(int x, int y, int h, int w)
259        {
260            return cucul_set_canvas_boundaries(_cv, x, y, h, w);
261        }
262
263        /* canvas transformation */
264
265        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
266         SuppressUnmanagedCodeSecurity]
267        private static extern int cucul_invert(IntPtr cv);
268        public int Invert()
269        {
270            return cucul_invert(_cv);
271        }
272
273        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
274         SuppressUnmanagedCodeSecurity]
275        private static extern int cucul_flip(IntPtr cv);
276        public int Flip()
277        {
278            return cucul_flip(_cv);
279        }
280
281        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
282         SuppressUnmanagedCodeSecurity]
283        private static extern int cucul_flop(IntPtr cv);
284        public int Flop()
285        {
286            return cucul_flop(_cv);
287        }
288
289        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
290         SuppressUnmanagedCodeSecurity]
291        private static extern int cucul_rotate_180(IntPtr cv);
292        public int Rotate180()
293        {
294            return cucul_rotate_180(_cv);
295        }
296
297        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
298         SuppressUnmanagedCodeSecurity]
299        private static extern int cucul_rotate_left(IntPtr cv);
300        public int RotateLeft()
301        {
302            return cucul_rotate_left(_cv);
303        }
304
305        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
306         SuppressUnmanagedCodeSecurity]
307        private static extern int cucul_rotate_right(IntPtr cv);
308        public int RotateRight()
309        {
310            return cucul_rotate_right(_cv);
311        }
312
313        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
314         SuppressUnmanagedCodeSecurity]
315        private static extern int cucul_stretch_left(IntPtr cv);
316        public int StretchLeft()
317        {
318            return cucul_stretch_left(_cv);
319        }
320
321        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
322         SuppressUnmanagedCodeSecurity]
323        private static extern int cucul_stretch_right(IntPtr cv);
324        public int StretchRight()
325        {
326            return cucul_stretch_right(_cv);
327        }
328
329        /* primitives drawing */
330        /* FIXME: highly incomplete */
331
332        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
333         SuppressUnmanagedCodeSecurity]
334        private static extern int cucul_draw_line(IntPtr cv, int x1, int y1, int x2, int y2, int c);
335        public int drawLine(int x1, int y1, int x2, int y2, int c)
336        {
337            return cucul_draw_line(_cv, x1, y1, x2, y2, c);
338        }
339        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
340         SuppressUnmanagedCodeSecurity]
341        private static extern int cucul_draw_polyline(IntPtr cv, int[] x, int[] y, int n, IntPtr c);
342        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
343         SuppressUnmanagedCodeSecurity]
344        private static extern int cucul_draw_thin_line(IntPtr cv, int x1, int y1, int x2, int y2);
345        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
346         SuppressUnmanagedCodeSecurity]
347        private static extern int cucul_draw_thin_polyline(IntPtr cv, int[] x, int[] y, int n);
348
349        /* frame handling */
350        /* FIXME: clean up this shit */
351
352        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
353         SuppressUnmanagedCodeSecurity]
354        private static extern int cucul_get_frame_count(IntPtr cv);
355        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
356         SuppressUnmanagedCodeSecurity]
357        private static extern int cucul_set_frame(IntPtr cv, int f);
358        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
359         SuppressUnmanagedCodeSecurity]
360        private static extern string cucul_get_frame_name(IntPtr cv);
361        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
362         SuppressUnmanagedCodeSecurity]
363        private static extern int cucul_set_frame_name(IntPtr cv, string n);
364        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
365         SuppressUnmanagedCodeSecurity]
366        private static extern int cucul_create_frame(IntPtr cv, int f);
367        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
368         SuppressUnmanagedCodeSecurity]
369        private static extern int cucul_free_frame(IntPtr cv, int f);
370
371        public int getFrameCount()
372        {
373            return cucul_get_frame_count(_cv);
374        }
375
376        public int setFrame(int f)
377        {
378            return cucul_set_frame(_cv, f);
379        }
380
381        public string getFrameName()
382        {
383            return cucul_get_frame_name(_cv);
384        }
385
386        public int setFrameName(string n)
387        {
388            return cucul_set_frame_name(_cv, n);
389        }
390
391        public int createFrame(int f)
392        {
393            return cucul_create_frame(_cv, f);
394        }
395
396        public int freeFrame(int f)
397        {
398            return cucul_free_frame(_cv, f);
399        }
400    }
401
402    public unsafe class CuculAttr
403    {
404        private int _attr;
405
406        public CuculAttr(int attr)
407        {
408            attr = _attr;
409        }
410
411        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
412         SuppressUnmanagedCodeSecurity]
413        private static extern byte cucul_attr_to_ansi(Int32 a);
414        public byte toAnsi()
415        {
416            return cucul_attr_to_ansi(_attr);
417        }
418
419        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
420         SuppressUnmanagedCodeSecurity]
421        private static extern byte cucul_attr_to_ansi_fg(Int32 a);
422        public byte toAnsiFg()
423        {
424            return cucul_attr_to_ansi_fg(_attr);
425        }
426
427        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
428         SuppressUnmanagedCodeSecurity]
429        private static extern byte cucul_attr_to_ansi_bg(Int32 a);
430        public byte toAnsiBg()
431        {
432            return cucul_attr_to_ansi_bg(_attr);
433        }
434    }
435
436    public unsafe class CuculDither : IDisposable
437    {
438    [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
439         SuppressUnmanagedCodeSecurity]
440      private static extern IntPtr cucul_create_dither(int bpp, int w,
441                                                      int h, int pitch,
442                                                      Int64 rmask,
443                                                      Int64 gmask,
444                                                      Int64 bmask,
445                                                      Int64 amask);
446
447
448        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
449         SuppressUnmanagedCodeSecurity]
450        private static extern int cucul_set_dither_palette(IntPtr d,
451                               int[] r, int[] g,
452                               int[] b, int[] a);
453        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
454         SuppressUnmanagedCodeSecurity]
455        private static extern int cucul_set_dither_brightness(IntPtr d, float b);
456        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
457         SuppressUnmanagedCodeSecurity]
458        private static extern int cucul_set_dither_gamma(IntPtr d, float g);
459        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
460         SuppressUnmanagedCodeSecurity]
461        private static extern int cucul_set_dither_contrast(IntPtr d, float c);
462        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
463         SuppressUnmanagedCodeSecurity]
464        private static extern int cucul_set_dither_invert(IntPtr d, int i);
465        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
466         SuppressUnmanagedCodeSecurity]
467        private static extern int cucul_set_dither_antialias(IntPtr d, string s);
468        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
469         SuppressUnmanagedCodeSecurity]
470        private static extern string[] cucul_get_dither_antialias_list(IntPtr d);
471        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
472         SuppressUnmanagedCodeSecurity]
473        private static extern int cucul_set_dither_color(IntPtr d, string s);
474        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
475         SuppressUnmanagedCodeSecurity]
476        private static extern string[] cucul_get_dither_color_list(IntPtr d);
477        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
478         SuppressUnmanagedCodeSecurity]
479        private static extern int cucul_set_dither_charset(IntPtr d, string s);
480        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
481         SuppressUnmanagedCodeSecurity]
482        private static extern string[] cucul_get_dither_charset_list(IntPtr d);
483        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
484         SuppressUnmanagedCodeSecurity]
485        private static extern int cucul_set_dither_mode(IntPtr d, string s);
486        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
487         SuppressUnmanagedCodeSecurity]
488        private static extern string[] cucul_get_dither_mode_list(IntPtr d);
489        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
490         SuppressUnmanagedCodeSecurity]
491        private static extern int cucul_free_dither(IntPtr d);
492
493  /* FIXME  [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
494         SuppressUnmanagedCodeSecurity]
495      int cucul_dither_bitmap(Canvas c, int  x, int y, int w , int y,
496                         IntPtr d2, void *);*/
497
498        IntPtr _dither;
499
500        public CuculDither(int bpp, int w,int h, int pitch,
501                           Int64 rmask, Int64 gmask,Int64 bmask, Int64 amask)
502        {
503            _dither = cucul_create_dither(bpp, w, h, pitch, rmask, gmask, bmask, amask);
504        }
505
506        public void Dispose()
507        {
508            cucul_free_dither(_dither);
509            GC.SuppressFinalize(this);
510        }
511
512        public int setBrightness(float b)
513        {
514            return cucul_set_dither_brightness(_dither, b);
515        }
516
517        public int setGamma(float g)
518        {
519            return cucul_set_dither_gamma(_dither, g);
520        }
521
522        public int setContrast(float c)
523        {
524            return cucul_set_dither_contrast(_dither, c);
525        }
526
527        public int setInvert(int i)
528        {
529            return cucul_set_dither_invert(_dither, i);
530        }
531
532        public int setAntialias(string s)
533        {
534            return cucul_set_dither_antialias(_dither, s);
535        }
536
537        public int setColor(string s)
538        {
539            return cucul_set_dither_color(_dither, s);
540        }
541
542        public int setCharset(string s)
543        {
544            return cucul_set_dither_charset(_dither, s);
545        }
546
547        public int setMode(string s)
548        {
549            return cucul_set_dither_mode(_dither, s);
550        }
551
552        /* <FIXME> */
553        public string[] getAntialiasList()
554        {
555            return cucul_get_dither_antialias_list(_dither);
556        }
557
558        public string[] getColorList()
559        {
560            return cucul_get_dither_color_list(_dither);
561        }
562
563        public string[] getCharsetList()
564        {
565            return cucul_get_dither_charset_list(_dither);
566        }
567
568        public string[] getModeList()
569        {
570            return cucul_get_dither_mode_list(_dither);
571        }
572
573        /* </FIXME> */
574    }
575}
576
Note: See TracBrowser for help on using the repository browser.