Changeset 2095 for libcaca/trunk


Ignore:
Timestamp:
Nov 29, 2007, 12:20:05 AM (13 years ago)
Author:
Sam Hocevar
Message:
  • Implemented the empty CuculCanvas? constructor.
  • Implemented CacaDisplay?.Canvas which acts the same as caca_get_canvas().
Location:
libcaca/trunk/csharp
Files:
2 edited

Legend:

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

    r2089 r2095  
    201201    public class CacaDisplay : IDisposable
    202202    {
    203         private IntPtr _cv;
    204         private IntPtr _dp;
     203        private CuculCanvas _cv;
     204        public CuculCanvas Canvas { get { return _cv; } }
     205
     206        private IntPtr _c_cv;
     207        private IntPtr _c_dp;
    205208
    206209        [DllImport("libcaca.dll", CallingConvention=CallingConvention.Cdecl),
     
    209212        public CacaDisplay(CuculCanvas cv)
    210213        {
    211             _cv = cv._cv;
    212             _dp = caca_create_display(_cv);
     214            _cv = cv;
     215            _c_cv = _cv._c_cv;
     216            _c_dp = caca_create_display(_c_cv);
     217        }
     218
     219        public CacaDisplay()
     220        {
     221            /* XXX: we do not call caca_create_display() with a NULL
     222             * argument because it's then impossible to create a CuculCanvas
     223             * and I don't want to add a weird constructor */
     224            _cv = new CuculCanvas();
     225            _c_cv = _cv._c_cv;
     226            _c_dp = caca_create_display(_c_cv);
    213227        }
    214228
     
    218232        public void Dispose()
    219233        {
    220             caca_free_display(_dp);
     234            caca_free_display(_c_dp);
    221235            GC.SuppressFinalize(this);
    222236        }
     
    227241        public void Refresh()
    228242        {
    229             caca_refresh_display(_dp);
     243            caca_refresh_display(_c_dp);
    230244        }
    231245
     
    238252        public int DisplayTime
    239253        {
    240             get { return caca_get_display_time(_dp); }
    241             set { caca_set_display_time(_dp, value); }
     254            get { return caca_get_display_time(_c_dp); }
     255            set { caca_set_display_time(_c_dp, value); }
    242256        }
    243257
     
    250264        {
    251265            CacaEvent e = new CacaEvent();
    252             caca_get_event(_dp, (int)t, e.cevent, timeout);
     266            caca_get_event(_c_dp, (int)t, e.cevent, timeout);
    253267            return e;
    254268        }
     
    262276        public Size Size
    263277        {
    264             get { return new Size(caca_get_display_width(_dp),
    265                                   caca_get_display_height(_dp)); }
     278            get { return new Size(caca_get_display_width(_c_dp),
     279                                  caca_get_display_height(_c_dp)); }
    266280        }
    267281
     
    271285        public string Title
    272286        {
    273             set { caca_set_display_title(_dp, value); }
     287            set { caca_set_display_title(_c_dp, value); }
    274288        }
    275289
     
    279293        public bool Mouse
    280294        {
    281             set { caca_set_mouse(_dp, value); }
     295            set { caca_set_mouse(_c_dp, value); }
    282296        }
    283297
     
    290304        public Point MousePos
    291305        {
    292             get { return new Point(caca_get_mouse_x(_dp),
    293                                    caca_get_mouse_y(_dp)); }
     306            get { return new Point(caca_get_mouse_x(_c_dp),
     307                                   caca_get_mouse_y(_c_dp)); }
    294308        }
    295309
     
    299313        public bool Cursor
    300314        {
    301             set { caca_set_cursor(_dp, value); }
     315            set { caca_set_cursor(_c_dp, value); }
    302316        }
    303317    }
  • libcaca/trunk/csharp/Cucul.cs

    r2091 r2095  
    6767    public class CuculCanvas : IDisposable
    6868    {
    69         public readonly IntPtr _cv;
     69        public readonly IntPtr _c_cv;
    7070
    7171        /* libcucul basic functions */
     
    7676        public CuculCanvas()
    7777        {
    78             _cv = cucul_create_canvas(0, 0);
     78            _c_cv = cucul_create_canvas(0, 0);
    7979        }
    8080
    8181        public CuculCanvas(Size s)
    8282        {
    83             _cv = cucul_create_canvas(s.Width, s.Height);
     83            _c_cv = cucul_create_canvas(s.Width, s.Height);
    8484        }
    8585
    8686        public CuculCanvas(int w, int h)
    8787        {
    88             _cv = cucul_create_canvas(h, w);
     88            _c_cv = cucul_create_canvas(h, w);
    8989        }
    9090
     
    9494        public void Dispose()
    9595        {
    96            cucul_free_canvas(_cv);
     96           /* FIXME: don't destroy ourselves if we're attached */
     97           cucul_free_canvas(_c_cv);
    9798           GC.SuppressFinalize(this);
    9899        }
     
    110111        public Size Size
    111112        {
    112             get { return new Size(cucul_get_canvas_width(_cv),
    113                                   cucul_get_canvas_height(_cv)); }
    114             set { cucul_set_canvas_size(_cv, value.Width, value.Height); }
     113            get { return new Size(cucul_get_canvas_width(_c_cv),
     114                                  cucul_get_canvas_height(_c_cv)); }
     115            set { cucul_set_canvas_size(_c_cv, value.Width, value.Height); }
    115116        }
    116117
    117118        public Rectangle Rectangle
    118119        {
    119             get { return new Rectangle(0, 0, cucul_get_canvas_width(_cv),
    120                                              cucul_get_canvas_height(_cv)); }
    121             set { cucul_set_canvas_size(_cv, value.Width, value.Height); }
     120            get { return new Rectangle(0, 0, cucul_get_canvas_width(_c_cv),
     121                                             cucul_get_canvas_height(_c_cv)); }
     122            set { cucul_set_canvas_size(_c_cv, value.Width, value.Height); }
    122123        }
    123124
     
    135136        public Point Cursor
    136137        {
    137             get { return new Point(cucul_get_cursor_x(_cv),
    138                                    cucul_get_cursor_y(_cv)); }
    139             set { cucul_gotoxy(_cv, value.X, value.Y); }
     138            get { return new Point(cucul_get_cursor_x(_c_cv),
     139                                   cucul_get_cursor_y(_c_cv)); }
     140            set { cucul_gotoxy(_c_cv, value.X, value.Y); }
    140141        }
    141142
     
    146147        public int putChar(Point p, int c)
    147148        {
    148             return cucul_put_char(_cv, p.X, p.Y, c);
     149            return cucul_put_char(_c_cv, p.X, p.Y, c);
    149150        }
    150151
    151152        public int putChar(int x, int y, int c)
    152153        {
    153             return cucul_put_char(_cv, x, y, c);
     154            return cucul_put_char(_c_cv, x, y, c);
    154155        }
    155156
     
    159160        public int getChar(Point p)
    160161        {
    161             return cucul_get_char(_cv, p.X, p.Y);
     162            return cucul_get_char(_c_cv, p.X, p.Y);
    162163        }
    163164
    164165        public int getChar(int x, int y)
    165166        {
    166             return cucul_get_char(_cv, x, y);
     167            return cucul_get_char(_c_cv, x, y);
    167168        }
    168169
     
    173174        public int putStr(Point p, string c)
    174175        {
    175             return cucul_put_str(_cv, p.X, p.Y, c);
     176            return cucul_put_str(_c_cv, p.X, p.Y, c);
    176177        }
    177178
    178179        public int putStr(int x, int y, string c)
    179180        {
    180             return cucul_put_str(_cv, x, y, c);
     181            return cucul_put_str(_c_cv, x, y, c);
    181182        }
    182183
     
    186187        public int getAttr(Point p)
    187188        {
    188             return cucul_get_attr(_cv, p.X, p.Y);
     189            return cucul_get_attr(_c_cv, p.X, p.Y);
    189190        }
    190191
    191192        public int getAttr(int x, int y)
    192193        {
    193             return cucul_get_attr(_cv, x, y);
     194            return cucul_get_attr(_c_cv, x, y);
    194195        }
    195196
     
    199200        public int setAttr(int a)
    200201        {
    201             return cucul_set_attr(_cv, a);
     202            return cucul_set_attr(_c_cv, a);
    202203        }
    203204
     
    208209        public int putAttr(Point p, int a)
    209210        {
    210             return cucul_put_attr(_cv, p.X, p.Y, a);
     211            return cucul_put_attr(_c_cv, p.X, p.Y, a);
    211212        }
    212213
    213214        public int putAttr(int x, int y, int a)
    214215        {
    215             return cucul_put_attr(_cv, x, y, a);
     216            return cucul_put_attr(_c_cv, x, y, a);
    216217        }
    217218
     
    222223        public int setColorAnsi(int fg, int bg)
    223224        {
    224             return cucul_set_color_ansi(_cv, (byte)fg, (byte)bg);
     225            return cucul_set_color_ansi(_c_cv, (byte)fg, (byte)bg);
    225226        }
    226227
     
    231232        public int setColorArgb(int fg, int bg)
    232233        {
    233             return cucul_set_color_argb(_cv, fg, bg);
     234            return cucul_set_color_argb(_c_cv, fg, bg);
    234235        }
    235236
     
    239240        public int Clear()
    240241        {
    241             return cucul_clear_canvas(_cv);
     242            return cucul_clear_canvas(_c_cv);
    242243        }
    243244
     
    254255        public Point Handle
    255256        {
    256             get { return new Point(cucul_get_canvas_handle_x(_cv),
    257                                    cucul_get_canvas_handle_y(_cv)); }
    258             set { cucul_set_canvas_handle(_cv, value.X, value.Y); }
     257            get { return new Point(cucul_get_canvas_handle_x(_c_cv),
     258                                   cucul_get_canvas_handle_y(_c_cv)); }
     259            set { cucul_set_canvas_handle(_c_cv, value.X, value.Y); }
    259260        }
    260261
     
    265266        public int Blit(Point p, CuculCanvas canvas)
    266267        {
    267             return cucul_blit(_cv, p.X, p.Y, canvas._cv, IntPtr.Zero);
     268            return cucul_blit(_c_cv, p.X, p.Y, canvas._c_cv, IntPtr.Zero);
    268269        }
    269270
    270271        public int Blit(Point p, CuculCanvas cv, CuculCanvas mask)
    271272        {
    272             return cucul_blit(_cv, p.X, p.Y, cv._cv, mask._cv);
     273            return cucul_blit(_c_cv, p.X, p.Y, cv._c_cv, mask._c_cv);
    273274        }
    274275
    275276        public int Blit(int x, int y, CuculCanvas canvas)
    276277        {
    277             return cucul_blit(_cv, x, y, canvas._cv, IntPtr.Zero);
     278            return cucul_blit(_c_cv, x, y, canvas._c_cv, IntPtr.Zero);
    278279        }
    279280
    280281        public int Blit(int x, int y, CuculCanvas cv, CuculCanvas mask)
    281282        {
    282             return cucul_blit(_cv, x, y, cv._cv, mask._cv);
     283            return cucul_blit(_c_cv, x, y, cv._c_cv, mask._c_cv);
    283284        }
    284285
     
    290291        public int setBoundaries(Rectangle r)
    291292        {
    292             return cucul_set_canvas_boundaries(_cv, r.X, r.Y,
     293            return cucul_set_canvas_boundaries(_c_cv, r.X, r.Y,
    293294                                               r.Width, r.Height);
    294295        }
     
    296297        public int setBoundaries(int x, int y, int w, int h)
    297298        {
    298             return cucul_set_canvas_boundaries(_cv, x, y, w, h);
     299            return cucul_set_canvas_boundaries(_c_cv, x, y, w, h);
    299300        }
    300301
     
    306307        public int Invert()
    307308        {
    308             return cucul_invert(_cv);
     309            return cucul_invert(_c_cv);
    309310        }
    310311
     
    314315        public int Flip()
    315316        {
    316             return cucul_flip(_cv);
     317            return cucul_flip(_c_cv);
    317318        }
    318319
     
    322323        public int Flop()
    323324        {
    324             return cucul_flop(_cv);
     325            return cucul_flop(_c_cv);
    325326        }
    326327
     
    330331        public int Rotate180()
    331332        {
    332             return cucul_rotate_180(_cv);
     333            return cucul_rotate_180(_c_cv);
    333334        }
    334335
     
    338339        public int RotateLeft()
    339340        {
    340             return cucul_rotate_left(_cv);
     341            return cucul_rotate_left(_c_cv);
    341342        }
    342343
     
    346347        public int RotateRight()
    347348        {
    348             return cucul_rotate_right(_cv);
     349            return cucul_rotate_right(_c_cv);
    349350        }
    350351
     
    354355        public int StretchLeft()
    355356        {
    356             return cucul_stretch_left(_cv);
     357            return cucul_stretch_left(_c_cv);
    357358        }
    358359
     
    362363        public int StretchRight()
    363364        {
    364             return cucul_stretch_right(_cv);
     365            return cucul_stretch_right(_c_cv);
    365366        }
    366367
     
    373374        public int drawLine(Point p1, Point p2, uint c)
    374375        {
    375             return cucul_draw_line(_cv, p1.X, p1.Y, p2.X, p2.Y, c);
     376            return cucul_draw_line(_c_cv, p1.X, p1.Y, p2.X, p2.Y, c);
    376377        }
    377378
    378379        public int drawLine(int x1, int y1, int x2, int y2, uint c)
    379380        {
    380             return cucul_draw_line(_cv, x1, y1, x2, y2, c);
     381            return cucul_draw_line(_c_cv, x1, y1, x2, y2, c);
    381382        }
    382383
     
    394395                ly[i] = lp[i].Y;
    395396            }
    396             return cucul_draw_polyline(_cv, lx, ly, lp.Length - 1, c);
     397            return cucul_draw_polyline(_c_cv, lx, ly, lp.Length - 1, c);
    397398        }
    398399
     
    402403                return -1;
    403404
    404             return cucul_draw_polyline(_cv, lx, ly, lx.Length - 1, c);
     405            return cucul_draw_polyline(_c_cv, lx, ly, lx.Length - 1, c);
    405406        }
    406407
     
    411412        public int drawThinLine(Point p1, Point p2)
    412413        {
    413             return cucul_draw_thin_line(_cv, p1.X, p1.Y, p2.X, p2.Y);
     414            return cucul_draw_thin_line(_c_cv, p1.X, p1.Y, p2.X, p2.Y);
    414415        }
    415416
    416417        public int drawThinLine(int x1, int y1, int x2, int y2)
    417418        {
    418             return cucul_draw_thin_line(_cv, x1, y1, x2, y2);
     419            return cucul_draw_thin_line(_c_cv, x1, y1, x2, y2);
    419420        }
    420421
     
    432433                ly[i] = lp[i].Y;
    433434            }
    434             return cucul_draw_thin_polyline(_cv, lx, ly, lp.Length - 1);
     435            return cucul_draw_thin_polyline(_c_cv, lx, ly, lp.Length - 1);
    435436        }
    436437
     
    440441                return -1;
    441442
    442             return cucul_draw_thin_polyline(_cv, lx, ly, lx.Length - 1);
     443            return cucul_draw_thin_polyline(_c_cv, lx, ly, lx.Length - 1);
    443444        }
    444445
     
    449450        public int drawCircle(Point p, int r, uint c)
    450451        {
    451             return cucul_draw_circle(_cv, p.X, p.Y, r, c);
     452            return cucul_draw_circle(_c_cv, p.X, p.Y, r, c);
    452453        }
    453454
    454455        public int drawCircle(int x, int y, int r, uint c)
    455456        {
    456             return cucul_draw_circle(_cv, x, y, r, c);
     457            return cucul_draw_circle(_c_cv, x, y, r, c);
    457458        }
    458459
     
    463464        public int drawEllipse(Point p, int a, int b, uint c)
    464465        {
    465             return cucul_draw_ellipse(_cv, p.X, p.Y, a, b, c);
     466            return cucul_draw_ellipse(_c_cv, p.X, p.Y, a, b, c);
    466467        }
    467468
    468469        public int drawEllipse(int x, int y, int a, int b, uint c)
    469470        {
    470             return cucul_draw_ellipse(_cv, x, y, a, b, c);
     471            return cucul_draw_ellipse(_c_cv, x, y, a, b, c);
    471472        }
    472473
     
    478479        public int drawThinEllipse(Point p, int a, int b)
    479480        {
    480             return cucul_draw_thin_ellipse(_cv, p.X, p.Y, a, b);
     481            return cucul_draw_thin_ellipse(_c_cv, p.X, p.Y, a, b);
    481482        }
    482483
    483484        public int drawThinEllipse(int x, int y, int a, int b)
    484485        {
    485             return cucul_draw_thin_ellipse(_cv, x, y, a, b);
     486            return cucul_draw_thin_ellipse(_c_cv, x, y, a, b);
    486487        }
    487488
     
    492493        public int fillEllipse(Point p, int a, int b, uint c)
    493494        {
    494             return cucul_fill_ellipse(_cv, p.X, p.Y, a, b, c);
     495            return cucul_fill_ellipse(_c_cv, p.X, p.Y, a, b, c);
    495496        }
    496497
    497498        public int fillEllipse(int x, int y, int a, int b, uint c)
    498499        {
    499             return cucul_fill_ellipse(_cv, x, y, a, b, c);
     500            return cucul_fill_ellipse(_c_cv, x, y, a, b, c);
    500501        }
    501502
     
    506507        public int drawBox(Rectangle r, uint c)
    507508        {
    508             return cucul_draw_box(_cv, r.X, r.Y, r.Width, r.Height, c);
     509            return cucul_draw_box(_c_cv, r.X, r.Y, r.Width, r.Height, c);
    509510        }
    510511
    511512        public int drawBox(int x, int y, int w, int h, uint c)
    512513        {
    513             return cucul_draw_box(_cv, x, y, w, h, c);
     514            return cucul_draw_box(_c_cv, x, y, w, h, c);
    514515        }
    515516
     
    520521        public int drawThinBox(Rectangle r)
    521522        {
    522             return cucul_draw_thin_box(_cv, r.X, r.Y, r.Width, r.Height);
     523            return cucul_draw_thin_box(_c_cv, r.X, r.Y, r.Width, r.Height);
    523524        }
    524525
    525526        public int drawThinBox(int x, int y, int w, int h)
    526527        {
    527             return cucul_draw_thin_box(_cv, x, y, w, h);
     528            return cucul_draw_thin_box(_c_cv, x, y, w, h);
    528529        }
    529530
     
    534535        public int drawCp437Box(Rectangle r)
    535536        {
    536             return cucul_draw_cp437_box(_cv, r.X, r.Y, r.Width, r.Height);
     537            return cucul_draw_cp437_box(_c_cv, r.X, r.Y, r.Width, r.Height);
    537538        }
    538539
    539540        public int drawCp437Box(int x, int y, int w, int h)
    540541        {
    541             return cucul_draw_cp437_box(_cv, x, y, w, h);
     542            return cucul_draw_cp437_box(_c_cv, x, y, w, h);
    542543        }
    543544
     
    548549        public int fillBox(Rectangle r, uint c)
    549550        {
    550             return cucul_fill_box(_cv, r.X, r.Y, r.Width, r.Height, c);
     551            return cucul_fill_box(_c_cv, r.X, r.Y, r.Width, r.Height, c);
    551552        }
    552553
    553554        public int fillBox(int x, int y, int w, int h, uint c)
    554555        {
    555             return cucul_fill_box(_cv, x, y, w, h, c);
     556            return cucul_fill_box(_c_cv, x, y, w, h, c);
    556557        }
    557558
     
    563564        public int drawTriangle(Point p1, Point p2, Point p3, uint c)
    564565        {
    565             return cucul_draw_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
     566            return cucul_draw_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
    566567                                       p3.X, p3.Y, c);
    567568        }
     
    570571                                int x3, int y3, uint c)
    571572        {
    572             return cucul_draw_triangle(_cv, x1, y1, x2, y2, x3, y3, c);
     573            return cucul_draw_triangle(_c_cv, x1, y1, x2, y2, x3, y3, c);
    573574        }
    574575
     
    581582        public int drawThinTriangle(Point p1, Point p2, Point p3)
    582583        {
    583             return cucul_draw_thin_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
     584            return cucul_draw_thin_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
    584585                                            p3.X, p3.Y);
    585586        }
     
    588589                                    int x3, int y3)
    589590        {
    590             return cucul_draw_thin_triangle(_cv, x1, y1, x2, y2, x3, y3);
     591            return cucul_draw_thin_triangle(_c_cv, x1, y1, x2, y2, x3, y3);
    591592        }
    592593
     
    598599        public int fillTriangle(Point p1, Point p2, Point p3, uint c)
    599600        {
    600             return cucul_fill_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
     601            return cucul_fill_triangle(_c_cv, p1.X, p1.Y, p2.X, p2.Y,
    601602                                       p3.X, p3.Y, c);
    602603        }
     
    605606                                int x3, int y3, uint c)
    606607        {
    607             return cucul_fill_triangle(_cv, x1, y1, x2, y2, x3, y3, c);
     608            return cucul_fill_triangle(_c_cv, x1, y1, x2, y2, x3, y3, c);
    608609        }
    609610
     
    615616        public int getFrameCount()
    616617        {
    617             return cucul_get_frame_count(_cv);
     618            return cucul_get_frame_count(_c_cv);
    618619        }
    619620
     
    623624        public int setFrame(int f)
    624625        {
    625             return cucul_set_frame(_cv, f);
     626            return cucul_set_frame(_c_cv, f);
    626627        }
    627628
     
    634635        public string FrameName
    635636        {
    636             get { return cucul_get_frame_name(_cv); }
    637             set { cucul_set_frame_name(_cv, value); }
     637            get { return cucul_get_frame_name(_c_cv); }
     638            set { cucul_set_frame_name(_c_cv, value); }
    638639        }
    639640
     
    643644        public int createFrame(int f)
    644645        {
    645             return cucul_create_frame(_cv, f);
     646            return cucul_create_frame(_c_cv, f);
    646647        }
    647648
     
    651652        public int freeFrame(int f)
    652653        {
    653             return cucul_free_frame(_cv, f);
     654            return cucul_free_frame(_c_cv, f);
    654655        }
    655656
     
    664665        {
    665666            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
    666             int ret = cucul_dither_bitmap(_cv, r.X, r.Y, r.Width, r.Height,
     667            int ret = cucul_dither_bitmap(_c_cv, r.X, r.Y, r.Width, r.Height,
    667668                                          d._dither, gch.AddrOfPinnedObject());
    668669            gch.Free();
     
    674675        {
    675676            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
    676             int ret = cucul_dither_bitmap(_cv, x, y, w, h, d._dither,
     677            int ret = cucul_dither_bitmap(_c_cv, x, y, w, h, d._dither,
    677678                                          gch.AddrOfPinnedObject());
    678679            gch.Free();
     
    947948        {
    948949            GCHandle gch = GCHandle.Alloc(buf, GCHandleType.Pinned);
    949             int ret = cucul_render_canvas(cv._cv, _font,
     950            int ret = cucul_render_canvas(cv._c_cv, _font,
    950951                                          gch.AddrOfPinnedObject(),
    951952                                          buf.GetLength(0), buf.GetLength(1),
Note: See TracChangeset for help on using the changeset viewer.