source: libcaca/trunk/csharp/Caca.cs @ 2822

Last change on this file since 2822 was 2822, checked in by Sam Hocevar, 12 years ago

Continuing the libcucul-libcaca merge.

  • Property svn:keywords set to Id
File size: 44.8 KB
Line 
1/*
2 *  libcaca       .NET bindings for libcaca
3 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
4 *                2007 Sam Hocevar <sam@zoy.org>
5 *                All Rights Reserved
6 *
7 *  $Id: Caca.cs 2822 2008-09-27 14:11:36Z 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 Caca
22{
23    /* Static libcaca stuff that does not fit in any object */
24    public static class Libcaca
25    {
26        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
27         SuppressUnmanagedCodeSecurity]
28        private static extern int caca_rand(int min, int max);
29        public static int Rand(int min, int max)
30        {
31            return caca_rand(min, max);
32        }
33
34        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
35         SuppressUnmanagedCodeSecurity]
36        private static extern IntPtr caca_get_version();
37        public static string getVersion()
38        {
39            return Marshal.PtrToStringAnsi(caca_get_version());
40        }
41
42        public const uint 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 uint BOLD = 0x01,
62                          ITALICS = 0x02,
63                          UNDERLINE = 0x04,
64                          BLINK = 0x08;
65    }
66
67    public enum CacaEventType
68    {
69        NONE =          0x0000,
70
71        KEY_PRESS =     0x0001,
72        KEY_RELEASE =   0x0002,
73        MOUSE_PRESS =   0x0004,
74        MOUSE_RELEASE = 0x0008,
75        MOUSE_MOTION =  0x0010,
76        RESIZE =        0x0020,
77        QUIT =          0x0040,
78
79        ANY =           0xffff,
80    }
81
82    public enum CacaEventKey
83    {
84        UNKNOWN = 0x00,
85
86        CTRL_A =    0x01,
87        CTRL_B =    0x02,
88        CTRL_C =    0x03,
89        CTRL_D =    0x04,
90        CTRL_E =    0x05,
91        CTRL_F =    0x06,
92        CTRL_G =    0x07,
93        BACKSPACE = 0x08,
94        TAB =       0x09,
95        CTRL_J =    0x0a,
96        CTRL_K =    0x0b,
97        CTRL_L =    0x0c,
98        RETURN =    0x0d,
99        CTRL_N =    0x0e,
100        CTRL_O =    0x0f,
101        CTRL_P =    0x10,
102        CTRL_Q =    0x11,
103        CTRL_R =    0x12,
104        PAUSE =     0x13,
105        CTRL_T =    0x14,
106        CTRL_U =    0x15,
107        CTRL_V =    0x16,
108        CTRL_W =    0x17,
109        CTRL_X =    0x18,
110        CTRL_Y =    0x19,
111        CTRL_Z =    0x1a,
112        ESCAPE =    0x1b,
113        DELETE =    0x7f,
114
115        UP =    0x111,
116        DOWN =  0x112,
117        LEFT =  0x113,
118        RIGHT = 0x114,
119
120        INSERT =   0x115,
121        HOME =     0x116,
122        END =      0x117,
123        PAGEUP =   0x118,
124        PAGEDOWN = 0x119,
125
126        F1 =  0x11a,
127        F2 =  0x11b,
128        F3 =  0x11c,
129        F4 =  0x11d,
130        F5 =  0x11e,
131        F6 =  0x11f,
132        F7 =  0x120,
133        F8 =  0x121,
134        F9 =  0x122,
135        F10 = 0x123,
136        F11 = 0x124,
137        F12 = 0x125,
138        F13 = 0x126,
139        F14 = 0x127,
140        F15 = 0x128,
141    }
142
143    public class CacaCanvas : IDisposable
144    {
145        public readonly IntPtr _c_cv;
146
147        /* libcaca basic functions */
148
149        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
150         SuppressUnmanagedCodeSecurity]
151        private static extern IntPtr caca_create_canvas(int w, int h);
152        public CacaCanvas()
153        {
154            _c_cv = caca_create_canvas(0, 0);
155        }
156
157        public CacaCanvas(Size s)
158        {
159            _c_cv = caca_create_canvas(s.Width, s.Height);
160        }
161
162        public CacaCanvas(int w, int h)
163        {
164            _c_cv = caca_create_canvas(h, w);
165        }
166
167        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
168         SuppressUnmanagedCodeSecurity]
169        private static extern int caca_free_canvas(IntPtr cv);
170        public void Dispose()
171        {
172           /* FIXME: don't destroy ourselves if we're attached */
173           caca_free_canvas(_c_cv);
174           GC.SuppressFinalize(this);
175        }
176
177        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
178         SuppressUnmanagedCodeSecurity]
179        private static extern int caca_set_canvas_size(IntPtr cv,
180                                                        int w, int h);
181        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
182         SuppressUnmanagedCodeSecurity]
183        private static extern int caca_get_canvas_width(IntPtr cv);
184        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
185         SuppressUnmanagedCodeSecurity]
186        private static extern int caca_get_canvas_height(IntPtr cv);
187        public Size Size
188        {
189            get { return new Size(caca_get_canvas_width(_c_cv),
190                                  caca_get_canvas_height(_c_cv)); }
191            set { caca_set_canvas_size(_c_cv, value.Width, value.Height); }
192        }
193
194        public Rectangle Rectangle
195        {
196            get { return new Rectangle(0, 0, caca_get_canvas_width(_c_cv),
197                                             caca_get_canvas_height(_c_cv)); }
198            set { caca_set_canvas_size(_c_cv, value.Width, value.Height); }
199        }
200
201        /* canvas drawing */
202
203        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
204         SuppressUnmanagedCodeSecurity]
205        private static extern int caca_gotoxy(IntPtr cv, int x, int y);
206        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
207         SuppressUnmanagedCodeSecurity]
208        private static extern int caca_get_cursor_x(IntPtr cv);
209        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
210         SuppressUnmanagedCodeSecurity]
211        private static extern int caca_get_cursor_y(IntPtr cv);
212        public Point Cursor
213        {
214            get { return new Point(caca_get_cursor_x(_c_cv),
215                                   caca_get_cursor_y(_c_cv)); }
216            set { caca_gotoxy(_c_cv, value.X, value.Y); }
217        }
218
219        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
220         SuppressUnmanagedCodeSecurity]
221        private static extern int caca_put_char(IntPtr cv,
222                                                 int x, int y, uint c);
223        public int putChar(Point p, uint c)
224        {
225            return caca_put_char(_c_cv, p.X, p.Y, c);
226        }
227
228        public int putChar(int x, int y, uint c)
229        {
230            return caca_put_char(_c_cv, x, y, c);
231        }
232
233        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
234         SuppressUnmanagedCodeSecurity]
235        private static extern uint caca_get_char(IntPtr cv, int x, int y);
236        public uint getChar(Point p)
237        {
238            return caca_get_char(_c_cv, p.X, p.Y);
239        }
240
241        public uint getChar(int x, int y)
242        {
243            return caca_get_char(_c_cv, x, y);
244        }
245
246        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
247         SuppressUnmanagedCodeSecurity]
248        private static extern int caca_put_str(IntPtr cv,
249                                                int x, int y, string c);
250        public int putStr(Point p, string c)
251        {
252            return caca_put_str(_c_cv, p.X, p.Y, c);
253        }
254
255        public int putStr(int x, int y, string c)
256        {
257            return caca_put_str(_c_cv, x, y, c);
258        }
259
260        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
261         SuppressUnmanagedCodeSecurity]
262        private static extern int caca_get_attr(IntPtr cv, int x, int y);
263        public int getAttr(Point p)
264        {
265            return caca_get_attr(_c_cv, p.X, p.Y);
266        }
267
268        public int getAttr(int x, int y)
269        {
270            return caca_get_attr(_c_cv, x, y);
271        }
272
273        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
274         SuppressUnmanagedCodeSecurity]
275        private static extern int caca_set_attr(IntPtr cv, uint a);
276        public int setAttr(uint a)
277        {
278            return caca_set_attr(_c_cv, a);
279        }
280
281        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
282         SuppressUnmanagedCodeSecurity]
283        private static extern int caca_put_attr(IntPtr cv,
284                                                 int x, int y, uint a);
285        public int putAttr(Point p, uint a)
286        {
287            return caca_put_attr(_c_cv, p.X, p.Y, a);
288        }
289
290        public int putAttr(int x, int y, uint a)
291        {
292            return caca_put_attr(_c_cv, x, y, a);
293        }
294
295        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
296         SuppressUnmanagedCodeSecurity]
297        private static extern int caca_set_color_ansi(IntPtr cv,
298                                                       byte fg, byte bg);
299        public int setColorAnsi(uint fg, uint bg)
300        {
301            return caca_set_color_ansi(_c_cv, (byte)fg, (byte)bg);
302        }
303
304        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
305         SuppressUnmanagedCodeSecurity]
306        private static extern int caca_set_color_argb(IntPtr cv,
307                                                       uint fg, uint bg);
308        public int setColorArgb(uint fg, uint bg)
309        {
310            return caca_set_color_argb(_c_cv, fg, bg);
311        }
312
313        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
314         SuppressUnmanagedCodeSecurity]
315        private static extern int caca_clear_canvas(IntPtr cv);
316        public int Clear()
317        {
318            return caca_clear_canvas(_c_cv);
319        }
320
321        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
322         SuppressUnmanagedCodeSecurity]
323        private static extern int caca_set_canvas_handle(IntPtr cv,
324                                                          int x, int y);
325        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
326         SuppressUnmanagedCodeSecurity]
327        private static extern int caca_get_canvas_handle_x(IntPtr cv);
328        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
329         SuppressUnmanagedCodeSecurity]
330        private static extern int caca_get_canvas_handle_y(IntPtr cv);
331        public Point Handle
332        {
333            get { return new Point(caca_get_canvas_handle_x(_c_cv),
334                                   caca_get_canvas_handle_y(_c_cv)); }
335            set { caca_set_canvas_handle(_c_cv, value.X, value.Y); }
336        }
337
338        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
339         SuppressUnmanagedCodeSecurity]
340        private static extern int caca_blit(IntPtr cv, int x, int y,
341                                             IntPtr cv1, IntPtr cv2);
342        public int Blit(Point p, CacaCanvas canvas)
343        {
344            return caca_blit(_c_cv, p.X, p.Y, canvas._c_cv, IntPtr.Zero);
345        }
346
347        public int Blit(Point p, CacaCanvas cv, CacaCanvas mask)
348        {
349            return caca_blit(_c_cv, p.X, p.Y, cv._c_cv, mask._c_cv);
350        }
351
352        public int Blit(int x, int y, CacaCanvas canvas)
353        {
354            return caca_blit(_c_cv, x, y, canvas._c_cv, IntPtr.Zero);
355        }
356
357        public int Blit(int x, int y, CacaCanvas cv, CacaCanvas mask)
358        {
359            return caca_blit(_c_cv, x, y, cv._c_cv, mask._c_cv);
360        }
361
362        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
363         SuppressUnmanagedCodeSecurity]
364        private static extern int caca_set_canvas_boundaries(IntPtr cv,
365                                                              int x, int y,
366                                                              int h, int w);
367        public int setBoundaries(Rectangle r)
368        {
369            return caca_set_canvas_boundaries(_c_cv, r.X, r.Y,
370                                               r.Width, r.Height);
371        }
372
373        public int setBoundaries(int x, int y, int w, int h)
374        {
375            return caca_set_canvas_boundaries(_c_cv, x, y, w, h);
376        }
377
378        /* canvas transformation */
379
380        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
381         SuppressUnmanagedCodeSecurity]
382        private static extern int caca_invert(IntPtr cv);
383        public int Invert()
384        {
385            return caca_invert(_c_cv);
386        }
387
388        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
389         SuppressUnmanagedCodeSecurity]
390        private static extern int caca_flip(IntPtr cv);
391        public int Flip()
392        {
393            return caca_flip(_c_cv);
394        }
395
396        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
397         SuppressUnmanagedCodeSecurity]
398        private static extern int caca_flop(IntPtr cv);
399        public int Flop()
400        {
401            return caca_flop(_c_cv);
402        }
403
404        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
405         SuppressUnmanagedCodeSecurity]
406        private static extern int caca_rotate_180(IntPtr cv);
407        public int Rotate180()
408        {
409            return caca_rotate_180(_c_cv);
410        }
411
412        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
413         SuppressUnmanagedCodeSecurity]
414        private static extern int caca_rotate_left(IntPtr cv);
415        public int RotateLeft()
416        {
417            return caca_rotate_left(_c_cv);
418        }
419
420        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
421         SuppressUnmanagedCodeSecurity]
422        private static extern int caca_rotate_right(IntPtr cv);
423        public int RotateRight()
424        {
425            return caca_rotate_right(_c_cv);
426        }
427
428        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
429         SuppressUnmanagedCodeSecurity]
430        private static extern int caca_stretch_left(IntPtr cv);
431        public int StretchLeft()
432        {
433            return caca_stretch_left(_c_cv);
434        }
435
436        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
437         SuppressUnmanagedCodeSecurity]
438        private static extern int caca_stretch_right(IntPtr cv);
439        public int StretchRight()
440        {
441            return caca_stretch_right(_c_cv);
442        }
443
444        /* primitives drawing */
445
446        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
447         SuppressUnmanagedCodeSecurity]
448        private static extern int caca_draw_line(IntPtr cv, int x1, int y1,
449                                                  int x2, int y2, uint c);
450        public int drawLine(Point p1, Point p2, uint c)
451        {
452            return caca_draw_line(_c_cv, p1.X, p1.Y, p2.X, p2.Y, c);
453        }
454
455        public int drawLine(int x1, int y1, int x2, int y2, uint c)
456        {
457            return caca_draw_line(_c_cv, x1, y1, x2, y2, c);
458        }
459
460        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
461         SuppressUnmanagedCodeSecurity]
462        private static extern int caca_draw_polyline(IntPtr cv, int[] x,
463                                                      int[] y, int n, uint c);
464        public int drawPolyline(Point[] lp, uint c)
465        {
466            int[] lx = new int[lp.Length];
467            int[] ly = new int[lp.Length];
468            for(int i = 0; i < lp.Length; i++)
469            {
470                lx[i] = lp[i].X;
471                ly[i] = lp[i].Y;
472            }
473            return caca_draw_polyline(_c_cv, lx, ly, lp.Length - 1, c);
474        }
475
476        public int drawPolyline(int[] lx, int[] ly, uint c)
477        {
478            if(lx.Length != ly.Length)
479                return -1;
480
481            return caca_draw_polyline(_c_cv, lx, ly, lx.Length - 1, c);
482        }
483
484        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
485         SuppressUnmanagedCodeSecurity]
486        private static extern int caca_draw_thin_line(IntPtr cv, int x1,
487                                                       int y1, int x2, int y2);
488        public int drawThinLine(Point p1, Point p2)
489        {
490            return caca_draw_thin_line(_c_cv, p1.X, p1.Y, p2.X, p2.Y);
491        }
492
493        public int drawThinLine(int x1, int y1, int x2, int y2)
494        {
495            return caca_draw_thin_line(_c_cv, x1, y1, x2, y2);
496        }
497
498        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
499         SuppressUnmanagedCodeSecurity]
500        private static extern int caca_draw_thin_polyline(IntPtr cv, int[] x,
501                                                           int[] y, int n);
502        public int drawThinPolyline(Point[] lp)
503        {
504            int[] lx = new int[lp.Length];
505            int[] ly = new int[lp.Length];
506            for(int i = 0; i < lp.Length; i++)
507            {
508                lx[i] = lp[i].X;
509                ly[i] = lp[i].Y;
510            }
511            return caca_draw_thin_polyline(_c_cv, lx, ly, lp.Length - 1);
512        }
513
514        public int drawThinPolyline(int[] lx, int[] ly)
515        {
516            if(lx.Length != ly.Length)
517                return -1;
518
519            return caca_draw_thin_polyline(_c_cv, lx, ly, lx.Length - 1);
520        }
521
522        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
523         SuppressUnmanagedCodeSecurity]
524        private static extern int caca_draw_circle(IntPtr cv, int x, int y,
525                                                    int r, uint c);
526        public int drawCircle(Point p, int r, uint c)
527        {
528            return caca_draw_circle(_c_cv, p.X, p.Y, r, c);
529        }
530
531        public int drawCircle(int x, int y, int r, uint c)
532        {
533            return caca_draw_circle(_c_cv, x, y, r, c);
534        }
535
536        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
537         SuppressUnmanagedCodeSecurity]
538        private static extern int caca_draw_ellipse(IntPtr cv, int x, int y,
539                                                     int a, int b, uint c);
540        public int drawEllipse(Point p, int a, int b, uint c)
541        {
542            return caca_draw_ellipse(_c_cv, p.X, p.Y, a, b, c);
543        }
544
545        public int drawEllipse(int x, int y, int a, int b, uint c)
546        {
547            return caca_draw_ellipse(_c_cv, x, y, a, b, c);
548        }
549
550        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
551         SuppressUnmanagedCodeSecurity]
552        private static extern int caca_draw_thin_ellipse(IntPtr cv,
553                                                          int x, int y,
554                                                          int a, int b);
555        public int drawThinEllipse(Point p, int a, int b)
556        {
557            return caca_draw_thin_ellipse(_c_cv, p.X, p.Y, a, b);
558        }
559
560        public int drawThinEllipse(int x, int y, int a, int b)
561        {
562            return caca_draw_thin_ellipse(_c_cv, x, y, a, b);
563        }
564
565        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
566         SuppressUnmanagedCodeSecurity]
567        private static extern int caca_fill_ellipse(IntPtr cv, int x, int y,
568                                                     int a, int b, uint c);
569        public int fillEllipse(Point p, int a, int b, uint c)
570        {
571            return caca_fill_ellipse(_c_cv, p.X, p.Y, a, b, c);
572        }
573
574        public int fillEllipse(int x, int y, int a, int b, uint c)
575        {
576            return caca_fill_ellipse(_c_cv, x, y, a, b, c);
577        }
578
579        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
580         SuppressUnmanagedCodeSecurity]
581        private static extern int caca_draw_box(IntPtr cv, int x, int y,
582                                                 int w, int h, uint c);
583        public int drawBox(Rectangle r, uint c)
584        {
585            return caca_draw_box(_c_cv, r.X, r.Y, r.Width, r.Height, c);
586        }
587
588        public int drawBox(int x, int y, int w, int h, uint c)
589        {
590            return caca_draw_box(_c_cv, x, y, w, h, c);
591        }
592
593        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
594         SuppressUnmanagedCodeSecurity]
595        private static extern int caca_draw_thin_box(IntPtr cv, int x, int y,
596                                                      int w, int h);
597        public int drawThinBox(Rectangle r)
598        {
599            return caca_draw_thin_box(_c_cv, r.X, r.Y, r.Width, r.Height);
600        }
601
602        public int drawThinBox(int x, int y, int w, int h)
603        {
604            return caca_draw_thin_box(_c_cv, x, y, w, h);
605        }
606
607        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
608         SuppressUnmanagedCodeSecurity]
609        private static extern int caca_draw_cp437_box(IntPtr cv, int x, int y,
610                                                       int w, int h);
611        public int drawCp437Box(Rectangle r)
612        {
613            return caca_draw_cp437_box(_c_cv, r.X, r.Y, r.Width, r.Height);
614        }
615
616        public int drawCp437Box(int x, int y, int w, int h)
617        {
618            return caca_draw_cp437_box(_c_cv, x, y, w, h);
619        }
620
621        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
622         SuppressUnmanagedCodeSecurity]
623        private static extern int caca_fill_box(IntPtr cv, int x, int y,
624                                                 int w, int h, uint c);
625        public int fillBox(Rectangle r, uint c)
626        {
627            return caca_fill_box(_c_cv, r.X, r.Y, r.Width, r.Height, c);
628        }
629
630        public int fillBox(int x, int y, int w, int h, uint c)
631        {
632            return caca_fill_box(_c_cv, x, y, w, h, c);
633        }
634
635        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
636         SuppressUnmanagedCodeSecurity]
637        private static extern int caca_draw_triangle(IntPtr cv, int x1,
638                                                      int y1, int x2, int y2,
639                                                      int x3, int y3, uint c);
640        public int drawTriangle(Point p1, Point p2, Point p3, uint c)
641        {
642            return caca_draw_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
643                                       p3.X, p3.Y, c);
644        }
645
646        public int drawTriangle(int x1, int y1, int x2, int y2,
647                                int x3, int y3, uint c)
648        {
649            return caca_draw_triangle(_c_cv, x1, y1, x2, y2, x3, y3, c);
650        }
651
652        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
653         SuppressUnmanagedCodeSecurity]
654        private static extern int caca_draw_thin_triangle(IntPtr cv,
655                                                           int x1, int y1,
656                                                           int x2, int y2,
657                                                           int x3, int y3);
658        public int drawThinTriangle(Point p1, Point p2, Point p3)
659        {
660            return caca_draw_thin_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
661                                            p3.X, p3.Y);
662        }
663
664        public int drawThinTriangle(int x1, int y1, int x2, int y2,
665                                    int x3, int y3)
666        {
667            return caca_draw_thin_triangle(_c_cv, x1, y1, x2, y2, x3, y3);
668        }
669
670        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
671         SuppressUnmanagedCodeSecurity]
672        private static extern int caca_fill_triangle(IntPtr cv, int x1,
673                                                      int y1, int x2, int y2,
674                                                      int x3, int y3, uint c);
675        public int fillTriangle(Point p1, Point p2, Point p3, uint c)
676        {
677            return caca_fill_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
678                                       p3.X, p3.Y, c);
679        }
680
681        public int fillTriangle(int x1, int y1, int x2, int y2,
682                                int x3, int y3, uint c)
683        {
684            return caca_fill_triangle(_c_cv, x1, y1, x2, y2, x3, y3, c);
685        }
686
687        /* frame handling */
688
689        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
690         SuppressUnmanagedCodeSecurity]
691        private static extern int caca_get_frame_count(IntPtr cv);
692        public int getFrameCount()
693        {
694            return caca_get_frame_count(_c_cv);
695        }
696
697        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
698         SuppressUnmanagedCodeSecurity]
699        private static extern int caca_set_frame(IntPtr cv, int f);
700        public int setFrame(int f)
701        {
702            return caca_set_frame(_c_cv, f);
703        }
704
705        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
706         SuppressUnmanagedCodeSecurity]
707        private static extern string caca_get_frame_name(IntPtr cv);
708        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
709         SuppressUnmanagedCodeSecurity]
710        private static extern int caca_set_frame_name(IntPtr cv, string n);
711        public string FrameName
712        {
713            get { return caca_get_frame_name(_c_cv); }
714            set { caca_set_frame_name(_c_cv, value); }
715        }
716
717        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
718         SuppressUnmanagedCodeSecurity]
719        private static extern int caca_create_frame(IntPtr cv, int f);
720        public int createFrame(int f)
721        {
722            return caca_create_frame(_c_cv, f);
723        }
724
725        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
726         SuppressUnmanagedCodeSecurity]
727        private static extern int caca_free_frame(IntPtr cv, int f);
728        public int freeFrame(int f)
729        {
730            return caca_free_frame(_c_cv, f);
731        }
732
733        /* bitmap dithering */
734
735        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
736         SuppressUnmanagedCodeSecurity]
737        private static extern int caca_dither_bitmap(IntPtr c, int  x, int y,
738                                                      int w, int h,
739                                                      IntPtr d, IntPtr data);
740        public int ditherBitmap(Rectangle r, CacaDither d, object data)
741        {
742            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
743            int ret = caca_dither_bitmap(_c_cv, r.X, r.Y, r.Width, r.Height,
744                                          d._dither, gch.AddrOfPinnedObject());
745            gch.Free();
746            return ret;
747        }
748
749        public int ditherBitmap(int x, int y, int w, int h,
750                                CacaDither d, object data)
751        {
752            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
753            int ret = caca_dither_bitmap(_c_cv, x, y, w, h, d._dither,
754                                          gch.AddrOfPinnedObject());
755            gch.Free();
756            return ret;
757        }
758    }
759
760    public class CacaAttr
761    {
762        private uint _attr;
763
764        public CacaAttr(uint attr)
765        {
766            _attr = attr;
767        }
768
769        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
770         SuppressUnmanagedCodeSecurity]
771        private static extern byte caca_attr_to_ansi(uint a);
772        public byte toAnsi()
773        {
774            return caca_attr_to_ansi(_attr);
775        }
776
777        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
778         SuppressUnmanagedCodeSecurity]
779        private static extern byte caca_attr_to_ansi_fg(uint a);
780        public byte toAnsiFg()
781        {
782            return caca_attr_to_ansi_fg(_attr);
783        }
784
785        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
786         SuppressUnmanagedCodeSecurity]
787        private static extern byte caca_attr_to_ansi_bg(uint a);
788        public byte toAnsiBg()
789        {
790            return caca_attr_to_ansi_bg(_attr);
791        }
792    }
793
794    public class CacaDither : IDisposable
795    {
796        public readonly IntPtr _dither;
797
798        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
799         SuppressUnmanagedCodeSecurity]
800        private static extern IntPtr caca_create_dither(int bpp, int w,
801                                                         int h, int pitch,
802                                                         uint rmask,
803                                                         uint gmask,
804                                                         uint bmask,
805                                                         uint amask);
806        public CacaDither(int bpp, Size s, int pitch,
807                           uint rmask, uint gmask, uint bmask, uint amask)
808        {
809            _dither = caca_create_dither(bpp, s.Width, s.Height, pitch,
810                                          rmask, gmask, bmask, amask);
811        }
812
813        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
814         SuppressUnmanagedCodeSecurity]
815        private static extern int caca_free_dither(IntPtr d);
816        public void Dispose()
817        {
818            caca_free_dither(_dither);
819            GC.SuppressFinalize(this);
820        }
821
822        /* TODO: fix this shit */
823
824        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
825         SuppressUnmanagedCodeSecurity]
826        private static extern int caca_set_dither_palette(IntPtr d,
827                               uint[] r, uint[] g,
828                               uint[] b, uint[] a);
829        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
830         SuppressUnmanagedCodeSecurity]
831        private static extern int caca_set_dither_brightness(IntPtr d, float b);
832        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
833         SuppressUnmanagedCodeSecurity]
834        private static extern int caca_set_dither_gamma(IntPtr d, float g);
835        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
836         SuppressUnmanagedCodeSecurity]
837        private static extern int caca_set_dither_contrast(IntPtr d, float c);
838        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
839         SuppressUnmanagedCodeSecurity]
840        private static extern int caca_set_dither_invert(IntPtr d, int i);
841        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
842         SuppressUnmanagedCodeSecurity]
843        private static extern int caca_set_dither_antialias(IntPtr d, string s);
844        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
845         SuppressUnmanagedCodeSecurity]
846        private static extern string[] caca_get_dither_antialias_list(IntPtr d);
847        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
848         SuppressUnmanagedCodeSecurity]
849        private static extern int caca_set_dither_color(IntPtr d, string s);
850        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
851         SuppressUnmanagedCodeSecurity]
852        private static extern string[] caca_get_dither_color_list(IntPtr d);
853        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
854         SuppressUnmanagedCodeSecurity]
855        private static extern int caca_set_dither_charset(IntPtr d, string s);
856        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
857         SuppressUnmanagedCodeSecurity]
858        private static extern string[] caca_get_dither_charset_list(IntPtr d);
859        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
860         SuppressUnmanagedCodeSecurity]
861        private static extern int caca_set_dither_mode(IntPtr d, string s);
862        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
863         SuppressUnmanagedCodeSecurity]
864        private static extern string[] caca_get_dither_mode_list(IntPtr d);
865
866
867        public int setBrightness(float b)
868        {
869            return caca_set_dither_brightness(_dither, b);
870        }
871
872        public int setGamma(float g)
873        {
874            return caca_set_dither_gamma(_dither, g);
875        }
876
877        public int setContrast(float c)
878        {
879            return caca_set_dither_contrast(_dither, c);
880        }
881
882        public int setInvert(int i)
883        {
884            return caca_set_dither_invert(_dither, i);
885        }
886
887        public int setAntialias(string s)
888        {
889            return caca_set_dither_antialias(_dither, s);
890        }
891
892        public int setColor(string s)
893        {
894            return caca_set_dither_color(_dither, s);
895        }
896
897        public int setCharset(string s)
898        {
899            return caca_set_dither_charset(_dither, s);
900        }
901
902        public int setMode(string s)
903        {
904            return caca_set_dither_mode(_dither, s);
905        }
906
907        /* <FIXME> */
908        public string[] getAntialiasList()
909        {
910            return caca_get_dither_antialias_list(_dither);
911        }
912
913        public string[] getColorList()
914        {
915            return caca_get_dither_color_list(_dither);
916        }
917
918        public string[] getCharsetList()
919        {
920            return caca_get_dither_charset_list(_dither);
921        }
922
923        public string[] getModeList()
924        {
925            return caca_get_dither_mode_list(_dither);
926        }
927
928        /* </FIXME> */
929    }
930
931    public class CacaFont : IDisposable
932    {
933        private IntPtr _font;
934        private GCHandle _gch;
935
936        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
937         SuppressUnmanagedCodeSecurity]
938        private static extern IntPtr caca_load_font(IntPtr data, uint len);
939        public CacaFont(string s)
940        {
941            IntPtr name = Marshal.StringToHGlobalAnsi(s);
942            _font = caca_load_font(name, 0);
943            Marshal.FreeHGlobal(name);
944        }
945
946        public CacaFont(byte[] buf)
947        {
948            GCHandle _gch = GCHandle.Alloc(buf, GCHandleType.Pinned);
949            _font = caca_load_font(_gch.AddrOfPinnedObject(),
950                                    (uint)buf.Length);
951        }
952
953        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
954         SuppressUnmanagedCodeSecurity]
955        private static extern int caca_free_font(IntPtr d);
956        public void Dispose()
957        {
958            caca_free_font(_font);
959            _gch.Free();
960            GC.SuppressFinalize(this);
961        }
962
963        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
964         SuppressUnmanagedCodeSecurity]
965        private static extern IntPtr caca_get_font_list();
966        public static string[] getList()
967        {
968            IntPtr l = caca_get_font_list();
969
970            int size;
971            for(size = 0; true; size++)
972                if(Marshal.ReadIntPtr(l, IntPtr.Size * size) == IntPtr.Zero)
973                    break;
974
975            string[] ret = new string[size];
976            for(int i = 0; i < size; i++)
977            {
978                IntPtr s = Marshal.ReadIntPtr(l, IntPtr.Size * i);
979                ret[i] = Marshal.PtrToStringAnsi(s);
980            }
981
982            return ret;
983        }
984
985        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
986         SuppressUnmanagedCodeSecurity]
987        private static extern int caca_get_font_width(IntPtr font);
988        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
989         SuppressUnmanagedCodeSecurity]
990        private static extern int caca_get_font_height(IntPtr font);
991        public Size Size
992        {
993            get { return new Size(caca_get_font_width(_font),
994                                  caca_get_font_height(_font)); }
995        }
996
997        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
998         SuppressUnmanagedCodeSecurity]
999        private static extern IntPtr caca_get_font_blocks(IntPtr font);
1000        public int[,] getBlocks()
1001        {
1002            IntPtr l = caca_get_font_blocks(_font);
1003
1004            int size;
1005            for(size = 1; true; size += 2)
1006                if(Marshal.ReadIntPtr(l, IntPtr.Size * size) == IntPtr.Zero)
1007                    break;
1008
1009            int[,] ret = new int[size,2];
1010            for(int i = 0; i < size; i++)
1011            {
1012                ret[i,0] = (int)Marshal.ReadIntPtr(l, IntPtr.Size * i * 2);
1013                ret[i,1] = (int)Marshal.ReadIntPtr(l, IntPtr.Size * i * 2 + 1);
1014            }
1015
1016            return ret;
1017        }
1018
1019        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1020         SuppressUnmanagedCodeSecurity]
1021        private static extern int caca_render_canvas(IntPtr cv, IntPtr f,
1022                                                      IntPtr buf, int w, int h,
1023                                                      int pitch);
1024        public int Render(CacaCanvas cv, uint[,] buf, int pitch)
1025        {
1026            GCHandle gch = GCHandle.Alloc(buf, GCHandleType.Pinned);
1027            int ret = caca_render_canvas(cv._c_cv, _font,
1028                                          gch.AddrOfPinnedObject(),
1029                                          buf.GetLength(0), buf.GetLength(1),
1030                                          pitch);
1031            gch.Free();
1032            return ret;
1033        }
1034    }
1035
1036    public class CacaEvent : IDisposable
1037    {
1038        public IntPtr cevent;
1039        private IntPtr _utf8;
1040
1041        public CacaEvent()
1042        {
1043            cevent = Marshal.AllocHGlobal(32);
1044            _utf8 = Marshal.AllocHGlobal(8);
1045        }
1046
1047        public void Dispose()
1048        {
1049            Marshal.FreeHGlobal(cevent);
1050            Marshal.FreeHGlobal(_utf8);
1051            GC.SuppressFinalize(this);
1052        }
1053
1054        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1055         SuppressUnmanagedCodeSecurity]
1056        private static extern int caca_get_event_type(IntPtr ev);
1057        public CacaEventType Type
1058        {
1059            get { return (CacaEventType)caca_get_event_type(cevent); }
1060        }
1061
1062        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1063         SuppressUnmanagedCodeSecurity]
1064        private static extern int caca_get_event_key_ch(IntPtr ev);
1065        public int KeyCh
1066        {
1067            get { return caca_get_event_key_ch(cevent); }
1068        }
1069
1070        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1071         SuppressUnmanagedCodeSecurity]
1072        private static extern uint caca_get_event_key_utf32(IntPtr ev);
1073        public uint KeyUtf32
1074        {
1075            get { return caca_get_event_key_utf32(cevent); }
1076        }
1077
1078        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1079         SuppressUnmanagedCodeSecurity]
1080        private static extern int caca_get_event_key_utf8(IntPtr ev,
1081                                                          IntPtr _utf8);
1082        public string KeyUtf8
1083        {
1084            get
1085            {
1086                caca_get_event_key_utf8(cevent, _utf8);
1087                return Marshal.PtrToStringAnsi(_utf8);
1088            }
1089        }
1090
1091        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1092         SuppressUnmanagedCodeSecurity]
1093        private static extern int caca_get_event_mouse_button(IntPtr ev);
1094        public int MouseButton
1095        {
1096            get { return caca_get_event_mouse_button(cevent); }
1097        }
1098
1099        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1100         SuppressUnmanagedCodeSecurity]
1101        private static extern int caca_get_event_mouse_x(IntPtr ev);
1102        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1103         SuppressUnmanagedCodeSecurity]
1104        private static extern int caca_get_event_mouse_y(IntPtr ev);
1105        public Point MousePos
1106        {
1107            get { return new Point(caca_get_event_mouse_x(cevent),
1108                                   caca_get_event_mouse_y(cevent)); }
1109        }
1110
1111        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1112         SuppressUnmanagedCodeSecurity]
1113        private static extern int caca_get_event_resize_width(IntPtr ev);
1114        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1115         SuppressUnmanagedCodeSecurity]
1116        private static extern int caca_get_event_resize_height(IntPtr ev);
1117        public Size ResizeSize
1118        {
1119            get { return new Size(caca_get_event_resize_width(cevent),
1120                                  caca_get_event_resize_height(cevent)); }
1121        }
1122    }
1123
1124    public class CacaDisplay : IDisposable
1125    {
1126        private CacaCanvas _cv;
1127        public CacaCanvas Canvas { get { return _cv; } }
1128
1129        private IntPtr _c_cv;
1130        private IntPtr _c_dp;
1131
1132        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1133         SuppressUnmanagedCodeSecurity]
1134        private static extern IntPtr caca_create_display(IntPtr cv);
1135        public CacaDisplay(CacaCanvas cv)
1136        {
1137            _cv = cv;
1138            _c_cv = _cv._c_cv;
1139            _c_dp = caca_create_display(_c_cv);
1140        }
1141
1142        public CacaDisplay()
1143        {
1144            /* XXX: we do not call caca_create_display() with a NULL
1145             * argument because it's then impossible to create a CacaCanvas
1146             * and I don't want to add a weird constructor */
1147            _cv = new CacaCanvas();
1148            _c_cv = _cv._c_cv;
1149            _c_dp = caca_create_display(_c_cv);
1150        }
1151
1152        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1153         SuppressUnmanagedCodeSecurity]
1154        private static extern int caca_free_display(IntPtr dp);
1155        public void Dispose()
1156        {
1157            caca_free_display(_c_dp);
1158            GC.SuppressFinalize(this);
1159        }
1160
1161        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1162         SuppressUnmanagedCodeSecurity]
1163        private static extern int caca_refresh_display(IntPtr dp);
1164        public void Refresh()
1165        {
1166            caca_refresh_display(_c_dp);
1167        }
1168
1169        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1170         SuppressUnmanagedCodeSecurity]
1171        private static extern int caca_set_display_time(IntPtr dp, int d);
1172        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1173         SuppressUnmanagedCodeSecurity]
1174        private static extern int caca_get_display_time(IntPtr dp);
1175        public int DisplayTime
1176        {
1177            get { return caca_get_display_time(_c_dp); }
1178            set { caca_set_display_time(_c_dp, value); }
1179        }
1180
1181        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1182         SuppressUnmanagedCodeSecurity]
1183        private static extern int caca_get_event(IntPtr dp, uint t,
1184                                                 IntPtr cevent,
1185                                                 int timeout);
1186        public CacaEvent getEvent(CacaEventType t, int timeout)
1187        {
1188            CacaEvent e = new CacaEvent();
1189            caca_get_event(_c_dp, (uint)t, e.cevent, timeout);
1190            return e;
1191        }
1192
1193        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1194         SuppressUnmanagedCodeSecurity]
1195        private static extern int caca_get_display_width(IntPtr dp);
1196        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1197         SuppressUnmanagedCodeSecurity]
1198        private static extern int caca_get_display_height(IntPtr dp);
1199        public Size Size
1200        {
1201            get { return new Size(caca_get_display_width(_c_dp),
1202                                  caca_get_display_height(_c_dp)); }
1203        }
1204
1205        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1206         SuppressUnmanagedCodeSecurity]
1207        private static extern int caca_set_display_title(IntPtr dp, string t);
1208        public string Title
1209        {
1210            set { caca_set_display_title(_c_dp, value); }
1211        }
1212
1213        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1214         SuppressUnmanagedCodeSecurity]
1215        private static extern int caca_set_mouse(IntPtr k, bool status);
1216        public bool Mouse
1217        {
1218            set { caca_set_mouse(_c_dp, value); }
1219        }
1220
1221        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1222         SuppressUnmanagedCodeSecurity]
1223        private static extern int caca_get_mouse_x(IntPtr k);
1224        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1225         SuppressUnmanagedCodeSecurity]
1226        private static extern int caca_get_mouse_y(IntPtr k);
1227        public Point MousePos
1228        {
1229            get { return new Point(caca_get_mouse_x(_c_dp),
1230                                   caca_get_mouse_y(_c_dp)); }
1231        }
1232
1233        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
1234         SuppressUnmanagedCodeSecurity]
1235        private static extern int caca_set_cursor(IntPtr k, bool status);
1236        public bool Cursor
1237        {
1238            set { caca_set_cursor(_c_dp, value); }
1239        }
1240    }
1241}
1242
Note: See TracBrowser for help on using the repository browser.