Changeset 2867 for libcaca/trunk


Ignore:
Timestamp:
Oct 5, 2008, 2:56:17 AM (12 years ago)
Author:
Sam Hocevar
Message:

Split the C# bindings into separate files.

Location:
libcaca/trunk
Files:
6 added
4 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/csharp/Caca.cs

    r2822 r2867  
    3939            return Marshal.PtrToStringAnsi(caca_get_version());
    4040        }
    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         }
    124041    }
    124142}
  • libcaca/trunk/csharp/Makefile.am

    r2822 r2867  
    33cacadir = $(libdir)/caca-sharp
    44
    5 caca_sources = $(srcdir)/AssemblyInfo.cs $(srcdir)/Caca.cs
     5caca_sources = \
     6        $(srcdir)/AssemblyInfo.cs \
     7        $(srcdir)/Caca.cs \
     8        $(srcdir)/Attr.cs \
     9        $(srcdir)/Canvas.cs \
     10        $(srcdir)/Display.cs \
     11        $(srcdir)/Dither.cs \
     12        $(srcdir)/Event.cs \
     13        $(srcdir)/Font.cs
    614
    715if USE_CSHARP
  • libcaca/trunk/csharp/test.cs

    r2822 r2867  
    2121using Caca;
    2222
    23 class DemoCanvas : CacaCanvas
     23class DemoCanvas : Canvas
    2424{
    2525    private uint[,] image;
    2626
    2727    private DateTime startTime;
    28     private CacaDither d;
    29     private CacaCanvas scroll;
     28    private Dither d;
     29    private Canvas scroll;
    3030
    3131    public DemoCanvas()
     
    3535        string message = " --- POWERED BY LIBCACA --- OLDSCHOOL TEXT EFFECTS ARE 100% PURE WIN";
    3636
    37         scroll = new CacaCanvas(new Size(message.Length, 1));
    38         scroll.setColorAnsi(Libcaca.WHITE, Libcaca.TRANSPARENT);
     37        scroll = new Canvas(new Size(message.Length, 1));
     38        scroll.setColorAnsi(AnsiColor.WHITE, AnsiColor.TRANSPARENT);
    3939        scroll.putStr(new Point(0, 0), message);
    4040
    41         CacaFont f = new CacaFont(CacaFont.getList()[1]);
     41        Caca.Font f = new Caca.Font(Caca.Font.getList()[1]);
    4242        int w = f.Size.Width * message.Length;
    4343        int h = f.Size.Height;
    4444        image = new uint[w, h];
    45         d = new CacaDither(32, new Size(w, h), w * 4,
     45        d = new Dither(32, new Size(w, h), w * 4,
    4646                            0xff00, 0xff0000, 0xff000000, 0xff);
    4747        f.Render(scroll, image, image.GetLength(0) * 4);
     
    5555        Clear();
    5656
    57         setColorAnsi(Libcaca.WHITE, Libcaca.BLACK);
     57        setColorAnsi(AnsiColor.WHITE, AnsiColor.BLACK);
    5858        for(int i = 0; i < barCount; i++)
    5959        {
     
    6363            Point p2 = new Point(Size.Width - 1, (int)v);
    6464
    65             setColorAnsi((uint)(i + 9), Libcaca.BLACK);
     65            setColorAnsi((uint)(i + 9), AnsiColor.BLACK);
    6666            /* drawLine is already clipped, we don't care about overflows */
    6767            drawLine(p1 + new Size(0, -2), p2 + new Size(0, -2), '-');
     
    7979        ditherBitmap(new Rectangle(12 * w - x, h / 2 - y, w * 12, y * 2), d, image);
    8080
    81         setColorAnsi(Libcaca.WHITE, Libcaca.BLUE);
     81        setColorAnsi(AnsiColor.WHITE, AnsiColor.BLUE);
    8282        putStr(new Point(-30, -2) + Size, " -=[ Powered by libcaca ]=- ");
    83         setColorAnsi(Libcaca.WHITE, Libcaca.BLACK);
     83        setColorAnsi(AnsiColor.WHITE, AnsiColor.BLACK);
    8484    }
    8585}
    8686
    87 class DemoDisplay : CacaDisplay
     87class DemoDisplay : Display
    8888{
    8989    private DemoCanvas cv;
     
    9898    public void EventLoop()
    9999    {
    100         CacaEvent ev;
     100        Event ev;
    101101
    102         while((ev = getEvent(CacaEventType.KEY_RELEASE, 10)).Type == 0)
     102        while((ev = getEvent(EventType.KEY_RELEASE, 10)).Type == 0)
    103103        {
    104104            cv.Draw();
  • libcaca/trunk/msvc/caca-sharp.csproj

    r2822 r2867  
    3636  <ItemGroup>
    3737    <Compile Include="..\csharp\Caca.cs" />
     38    <Compile Include="..\csharp\Canvas.cs" />
     39    <Compile Include="..\csharp\Attr.cs" />
     40    <Compile Include="..\csharp\Font.cs" />
     41    <Compile Include="..\csharp\Dither.cs" />
     42    <Compile Include="..\csharp\Display.cs" />
     43    <Compile Include="..\csharp\Event.cs" />
    3844    <Compile Include="..\csharp\AssemblyInfo.cs" />
    3945  </ItemGroup>
Note: See TracChangeset for help on using the changeset viewer.