Ignore:
Timestamp:
Sep 27, 2008, 4:11:36 PM (12 years ago)
Author:
Sam Hocevar
Message:

Continuing the libcucul-libcaca merge.

File:
1 edited

Legend:

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

    r2307 r2822  
    1919using System.Drawing;
    2020
    21 using Cucul;
    22 
    2321namespace Caca
    2422{
     
    2826        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
    2927         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]
    3036        private static extern IntPtr caca_get_version();
    3137        public static string getVersion()
     
    3339            return Marshal.PtrToStringAnsi(caca_get_version());
    3440        }
     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;
    3565    }
    3666
     
    111141    }
    112142
     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
    1131036    public class CacaEvent : IDisposable
    1141037    {
     
    2011124    public class CacaDisplay : IDisposable
    2021125    {
    203         private CuculCanvas _cv;
    204         public CuculCanvas Canvas { get { return _cv; } }
     1126        private CacaCanvas _cv;
     1127        public CacaCanvas Canvas { get { return _cv; } }
    2051128
    2061129        private IntPtr _c_cv;
     
    2101133         SuppressUnmanagedCodeSecurity]
    2111134        private static extern IntPtr caca_create_display(IntPtr cv);
    212         public CacaDisplay(CuculCanvas cv)
     1135        public CacaDisplay(CacaCanvas cv)
    2131136        {
    2141137            _cv = cv;
     
    2201143        {
    2211144            /* XXX: we do not call caca_create_display() with a NULL
    222              * argument because it's then impossible to create a CuculCanvas
     1145             * argument because it's then impossible to create a CacaCanvas
    2231146             * and I don't want to add a weird constructor */
    224             _cv = new CuculCanvas();
     1147            _cv = new CacaCanvas();
    2251148            _c_cv = _cv._c_cv;
    2261149            _c_dp = caca_create_display(_c_cv);
Note: See TracChangeset for help on using the changeset viewer.