source: libcaca/trunk/csharp/Cucul.cs @ 2076

Last change on this file since 2076 was 2076, checked in by Sam Hocevar, 13 years ago
  • Implemented getVersion() in the C# bindings.
  • Slightly improved the C# test program.
  • Property svn:keywords set to Id
File size: 22.1 KB
Line 
1/*
2 *  libcucul      .NET bindings for libcucul
3 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
4 *                2007 Sam Hocevar <sam@zoy.org>
5 *                All Rights Reserved
6 *
7 *  $Id: Cucul.cs 2076 2007-11-26 01:04:36Z sam $
8 *
9 *  This library is free software. It comes without any warranty, to
10 *  the extent permitted by applicable law. You can redistribute it
11 *  and/or modify it under the terms of the Do What The Fuck You Want
12 *  To Public License, Version 2, as published by Sam Hocevar. See
13 *  http://sam.zoy.org/wtfpl/COPYING for more details.
14 */
15
16using System;
17using System.Runtime.InteropServices;
18using System.Security;
19
20namespace Cucul
21{
22    /* Static libcucul stuff that does not fit in any object */
23    public static class Libcucul
24    {
25        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
26         SuppressUnmanagedCodeSecurity]
27        private static extern int cucul_rand(int min, int max);
28        public static int Rand(int min, int max)
29        {
30            return cucul_rand(min, max);
31        }
32
33        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
34         SuppressUnmanagedCodeSecurity]
35        private static extern IntPtr cucul_get_version();
36        public static string getVersion()
37        {
38            return Marshal.PtrToStringAnsi(cucul_get_version());
39        }
40
41        public const int BLACK = 0x00,
42                         BLUE = 0x01,
43                         GREEN = 0x02,
44                         CYAN = 0x03,
45                         RED = 0x04,
46                         MAGENTA = 0x05,
47                         BROWN = 0x06,
48                         LIGHTGRAY = 0x07,
49                         DARKGRAY = 0x08,
50                         LIGHTBLUE = 0x09,
51                         LIGHTGREEN = 0x0a,
52                         LIGHTCYAN = 0x0b,
53                         LIGHTRED = 0x0c,
54                         LIGHTMAGENTA = 0x0d,
55                         YELLOW = 0x0e,
56                         WHITE = 0x0f,
57                         DEFAULT = 0x10,
58                         TRANSPARENT = 0x20;
59
60        public const int BOLD = 0x01,
61                         ITALICS = 0x02,
62                         UNDERLINE = 0x04,
63                         BLINK = 0x08;
64    }
65
66    public class CuculCanvas : IDisposable
67    {
68        public readonly IntPtr _cv;
69
70        /* libcucul basic functions */
71
72        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
73         SuppressUnmanagedCodeSecurity]
74        private static extern IntPtr cucul_create_canvas(int w, int h);
75        public CuculCanvas()
76        {
77            _cv = cucul_create_canvas(0, 0);
78        }
79
80        public CuculCanvas(int w, int h)
81        {
82            _cv = cucul_create_canvas(w, h);
83        }
84
85        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
86         SuppressUnmanagedCodeSecurity]
87        private static extern int cucul_free_canvas(IntPtr cv);
88        public void Dispose()
89        {
90           cucul_free_canvas(_cv);
91           GC.SuppressFinalize(this);
92        }
93
94        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
95         SuppressUnmanagedCodeSecurity]
96        private static extern int cucul_set_canvas_size(IntPtr cv,
97                                                        int w, int h);
98        public void setSize(int w, int h)
99        {
100            cucul_set_canvas_size(_cv, w, h);
101        }
102
103        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
104         SuppressUnmanagedCodeSecurity]
105        private static extern int cucul_get_canvas_width(IntPtr cv);
106        public int width
107        {
108            get { return cucul_get_canvas_width(_cv); }
109            set { cucul_set_canvas_size(_cv, value,
110                                        cucul_get_canvas_height(_cv)); }
111        }
112
113        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
114         SuppressUnmanagedCodeSecurity]
115        private static extern int cucul_get_canvas_height(IntPtr cv);
116        public int height
117        {
118            get { return cucul_get_canvas_height(_cv); }
119            set { cucul_set_canvas_size(_cv, cucul_get_canvas_width(_cv),
120                                        value); }
121        }
122
123        /* canvas drawing */
124
125        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
126         SuppressUnmanagedCodeSecurity]
127        private static extern int cucul_gotoxy(IntPtr cv, int x, int y);
128        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
129         SuppressUnmanagedCodeSecurity]
130        private static extern int cucul_get_cursor_x(IntPtr cv);
131        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
132         SuppressUnmanagedCodeSecurity]
133        private static extern int cucul_get_cursor_y(IntPtr cv);
134        public int cursorX
135        {
136            get { return cucul_get_cursor_x(_cv); }
137            set { cucul_gotoxy(_cv, value, cucul_get_cursor_y(_cv)); }
138        }
139
140        public int cursorY
141        {
142            get { return cucul_get_cursor_y(_cv); }
143            set { cucul_gotoxy(_cv, cucul_get_cursor_x(_cv), value); }
144        }
145
146        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
147         SuppressUnmanagedCodeSecurity]
148        private static extern int cucul_put_char(IntPtr cv,
149                                                 int x, int y, int c);
150        public int putChar(int x, int y, int c)
151        {
152            return cucul_put_char(_cv, x, y, c);
153        }
154
155        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
156         SuppressUnmanagedCodeSecurity]
157        private static extern int cucul_get_char(IntPtr cv, int x, int y);
158        public int getChar(int x, int y)
159        {
160            return cucul_get_char(_cv, x, y);
161        }
162
163        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
164         SuppressUnmanagedCodeSecurity]
165        private static extern int cucul_put_str(IntPtr cv,
166                                                int x, int y, string c);
167        public int putStr(int x, int y, string c)
168        {
169            return cucul_put_str(_cv, x, y, c);
170        }
171
172        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
173         SuppressUnmanagedCodeSecurity]
174        private static extern int cucul_get_attr(IntPtr cv, int x, int y);
175        public int getAttr(int x, int y)
176        {
177            return cucul_get_attr(_cv, x, y);
178        }
179
180        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
181         SuppressUnmanagedCodeSecurity]
182        private static extern int cucul_set_attr(IntPtr cv, int a);
183        public int setAttr(int a)
184        {
185            return cucul_set_attr(_cv, a);
186        }
187
188        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
189         SuppressUnmanagedCodeSecurity]
190        private static extern int cucul_put_attr(IntPtr cv,
191                                                 int x, int y, int a);
192        public int putAttr(int x, int y, int a)
193        {
194            return cucul_put_attr(_cv, x, y, a);
195        }
196
197        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
198         SuppressUnmanagedCodeSecurity]
199        private static extern int cucul_set_color_ansi(IntPtr cv,
200                                                       byte fg, byte bg);
201        public int setColorAnsi(int fg, int bg)
202        {
203            return cucul_set_color_ansi(_cv, (byte)fg, (byte)bg);
204        }
205
206        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
207         SuppressUnmanagedCodeSecurity]
208        private static extern int cucul_set_color_argb(IntPtr cv,
209                                                       int fg, int bg);
210        public int setColorArgb(int fg, int bg)
211        {
212            return cucul_set_color_argb(_cv, fg, bg);
213        }
214
215        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
216         SuppressUnmanagedCodeSecurity]
217        private static extern int cucul_clear_canvas(IntPtr cv);
218        public int Clear()
219        {
220            return cucul_clear_canvas(_cv);
221        }
222
223        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
224         SuppressUnmanagedCodeSecurity]
225        private static extern int cucul_set_canvas_handle(IntPtr cv,
226                                                          int x, int y);
227        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
228         SuppressUnmanagedCodeSecurity]
229        private static extern int cucul_get_canvas_handle_x(IntPtr cv);
230        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
231         SuppressUnmanagedCodeSecurity]
232        private static extern int cucul_get_canvas_handle_y(IntPtr cv);
233        public int handleX
234        {
235            get { return cucul_get_canvas_handle_x(_cv); }
236            set { cucul_set_canvas_handle(_cv, value,
237                                          cucul_get_canvas_handle_y(_cv)); }
238        }
239
240        public int handleY
241        {
242            get { return cucul_get_canvas_handle_y(_cv); }
243            set { cucul_set_canvas_handle(_cv, cucul_get_canvas_handle_x(_cv),
244                                          value); }
245        }
246
247        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
248         SuppressUnmanagedCodeSecurity]
249        private static extern int cucul_blit(IntPtr cv, int x, int y,
250                                             IntPtr cv1, IntPtr cv2);
251        public int Blit(int x, int y, CuculCanvas canvas)
252        {
253            return cucul_blit(_cv, x, y, canvas._cv, IntPtr.Zero);
254        }
255
256        public int Blit(int x, int y, CuculCanvas cv, CuculCanvas mask)
257        {
258            return cucul_blit(_cv, x, y, cv._cv, mask._cv);
259        }
260
261        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
262         SuppressUnmanagedCodeSecurity]
263        private static extern int cucul_set_canvas_boundaries(IntPtr cv,
264                                                              int x, int y,
265                                                              int h,  int w);
266        public int setBoundaries(int x, int y, int h, int w)
267        {
268            return cucul_set_canvas_boundaries(_cv, x, y, h, w);
269        }
270
271        /* canvas transformation */
272
273        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
274         SuppressUnmanagedCodeSecurity]
275        private static extern int cucul_invert(IntPtr cv);
276        public int Invert()
277        {
278            return cucul_invert(_cv);
279        }
280
281        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
282         SuppressUnmanagedCodeSecurity]
283        private static extern int cucul_flip(IntPtr cv);
284        public int Flip()
285        {
286            return cucul_flip(_cv);
287        }
288
289        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
290         SuppressUnmanagedCodeSecurity]
291        private static extern int cucul_flop(IntPtr cv);
292        public int Flop()
293        {
294            return cucul_flop(_cv);
295        }
296
297        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
298         SuppressUnmanagedCodeSecurity]
299        private static extern int cucul_rotate_180(IntPtr cv);
300        public int Rotate180()
301        {
302            return cucul_rotate_180(_cv);
303        }
304
305        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
306         SuppressUnmanagedCodeSecurity]
307        private static extern int cucul_rotate_left(IntPtr cv);
308        public int RotateLeft()
309        {
310            return cucul_rotate_left(_cv);
311        }
312
313        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
314         SuppressUnmanagedCodeSecurity]
315        private static extern int cucul_rotate_right(IntPtr cv);
316        public int RotateRight()
317        {
318            return cucul_rotate_right(_cv);
319        }
320
321        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
322         SuppressUnmanagedCodeSecurity]
323        private static extern int cucul_stretch_left(IntPtr cv);
324        public int StretchLeft()
325        {
326            return cucul_stretch_left(_cv);
327        }
328
329        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
330         SuppressUnmanagedCodeSecurity]
331        private static extern int cucul_stretch_right(IntPtr cv);
332        public int StretchRight()
333        {
334            return cucul_stretch_right(_cv);
335        }
336
337        /* primitives drawing */
338        /* FIXME: highly incomplete */
339
340        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
341         SuppressUnmanagedCodeSecurity]
342        private static extern int cucul_draw_line(IntPtr cv, int x1, int y1, int x2, int y2, int c);
343        public int drawLine(int x1, int y1, int x2, int y2, int c)
344        {
345            return cucul_draw_line(_cv, x1, y1, x2, y2, c);
346        }
347        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
348         SuppressUnmanagedCodeSecurity]
349        private static extern int cucul_draw_polyline(IntPtr cv, int[] x, int[] y, int n, IntPtr c);
350        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
351         SuppressUnmanagedCodeSecurity]
352        private static extern int cucul_draw_thin_line(IntPtr cv, int x1, int y1, int x2, int y2);
353        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
354         SuppressUnmanagedCodeSecurity]
355        private static extern int cucul_draw_thin_polyline(IntPtr cv, int[] x, int[] y, int n);
356
357        /* frame handling */
358
359        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
360         SuppressUnmanagedCodeSecurity]
361        private static extern int cucul_get_frame_count(IntPtr cv);
362        public int getFrameCount()
363        {
364            return cucul_get_frame_count(_cv);
365        }
366
367        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
368         SuppressUnmanagedCodeSecurity]
369        private static extern int cucul_set_frame(IntPtr cv, int f);
370        public int setFrame(int f)
371        {
372            return cucul_set_frame(_cv, f);
373        }
374
375        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
376         SuppressUnmanagedCodeSecurity]
377        private static extern string cucul_get_frame_name(IntPtr cv);
378        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
379         SuppressUnmanagedCodeSecurity]
380        private static extern int cucul_set_frame_name(IntPtr cv, string n);
381        public string frameName
382        {
383            get { return cucul_get_frame_name(_cv); }
384            set { cucul_set_frame_name(_cv, value); }
385        }
386
387        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
388         SuppressUnmanagedCodeSecurity]
389        private static extern int cucul_create_frame(IntPtr cv, int f);
390        public int createFrame(int f)
391        {
392            return cucul_create_frame(_cv, f);
393        }
394
395        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
396         SuppressUnmanagedCodeSecurity]
397        private static extern int cucul_free_frame(IntPtr cv, int f);
398        public int freeFrame(int f)
399        {
400            return cucul_free_frame(_cv, f);
401        }
402
403        /* bitmap dithering */
404
405        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
406         SuppressUnmanagedCodeSecurity]
407        private static extern int cucul_dither_bitmap(IntPtr c, int  x, int y,
408                                                      int w, int h,
409                                                      IntPtr d, IntPtr data);
410        public int ditherBitmap(int x, int y, int w, int h, CuculDither d,
411                                object data)
412        {
413            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
414            int ret = cucul_dither_bitmap(_cv, x, y, w, h, d._dither,
415                                          gch.AddrOfPinnedObject());
416            gch.Free();
417            return ret;
418        }
419    }
420
421    public class CuculAttr
422    {
423        private int _attr;
424
425        public CuculAttr(int attr)
426        {
427            attr = _attr;
428        }
429
430        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
431         SuppressUnmanagedCodeSecurity]
432        private static extern byte cucul_attr_to_ansi(Int32 a);
433        public byte toAnsi()
434        {
435            return cucul_attr_to_ansi(_attr);
436        }
437
438        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
439         SuppressUnmanagedCodeSecurity]
440        private static extern byte cucul_attr_to_ansi_fg(Int32 a);
441        public byte toAnsiFg()
442        {
443            return cucul_attr_to_ansi_fg(_attr);
444        }
445
446        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
447         SuppressUnmanagedCodeSecurity]
448        private static extern byte cucul_attr_to_ansi_bg(Int32 a);
449        public byte toAnsiBg()
450        {
451            return cucul_attr_to_ansi_bg(_attr);
452        }
453    }
454
455    public class CuculDither : IDisposable
456    {
457        public readonly IntPtr _dither;
458
459        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
460         SuppressUnmanagedCodeSecurity]
461        private static extern IntPtr cucul_create_dither(int bpp, int w,
462                                                         int h, int pitch,
463                                                         ulong rmask,
464                                                         ulong gmask,
465                                                         ulong bmask,
466                                                         ulong amask);
467        public CuculDither(int bpp, int w,int h, int pitch,
468                           uint rmask, uint gmask, uint bmask, uint amask)
469        {
470            _dither = cucul_create_dither(bpp, w, h, pitch,
471                                          rmask, gmask, bmask, amask);
472        }
473
474        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
475         SuppressUnmanagedCodeSecurity]
476        private static extern int cucul_free_dither(IntPtr d);
477        public void Dispose()
478        {
479            cucul_free_dither(_dither);
480            GC.SuppressFinalize(this);
481        }
482
483        /* TODO: fix this shit */
484
485        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
486         SuppressUnmanagedCodeSecurity]
487        private static extern int cucul_set_dither_palette(IntPtr d,
488                               int[] r, int[] g,
489                               int[] b, int[] a);
490        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
491         SuppressUnmanagedCodeSecurity]
492        private static extern int cucul_set_dither_brightness(IntPtr d, float b);
493        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
494         SuppressUnmanagedCodeSecurity]
495        private static extern int cucul_set_dither_gamma(IntPtr d, float g);
496        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
497         SuppressUnmanagedCodeSecurity]
498        private static extern int cucul_set_dither_contrast(IntPtr d, float c);
499        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
500         SuppressUnmanagedCodeSecurity]
501        private static extern int cucul_set_dither_invert(IntPtr d, int i);
502        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
503         SuppressUnmanagedCodeSecurity]
504        private static extern int cucul_set_dither_antialias(IntPtr d, string s);
505        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
506         SuppressUnmanagedCodeSecurity]
507        private static extern string[] cucul_get_dither_antialias_list(IntPtr d);
508        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
509         SuppressUnmanagedCodeSecurity]
510        private static extern int cucul_set_dither_color(IntPtr d, string s);
511        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
512         SuppressUnmanagedCodeSecurity]
513        private static extern string[] cucul_get_dither_color_list(IntPtr d);
514        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
515         SuppressUnmanagedCodeSecurity]
516        private static extern int cucul_set_dither_charset(IntPtr d, string s);
517        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
518         SuppressUnmanagedCodeSecurity]
519        private static extern string[] cucul_get_dither_charset_list(IntPtr d);
520        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
521         SuppressUnmanagedCodeSecurity]
522        private static extern int cucul_set_dither_mode(IntPtr d, string s);
523        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
524         SuppressUnmanagedCodeSecurity]
525        private static extern string[] cucul_get_dither_mode_list(IntPtr d);
526
527
528        public int setBrightness(float b)
529        {
530            return cucul_set_dither_brightness(_dither, b);
531        }
532
533        public int setGamma(float g)
534        {
535            return cucul_set_dither_gamma(_dither, g);
536        }
537
538        public int setContrast(float c)
539        {
540            return cucul_set_dither_contrast(_dither, c);
541        }
542
543        public int setInvert(int i)
544        {
545            return cucul_set_dither_invert(_dither, i);
546        }
547
548        public int setAntialias(string s)
549        {
550            return cucul_set_dither_antialias(_dither, s);
551        }
552
553        public int setColor(string s)
554        {
555            return cucul_set_dither_color(_dither, s);
556        }
557
558        public int setCharset(string s)
559        {
560            return cucul_set_dither_charset(_dither, s);
561        }
562
563        public int setMode(string s)
564        {
565            return cucul_set_dither_mode(_dither, s);
566        }
567
568        /* <FIXME> */
569        public string[] getAntialiasList()
570        {
571            return cucul_get_dither_antialias_list(_dither);
572        }
573
574        public string[] getColorList()
575        {
576            return cucul_get_dither_color_list(_dither);
577        }
578
579        public string[] getCharsetList()
580        {
581            return cucul_get_dither_charset_list(_dither);
582        }
583
584        public string[] getModeList()
585        {
586            return cucul_get_dither_mode_list(_dither);
587        }
588
589        /* </FIXME> */
590    }
591}
592
Note: See TracBrowser for help on using the repository browser.