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

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