source: libcaca/trunk/caca-sharp/Canvas.cs @ 3587

Last change on this file since 3587 was 3587, checked in by Sam Hocevar, 10 years ago

Rename caca_get_cursor_x() and caca_get_cursor_y() to caca_wherex() and
caca_wherey(), in order to match the old <conio.h> naming scheme.

File size: 24.9 KB
Line 
1/*
2 *  libcaca       .NET bindings for libcaca
3 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
4 *                2007-2009 Sam Hocevar <sam@hocevar.net>
5 *                All Rights Reserved
6 *
7 *  $Id$
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    public enum AnsiColor
24    {
25        BLACK = 0x00,
26        BLUE = 0x01,
27        GREEN = 0x02,
28        CYAN = 0x03,
29        RED = 0x04,
30        MAGENTA = 0x05,
31        BROWN = 0x06,
32        LIGHTGRAY = 0x07,
33        DARKGRAY = 0x08,
34        LIGHTBLUE = 0x09,
35        LIGHTGREEN = 0x0a,
36        LIGHTCYAN = 0x0b,
37        LIGHTRED = 0x0c,
38        LIGHTMAGENTA = 0x0d,
39        YELLOW = 0x0e,
40        WHITE = 0x0f,
41        DEFAULT = 0x10,
42        TRANSPARENT = 0x20,
43    }
44
45    public enum AnsiStyle
46    {
47        BOLD = 0x01,
48        ITALICS = 0x02,
49        UNDERLINE = 0x04,
50        BLINK = 0x08,
51    }
52
53    public class Canvas : IDisposable
54    {
55        public readonly IntPtr _c_cv;
56
57        /* libcaca basic functions */
58
59        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
60         SuppressUnmanagedCodeSecurity]
61        private static extern IntPtr caca_create_canvas(int w, int h);
62        public Canvas()
63        {
64            _c_cv = caca_create_canvas(0, 0);
65        }
66
67        public Canvas(Size s)
68        {
69            _c_cv = caca_create_canvas(s.Width, s.Height);
70        }
71
72        public Canvas(int w, int h)
73        {
74            _c_cv = caca_create_canvas(h, w);
75        }
76
77        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
78         SuppressUnmanagedCodeSecurity]
79        private static extern int caca_free_canvas(IntPtr cv);
80        public void Dispose()
81        {
82           /* FIXME: don't destroy ourselves if we're attached */
83           caca_free_canvas(_c_cv);
84           GC.SuppressFinalize(this);
85        }
86
87        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
88         SuppressUnmanagedCodeSecurity]
89        private static extern int caca_set_canvas_size(IntPtr cv,
90                                                        int w, int h);
91        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
92         SuppressUnmanagedCodeSecurity]
93        private static extern int caca_get_canvas_width(IntPtr cv);
94        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
95         SuppressUnmanagedCodeSecurity]
96        private static extern int caca_get_canvas_height(IntPtr cv);
97        public Size Size
98        {
99            get { return new Size(caca_get_canvas_width(_c_cv),
100                                  caca_get_canvas_height(_c_cv)); }
101            set { caca_set_canvas_size(_c_cv, value.Width, value.Height); }
102        }
103
104        public Rectangle Rectangle
105        {
106            get { return new Rectangle(0, 0, caca_get_canvas_width(_c_cv),
107                                             caca_get_canvas_height(_c_cv)); }
108            set { caca_set_canvas_size(_c_cv, value.Width, value.Height); }
109        }
110
111        /* canvas drawing */
112
113        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
114         SuppressUnmanagedCodeSecurity]
115        private static extern int caca_gotoxy(IntPtr cv, int x, int y);
116        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
117         SuppressUnmanagedCodeSecurity]
118        private static extern int caca_wherex(IntPtr cv);
119        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
120         SuppressUnmanagedCodeSecurity]
121        private static extern int caca_wherey(IntPtr cv);
122        public Point Cursor
123        {
124            get { return new Point(caca_wherex(_c_cv), caca_wherey(_c_cv)); }
125            set { caca_gotoxy(_c_cv, value.X, value.Y); }
126        }
127
128        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
129         SuppressUnmanagedCodeSecurity]
130        private static extern int caca_put_char(IntPtr cv,
131                                                 int x, int y, uint c);
132        public int putChar(Point p, uint c)
133        {
134            return caca_put_char(_c_cv, p.X, p.Y, c);
135        }
136
137        public int putChar(int x, int y, uint c)
138        {
139            return caca_put_char(_c_cv, x, y, c);
140        }
141
142        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
143         SuppressUnmanagedCodeSecurity]
144        private static extern uint caca_get_char(IntPtr cv, int x, int y);
145        public uint getChar(Point p)
146        {
147            return caca_get_char(_c_cv, p.X, p.Y);
148        }
149
150        public uint getChar(int x, int y)
151        {
152            return caca_get_char(_c_cv, x, y);
153        }
154
155        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
156         SuppressUnmanagedCodeSecurity]
157        private static extern int caca_put_str(IntPtr cv,
158                                                int x, int y, string c);
159        public int putStr(Point p, string c)
160        {
161            return caca_put_str(_c_cv, p.X, p.Y, c);
162        }
163
164        public int putStr(int x, int y, string c)
165        {
166            return caca_put_str(_c_cv, x, y, c);
167        }
168
169        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
170         SuppressUnmanagedCodeSecurity]
171        private static extern int caca_get_attr(IntPtr cv, int x, int y);
172        public int getAttr(Point p)
173        {
174            return caca_get_attr(_c_cv, p.X, p.Y);
175        }
176
177        public int getAttr(int x, int y)
178        {
179            return caca_get_attr(_c_cv, x, y);
180        }
181
182        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
183         SuppressUnmanagedCodeSecurity]
184        private static extern int caca_set_attr(IntPtr cv, uint a);
185        public int setAttr(uint a)
186        {
187            return caca_set_attr(_c_cv, a);
188        }
189
190        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
191         SuppressUnmanagedCodeSecurity]
192        private static extern int caca_put_attr(IntPtr cv,
193                                                 int x, int y, uint a);
194        public int putAttr(Point p, uint a)
195        {
196            return caca_put_attr(_c_cv, p.X, p.Y, a);
197        }
198
199        public int putAttr(int x, int y, uint a)
200        {
201            return caca_put_attr(_c_cv, x, y, a);
202        }
203
204        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
205         SuppressUnmanagedCodeSecurity]
206        private static extern int caca_set_color_ansi(IntPtr cv,
207                                                       byte fg, byte bg);
208        public int setColorAnsi(AnsiColor fg, AnsiColor bg)
209        {
210            return caca_set_color_ansi(_c_cv, (byte)fg, (byte)bg);
211        }
212
213        public int setColorAnsi(uint fg, AnsiColor bg)
214        {
215            return caca_set_color_ansi(_c_cv, (byte)fg, (byte)bg);
216        }
217
218        public int setColorAnsi(AnsiColor fg, uint bg)
219        {
220            return caca_set_color_ansi(_c_cv, (byte)fg, (byte)bg);
221        }
222
223        public int setColorAnsi(uint fg, uint bg)
224        {
225            return caca_set_color_ansi(_c_cv, (byte)fg, (byte)bg);
226        }
227
228        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
229         SuppressUnmanagedCodeSecurity]
230        private static extern int caca_set_color_argb(IntPtr cv,
231                                                       uint fg, uint bg);
232        public int setColorArgb(uint fg, uint bg)
233        {
234            return caca_set_color_argb(_c_cv, fg, bg);
235        }
236
237        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
238         SuppressUnmanagedCodeSecurity]
239        private static extern int caca_clear_canvas(IntPtr cv);
240        public int Clear()
241        {
242            return caca_clear_canvas(_c_cv);
243        }
244
245        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
246         SuppressUnmanagedCodeSecurity]
247        private static extern int caca_set_canvas_handle(IntPtr cv,
248                                                          int x, int y);
249        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
250         SuppressUnmanagedCodeSecurity]
251        private static extern int caca_get_canvas_handle_x(IntPtr cv);
252        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
253         SuppressUnmanagedCodeSecurity]
254        private static extern int caca_get_canvas_handle_y(IntPtr cv);
255        public Point Handle
256        {
257            get { return new Point(caca_get_canvas_handle_x(_c_cv),
258                                   caca_get_canvas_handle_y(_c_cv)); }
259            set { caca_set_canvas_handle(_c_cv, value.X, value.Y); }
260        }
261
262        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
263         SuppressUnmanagedCodeSecurity]
264        private static extern int caca_blit(IntPtr cv, int x, int y,
265                                             IntPtr cv1, IntPtr cv2);
266        public int Blit(Point p, Canvas canvas)
267        {
268            return caca_blit(_c_cv, p.X, p.Y, canvas._c_cv, IntPtr.Zero);
269        }
270
271        public int Blit(Point p, Canvas cv, Canvas mask)
272        {
273            return caca_blit(_c_cv, p.X, p.Y, cv._c_cv, mask._c_cv);
274        }
275
276        public int Blit(int x, int y, Canvas canvas)
277        {
278            return caca_blit(_c_cv, x, y, canvas._c_cv, IntPtr.Zero);
279        }
280
281        public int Blit(int x, int y, Canvas cv, Canvas mask)
282        {
283            return caca_blit(_c_cv, x, y, cv._c_cv, mask._c_cv);
284        }
285
286        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
287         SuppressUnmanagedCodeSecurity]
288        private static extern int caca_set_canvas_boundaries(IntPtr cv,
289                                                              int x, int y,
290                                                              int h, int w);
291        public int setBoundaries(Rectangle r)
292        {
293            return caca_set_canvas_boundaries(_c_cv, r.X, r.Y,
294                                               r.Width, r.Height);
295        }
296
297        public int setBoundaries(int x, int y, int w, int h)
298        {
299            return caca_set_canvas_boundaries(_c_cv, x, y, w, h);
300        }
301
302        /* canvas transformation */
303
304        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
305         SuppressUnmanagedCodeSecurity]
306        private static extern int caca_invert(IntPtr cv);
307        public int Invert()
308        {
309            return caca_invert(_c_cv);
310        }
311
312        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
313         SuppressUnmanagedCodeSecurity]
314        private static extern int caca_flip(IntPtr cv);
315        public int Flip()
316        {
317            return caca_flip(_c_cv);
318        }
319
320        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
321         SuppressUnmanagedCodeSecurity]
322        private static extern int caca_flop(IntPtr cv);
323        public int Flop()
324        {
325            return caca_flop(_c_cv);
326        }
327
328        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
329         SuppressUnmanagedCodeSecurity]
330        private static extern int caca_rotate_180(IntPtr cv);
331        public int Rotate180()
332        {
333            return caca_rotate_180(_c_cv);
334        }
335
336        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
337         SuppressUnmanagedCodeSecurity]
338        private static extern int caca_rotate_left(IntPtr cv);
339        public int RotateLeft()
340        {
341            return caca_rotate_left(_c_cv);
342        }
343
344        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
345         SuppressUnmanagedCodeSecurity]
346        private static extern int caca_rotate_right(IntPtr cv);
347        public int RotateRight()
348        {
349            return caca_rotate_right(_c_cv);
350        }
351
352        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
353         SuppressUnmanagedCodeSecurity]
354        private static extern int caca_stretch_left(IntPtr cv);
355        public int StretchLeft()
356        {
357            return caca_stretch_left(_c_cv);
358        }
359
360        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
361         SuppressUnmanagedCodeSecurity]
362        private static extern int caca_stretch_right(IntPtr cv);
363        public int StretchRight()
364        {
365            return caca_stretch_right(_c_cv);
366        }
367
368        /* primitives drawing */
369
370        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
371         SuppressUnmanagedCodeSecurity]
372        private static extern int caca_draw_line(IntPtr cv, int x1, int y1,
373                                                  int x2, int y2, uint c);
374        public int drawLine(Point p1, Point p2, uint c)
375        {
376            return caca_draw_line(_c_cv, p1.X, p1.Y, p2.X, p2.Y, c);
377        }
378
379        public int drawLine(int x1, int y1, int x2, int y2, uint c)
380        {
381            return caca_draw_line(_c_cv, x1, y1, x2, y2, c);
382        }
383
384        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
385         SuppressUnmanagedCodeSecurity]
386        private static extern int caca_draw_polyline(IntPtr cv, int[] x,
387                                                      int[] y, int n, uint c);
388        public int drawPolyline(Point[] lp, uint c)
389        {
390            int[] lx = new int[lp.Length];
391            int[] ly = new int[lp.Length];
392            for(int i = 0; i < lp.Length; i++)
393            {
394                lx[i] = lp[i].X;
395                ly[i] = lp[i].Y;
396            }
397            return caca_draw_polyline(_c_cv, lx, ly, lp.Length - 1, c);
398        }
399
400        public int drawPolyline(int[] lx, int[] ly, uint c)
401        {
402            if(lx.Length != ly.Length)
403                return -1;
404
405            return caca_draw_polyline(_c_cv, lx, ly, lx.Length - 1, c);
406        }
407
408        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
409         SuppressUnmanagedCodeSecurity]
410        private static extern int caca_draw_thin_line(IntPtr cv, int x1,
411                                                       int y1, int x2, int y2);
412        public int drawThinLine(Point p1, Point p2)
413        {
414            return caca_draw_thin_line(_c_cv, p1.X, p1.Y, p2.X, p2.Y);
415        }
416
417        public int drawThinLine(int x1, int y1, int x2, int y2)
418        {
419            return caca_draw_thin_line(_c_cv, x1, y1, x2, y2);
420        }
421
422        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
423         SuppressUnmanagedCodeSecurity]
424        private static extern int caca_draw_thin_polyline(IntPtr cv, int[] x,
425                                                           int[] y, int n);
426        public int drawThinPolyline(Point[] lp)
427        {
428            int[] lx = new int[lp.Length];
429            int[] ly = new int[lp.Length];
430            for(int i = 0; i < lp.Length; i++)
431            {
432                lx[i] = lp[i].X;
433                ly[i] = lp[i].Y;
434            }
435            return caca_draw_thin_polyline(_c_cv, lx, ly, lp.Length - 1);
436        }
437
438        public int drawThinPolyline(int[] lx, int[] ly)
439        {
440            if(lx.Length != ly.Length)
441                return -1;
442
443            return caca_draw_thin_polyline(_c_cv, lx, ly, lx.Length - 1);
444        }
445
446        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
447         SuppressUnmanagedCodeSecurity]
448        private static extern int caca_draw_circle(IntPtr cv, int x, int y,
449                                                    int r, uint c);
450        public int drawCircle(Point p, int r, uint c)
451        {
452            return caca_draw_circle(_c_cv, p.X, p.Y, r, c);
453        }
454
455        public int drawCircle(int x, int y, int r, uint c)
456        {
457            return caca_draw_circle(_c_cv, x, y, r, c);
458        }
459
460        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
461         SuppressUnmanagedCodeSecurity]
462        private static extern int caca_draw_ellipse(IntPtr cv, int x, int y,
463                                                     int a, int b, uint c);
464        public int drawEllipse(Point p, int a, int b, uint c)
465        {
466            return caca_draw_ellipse(_c_cv, p.X, p.Y, a, b, c);
467        }
468
469        public int drawEllipse(int x, int y, int a, int b, uint c)
470        {
471            return caca_draw_ellipse(_c_cv, x, y, a, b, c);
472        }
473
474        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
475         SuppressUnmanagedCodeSecurity]
476        private static extern int caca_draw_thin_ellipse(IntPtr cv,
477                                                          int x, int y,
478                                                          int a, int b);
479        public int drawThinEllipse(Point p, int a, int b)
480        {
481            return caca_draw_thin_ellipse(_c_cv, p.X, p.Y, a, b);
482        }
483
484        public int drawThinEllipse(int x, int y, int a, int b)
485        {
486            return caca_draw_thin_ellipse(_c_cv, x, y, a, b);
487        }
488
489        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
490         SuppressUnmanagedCodeSecurity]
491        private static extern int caca_fill_ellipse(IntPtr cv, int x, int y,
492                                                     int a, int b, uint c);
493        public int fillEllipse(Point p, int a, int b, uint c)
494        {
495            return caca_fill_ellipse(_c_cv, p.X, p.Y, a, b, c);
496        }
497
498        public int fillEllipse(int x, int y, int a, int b, uint c)
499        {
500            return caca_fill_ellipse(_c_cv, x, y, a, b, c);
501        }
502
503        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
504         SuppressUnmanagedCodeSecurity]
505        private static extern int caca_draw_box(IntPtr cv, int x, int y,
506                                                 int w, int h, uint c);
507        public int drawBox(Rectangle r, uint c)
508        {
509            return caca_draw_box(_c_cv, r.X, r.Y, r.Width, r.Height, c);
510        }
511
512        public int drawBox(int x, int y, int w, int h, uint c)
513        {
514            return caca_draw_box(_c_cv, x, y, w, h, c);
515        }
516
517        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
518         SuppressUnmanagedCodeSecurity]
519        private static extern int caca_draw_thin_box(IntPtr cv, int x, int y,
520                                                      int w, int h);
521        public int drawThinBox(Rectangle r)
522        {
523            return caca_draw_thin_box(_c_cv, r.X, r.Y, r.Width, r.Height);
524        }
525
526        public int drawThinBox(int x, int y, int w, int h)
527        {
528            return caca_draw_thin_box(_c_cv, x, y, w, h);
529        }
530
531        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
532         SuppressUnmanagedCodeSecurity]
533        private static extern int caca_draw_cp437_box(IntPtr cv, int x, int y,
534                                                       int w, int h);
535        public int drawCp437Box(Rectangle r)
536        {
537            return caca_draw_cp437_box(_c_cv, r.X, r.Y, r.Width, r.Height);
538        }
539
540        public int drawCp437Box(int x, int y, int w, int h)
541        {
542            return caca_draw_cp437_box(_c_cv, x, y, w, h);
543        }
544
545        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
546         SuppressUnmanagedCodeSecurity]
547        private static extern int caca_fill_box(IntPtr cv, int x, int y,
548                                                 int w, int h, uint c);
549        public int fillBox(Rectangle r, uint c)
550        {
551            return caca_fill_box(_c_cv, r.X, r.Y, r.Width, r.Height, c);
552        }
553
554        public int fillBox(int x, int y, int w, int h, uint c)
555        {
556            return caca_fill_box(_c_cv, x, y, w, h, c);
557        }
558
559        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
560         SuppressUnmanagedCodeSecurity]
561        private static extern int caca_draw_triangle(IntPtr cv, int x1,
562                                                      int y1, int x2, int y2,
563                                                      int x3, int y3, uint c);
564        public int drawTriangle(Point p1, Point p2, Point p3, uint c)
565        {
566            return caca_draw_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
567                                       p3.X, p3.Y, c);
568        }
569
570        public int drawTriangle(int x1, int y1, int x2, int y2,
571                                int x3, int y3, uint c)
572        {
573            return caca_draw_triangle(_c_cv, x1, y1, x2, y2, x3, y3, c);
574        }
575
576        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
577         SuppressUnmanagedCodeSecurity]
578        private static extern int caca_draw_thin_triangle(IntPtr cv,
579                                                           int x1, int y1,
580                                                           int x2, int y2,
581                                                           int x3, int y3);
582        public int drawThinTriangle(Point p1, Point p2, Point p3)
583        {
584            return caca_draw_thin_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
585                                            p3.X, p3.Y);
586        }
587
588        public int drawThinTriangle(int x1, int y1, int x2, int y2,
589                                    int x3, int y3)
590        {
591            return caca_draw_thin_triangle(_c_cv, x1, y1, x2, y2, x3, y3);
592        }
593
594        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
595         SuppressUnmanagedCodeSecurity]
596        private static extern int caca_fill_triangle(IntPtr cv, int x1,
597                                                      int y1, int x2, int y2,
598                                                      int x3, int y3, uint c);
599        public int fillTriangle(Point p1, Point p2, Point p3, uint c)
600        {
601            return caca_fill_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
602                                       p3.X, p3.Y, c);
603        }
604
605        public int fillTriangle(int x1, int y1, int x2, int y2,
606                                int x3, int y3, uint c)
607        {
608            return caca_fill_triangle(_c_cv, x1, y1, x2, y2, x3, y3, c);
609        }
610
611        /* frame handling */
612
613        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
614         SuppressUnmanagedCodeSecurity]
615        private static extern int caca_get_frame_count(IntPtr cv);
616        public int getFrameCount()
617        {
618            return caca_get_frame_count(_c_cv);
619        }
620
621        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
622         SuppressUnmanagedCodeSecurity]
623        private static extern int caca_set_frame(IntPtr cv, int f);
624        public int setFrame(int f)
625        {
626            return caca_set_frame(_c_cv, f);
627        }
628
629        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
630         SuppressUnmanagedCodeSecurity]
631        private static extern string caca_get_frame_name(IntPtr cv);
632        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
633         SuppressUnmanagedCodeSecurity]
634        private static extern int caca_set_frame_name(IntPtr cv, string n);
635        public string FrameName
636        {
637            get { return caca_get_frame_name(_c_cv); }
638            set { caca_set_frame_name(_c_cv, value); }
639        }
640
641        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
642         SuppressUnmanagedCodeSecurity]
643        private static extern int caca_create_frame(IntPtr cv, int f);
644        public int createFrame(int f)
645        {
646            return caca_create_frame(_c_cv, f);
647        }
648
649        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
650         SuppressUnmanagedCodeSecurity]
651        private static extern int caca_free_frame(IntPtr cv, int f);
652        public int freeFrame(int f)
653        {
654            return caca_free_frame(_c_cv, f);
655        }
656
657        /* bitmap dithering */
658
659        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
660         SuppressUnmanagedCodeSecurity]
661        private static extern int caca_dither_bitmap(IntPtr c, int  x, int y,
662                                                      int w, int h,
663                                                      IntPtr d, IntPtr data);
664        public int ditherBitmap(Rectangle r, Dither d, object data)
665        {
666            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
667            int ret = caca_dither_bitmap(_c_cv, r.X, r.Y, r.Width, r.Height,
668                                          d._dither, gch.AddrOfPinnedObject());
669            gch.Free();
670            return ret;
671        }
672
673        public int ditherBitmap(int x, int y, int w, int h,
674                                Dither d, object data)
675        {
676            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
677            int ret = caca_dither_bitmap(_c_cv, x, y, w, h, d._dither,
678                                          gch.AddrOfPinnedObject());
679            gch.Free();
680            return ret;
681        }
682    }
683}
684
Note: See TracBrowser for help on using the repository browser.