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

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