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

Last change on this file since 2081 was 2081, checked in by Sam Hocevar, 13 years ago
  • Property svn:keywords set to Id
File size: 31.0 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 2081 2007-11-27 00:58:27Z 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;
19using System.Drawing;
20
21namespace Cucul
22{
23    /* Static libcucul stuff that does not fit in any object */
24    public static class Libcucul
25    {
26        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
27         SuppressUnmanagedCodeSecurity]
28        private static extern int cucul_rand(int min, int max);
29        public static int Rand(int min, int max)
30        {
31            return cucul_rand(min, max);
32        }
33
34        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
35         SuppressUnmanagedCodeSecurity]
36        private static extern IntPtr cucul_get_version();
37        public static string getVersion()
38        {
39            return Marshal.PtrToStringAnsi(cucul_get_version());
40        }
41
42        public const int 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 int BOLD = 0x01,
62                         ITALICS = 0x02,
63                         UNDERLINE = 0x04,
64                         BLINK = 0x08;
65    }
66
67    public class CuculCanvas : IDisposable
68    {
69        public readonly IntPtr _cv;
70
71        /* libcucul basic functions */
72
73        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
74         SuppressUnmanagedCodeSecurity]
75        private static extern IntPtr cucul_create_canvas(int w, int h);
76        public CuculCanvas()
77        {
78            _cv = cucul_create_canvas(0, 0);
79        }
80
81        public CuculCanvas(Size s)
82        {
83            _cv = cucul_create_canvas(s.Width, s.Height);
84        }
85
86        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
87         SuppressUnmanagedCodeSecurity]
88        private static extern int cucul_free_canvas(IntPtr cv);
89        public void Dispose()
90        {
91           cucul_free_canvas(_cv);
92           GC.SuppressFinalize(this);
93        }
94
95        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
96         SuppressUnmanagedCodeSecurity]
97        private static extern int cucul_set_canvas_size(IntPtr cv,
98                                                        int w, int h);
99        public void setSize(Size s)
100        {
101            cucul_set_canvas_size(_cv, s.Width, s.Height);
102        }
103
104        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
105         SuppressUnmanagedCodeSecurity]
106        private static extern int cucul_get_canvas_width(IntPtr cv);
107        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
108         SuppressUnmanagedCodeSecurity]
109        private static extern int cucul_get_canvas_height(IntPtr cv);
110        public Size Size
111        {
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); }
115        }
116
117        public Rectangle Rectangle
118        {
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); }
122        }
123
124        /* canvas drawing */
125
126        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
127         SuppressUnmanagedCodeSecurity]
128        private static extern int cucul_gotoxy(IntPtr cv, int x, int y);
129        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
130         SuppressUnmanagedCodeSecurity]
131        private static extern int cucul_get_cursor_x(IntPtr cv);
132        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
133         SuppressUnmanagedCodeSecurity]
134        private static extern int cucul_get_cursor_y(IntPtr cv);
135        public Point Cursor
136        {
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); }
140        }
141
142        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
143         SuppressUnmanagedCodeSecurity]
144        private static extern int cucul_put_char(IntPtr cv,
145                                                 int x, int y, int c);
146        public int putChar(Point p, int c)
147        {
148            return cucul_put_char(_cv, p.X, p.Y, c);
149        }
150
151        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
152         SuppressUnmanagedCodeSecurity]
153        private static extern int cucul_get_char(IntPtr cv, int x, int y);
154        public int getChar(Point p)
155        {
156            return cucul_get_char(_cv, p.X, p.Y);
157        }
158
159        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
160         SuppressUnmanagedCodeSecurity]
161        private static extern int cucul_put_str(IntPtr cv,
162                                                int x, int y, string c);
163        public int putStr(Point p, string c)
164        {
165            return cucul_put_str(_cv, p.X, p.Y, c);
166        }
167
168        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
169         SuppressUnmanagedCodeSecurity]
170        private static extern int cucul_get_attr(IntPtr cv, int x, int y);
171        public int getAttr(Point p)
172        {
173            return cucul_get_attr(_cv, p.X, p.Y);
174        }
175
176        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
177         SuppressUnmanagedCodeSecurity]
178        private static extern int cucul_set_attr(IntPtr cv, int a);
179        public int setAttr(int a)
180        {
181            return cucul_set_attr(_cv, a);
182        }
183
184        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
185         SuppressUnmanagedCodeSecurity]
186        private static extern int cucul_put_attr(IntPtr cv,
187                                                 int x, int y, int a);
188        public int putAttr(Point p, int a)
189        {
190            return cucul_put_attr(_cv, p.X, p.Y, a);
191        }
192
193        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
194         SuppressUnmanagedCodeSecurity]
195        private static extern int cucul_set_color_ansi(IntPtr cv,
196                                                       byte fg, byte bg);
197        public int setColorAnsi(int fg, int bg)
198        {
199            return cucul_set_color_ansi(_cv, (byte)fg, (byte)bg);
200        }
201
202        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
203         SuppressUnmanagedCodeSecurity]
204        private static extern int cucul_set_color_argb(IntPtr cv,
205                                                       int fg, int bg);
206        public int setColorArgb(int fg, int bg)
207        {
208            return cucul_set_color_argb(_cv, fg, bg);
209        }
210
211        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
212         SuppressUnmanagedCodeSecurity]
213        private static extern int cucul_clear_canvas(IntPtr cv);
214        public int Clear()
215        {
216            return cucul_clear_canvas(_cv);
217        }
218
219        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
220         SuppressUnmanagedCodeSecurity]
221        private static extern int cucul_set_canvas_handle(IntPtr cv,
222                                                          int x, int y);
223        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
224         SuppressUnmanagedCodeSecurity]
225        private static extern int cucul_get_canvas_handle_x(IntPtr cv);
226        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
227         SuppressUnmanagedCodeSecurity]
228        private static extern int cucul_get_canvas_handle_y(IntPtr cv);
229        public Point Handle
230        {
231            get { return new Point(cucul_get_canvas_handle_x(_cv),
232                                   cucul_get_canvas_handle_y(_cv)); }
233            set { cucul_set_canvas_handle(_cv, value.X, value.Y); }
234        }
235
236        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
237         SuppressUnmanagedCodeSecurity]
238        private static extern int cucul_blit(IntPtr cv, int x, int y,
239                                             IntPtr cv1, IntPtr cv2);
240        public int Blit(Point p, CuculCanvas canvas)
241        {
242            return cucul_blit(_cv, p.X, p.Y, canvas._cv, IntPtr.Zero);
243        }
244
245        public int Blit(Point p, CuculCanvas cv, CuculCanvas mask)
246        {
247            return cucul_blit(_cv, p.X, p.Y, cv._cv, mask._cv);
248        }
249
250        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
251         SuppressUnmanagedCodeSecurity]
252        private static extern int cucul_set_canvas_boundaries(IntPtr cv,
253                                                              int x, int y,
254                                                              int h, int w);
255        public int setBoundaries(Rectangle r)
256        {
257            return cucul_set_canvas_boundaries(_cv, r.X, r.Y,
258                                               r.Width, r.Height);
259        }
260
261        /* canvas transformation */
262
263        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
264         SuppressUnmanagedCodeSecurity]
265        private static extern int cucul_invert(IntPtr cv);
266        public int Invert()
267        {
268            return cucul_invert(_cv);
269        }
270
271        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
272         SuppressUnmanagedCodeSecurity]
273        private static extern int cucul_flip(IntPtr cv);
274        public int Flip()
275        {
276            return cucul_flip(_cv);
277        }
278
279        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
280         SuppressUnmanagedCodeSecurity]
281        private static extern int cucul_flop(IntPtr cv);
282        public int Flop()
283        {
284            return cucul_flop(_cv);
285        }
286
287        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
288         SuppressUnmanagedCodeSecurity]
289        private static extern int cucul_rotate_180(IntPtr cv);
290        public int Rotate180()
291        {
292            return cucul_rotate_180(_cv);
293        }
294
295        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
296         SuppressUnmanagedCodeSecurity]
297        private static extern int cucul_rotate_left(IntPtr cv);
298        public int RotateLeft()
299        {
300            return cucul_rotate_left(_cv);
301        }
302
303        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
304         SuppressUnmanagedCodeSecurity]
305        private static extern int cucul_rotate_right(IntPtr cv);
306        public int RotateRight()
307        {
308            return cucul_rotate_right(_cv);
309        }
310
311        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
312         SuppressUnmanagedCodeSecurity]
313        private static extern int cucul_stretch_left(IntPtr cv);
314        public int StretchLeft()
315        {
316            return cucul_stretch_left(_cv);
317        }
318
319        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
320         SuppressUnmanagedCodeSecurity]
321        private static extern int cucul_stretch_right(IntPtr cv);
322        public int StretchRight()
323        {
324            return cucul_stretch_right(_cv);
325        }
326
327        /* primitives drawing */
328        /* FIXME: highly incomplete */
329
330        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
331         SuppressUnmanagedCodeSecurity]
332        private static extern int cucul_draw_line(IntPtr cv, int x1, int y1,
333                                                  int x2, int y2, uint c);
334        public int drawLine(Point p1, Point p2, uint c)
335        {
336            return cucul_draw_line(_cv, p1.X, p1.Y, p2.X, p2.Y, c);
337        }
338
339        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
340         SuppressUnmanagedCodeSecurity]
341        private static extern int cucul_draw_polyline(IntPtr cv, int[] x,
342                                                      int[] y, int n, uint c);
343        public int drawPolyline(Point[] lp, uint c)
344        {
345            int[] lx = new int[lp.Length];
346            int[] ly = new int[lp.Length];
347            for(int i = 0; i < lp.Length; i++)
348            {
349                lx[i] = lp[i].X;
350                ly[i] = lp[i].Y;
351            }
352            return cucul_draw_polyline(_cv, lx, ly, lp.Length - 1, c);
353        }
354
355        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
356         SuppressUnmanagedCodeSecurity]
357        private static extern int cucul_draw_thin_line(IntPtr cv, int x1,
358                                                       int y1, int x2, int y2);
359        public int drawThinLine(Point p1, Point p2)
360        {
361            return cucul_draw_thin_line(_cv, p1.X, p1.Y, p2.X, p2.Y);
362        }
363
364        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
365         SuppressUnmanagedCodeSecurity]
366        private static extern int cucul_draw_thin_polyline(IntPtr cv, int[] x,
367                                                           int[] y, int n);
368        public int drawThinPolyline(Point[] lp)
369        {
370            int[] lx = new int[lp.Length];
371            int[] ly = new int[lp.Length];
372            for(int i = 0; i < lp.Length; i++)
373            {
374                lx[i] = lp[i].X;
375                ly[i] = lp[i].Y;
376            }
377            return cucul_draw_thin_polyline(_cv, lx, ly, lp.Length - 1);
378        }
379
380        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
381         SuppressUnmanagedCodeSecurity]
382        private static extern int cucul_draw_circle(IntPtr cv, int x, int y,
383                                                    int r, uint c);
384        public int drawCircle(Point p1, int r, uint c)
385        {
386            return cucul_draw_circle(_cv, p1.X, p1.Y, r, c);
387        }
388
389        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
390         SuppressUnmanagedCodeSecurity]
391        private static extern int cucul_draw_ellipse(IntPtr cv, int x, int y,
392                                                     int a, int b, uint c);
393        public int drawEllipse(Point p1, int a, int b, uint c)
394        {
395            return cucul_draw_ellipse(_cv, p1.X, p1.Y, a, b, c);
396        }
397
398        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
399         SuppressUnmanagedCodeSecurity]
400        private static extern int cucul_draw_thin_ellipse(IntPtr cv,
401                                                          int x, int y,
402                                                          int a, int b);
403        public int drawThinEllipse(Point p1, int a, int b)
404        {
405            return cucul_draw_thin_ellipse(_cv, p1.X, p1.Y, a, b);
406        }
407
408        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
409         SuppressUnmanagedCodeSecurity]
410        private static extern int cucul_fill_ellipse(IntPtr cv, int x, int y,
411                                                     int a, int b, uint c);
412        public int fillEllipse(Point p1, int a, int b, uint c)
413        {
414            return cucul_fill_ellipse(_cv, p1.X, p1.Y, a, b, c);
415        }
416
417        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
418         SuppressUnmanagedCodeSecurity]
419        private static extern int cucul_draw_box(IntPtr cv, int x, int y,
420                                                 int w, int h, uint c);
421        public int drawBox(Rectangle r, uint c)
422        {
423            return cucul_draw_box(_cv, r.X, r.Y, r.Width, r.Height, c);
424        }
425
426        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
427         SuppressUnmanagedCodeSecurity]
428        private static extern int cucul_draw_thin_box(IntPtr cv, int x, int y,
429                                                      int w, int h);
430        public int drawThinBox(Rectangle r)
431        {
432            return cucul_draw_thin_box(_cv, r.X, r.Y, r.Width, r.Height);
433        }
434
435        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
436         SuppressUnmanagedCodeSecurity]
437        private static extern int cucul_draw_cp437_box(IntPtr cv, int x, int y,
438                                                       int w, int h);
439        public int drawCp437Box(Rectangle r)
440        {
441            return cucul_draw_cp437_box(_cv, r.X, r.Y, r.Width, r.Height);
442        }
443
444        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
445         SuppressUnmanagedCodeSecurity]
446        private static extern int cucul_fill_box(IntPtr cv, int x, int y,
447                                                 int w, int h, uint c);
448        public int fillBox(Rectangle r, uint c)
449        {
450            return cucul_fill_box(_cv, r.X, r.Y, r.Width, r.Height, c);
451        }
452
453        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
454         SuppressUnmanagedCodeSecurity]
455        private static extern int cucul_draw_triangle(IntPtr cv, int x1,
456                                                      int y1, int x2, int y2,
457                                                      int x3, int y3, uint c);
458        public int drawTriangle(Point p1, Point p2, Point p3, uint c)
459        {
460            return cucul_draw_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
461                                       p3.X, p3.Y, c);
462        }
463
464        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
465         SuppressUnmanagedCodeSecurity]
466        private static extern int cucul_draw_thin_triangle(IntPtr cv,
467                                                           int x1, int y1,
468                                                           int x2, int y2,
469                                                           int x3, int y3);
470        public int drawThinTriangle(Point p1, Point p2, Point p3)
471        {
472            return cucul_draw_thin_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
473                                            p3.X, p3.Y);
474        }
475
476        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
477         SuppressUnmanagedCodeSecurity]
478        private static extern int cucul_fill_triangle(IntPtr cv, int x1,
479                                                      int y1, int x2, int y2,
480                                                      int x3, int y3, uint c);
481        public int fillTriangle(Point p1, Point p2, Point p3, uint c)
482        {
483            return cucul_fill_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
484                                       p3.X, p3.Y, c);
485        }
486
487        /* frame handling */
488
489        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
490         SuppressUnmanagedCodeSecurity]
491        private static extern int cucul_get_frame_count(IntPtr cv);
492        public int getFrameCount()
493        {
494            return cucul_get_frame_count(_cv);
495        }
496
497        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
498         SuppressUnmanagedCodeSecurity]
499        private static extern int cucul_set_frame(IntPtr cv, int f);
500        public int setFrame(int f)
501        {
502            return cucul_set_frame(_cv, f);
503        }
504
505        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
506         SuppressUnmanagedCodeSecurity]
507        private static extern string cucul_get_frame_name(IntPtr cv);
508        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
509         SuppressUnmanagedCodeSecurity]
510        private static extern int cucul_set_frame_name(IntPtr cv, string n);
511        public string frameName
512        {
513            get { return cucul_get_frame_name(_cv); }
514            set { cucul_set_frame_name(_cv, value); }
515        }
516
517        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
518         SuppressUnmanagedCodeSecurity]
519        private static extern int cucul_create_frame(IntPtr cv, int f);
520        public int createFrame(int f)
521        {
522            return cucul_create_frame(_cv, f);
523        }
524
525        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
526         SuppressUnmanagedCodeSecurity]
527        private static extern int cucul_free_frame(IntPtr cv, int f);
528        public int freeFrame(int f)
529        {
530            return cucul_free_frame(_cv, f);
531        }
532
533        /* bitmap dithering */
534
535        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
536         SuppressUnmanagedCodeSecurity]
537        private static extern int cucul_dither_bitmap(IntPtr c, int  x, int y,
538                                                      int w, int h,
539                                                      IntPtr d, IntPtr data);
540        public int ditherBitmap(Rectangle r, CuculDither d, object data)
541        {
542            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
543            int ret = cucul_dither_bitmap(_cv, r.X, r.Y, r.Width, r.Height,
544                                          d._dither, gch.AddrOfPinnedObject());
545            gch.Free();
546            return ret;
547        }
548    }
549
550    public class CuculAttr
551    {
552        private int _attr;
553
554        public CuculAttr(int attr)
555        {
556            attr = _attr;
557        }
558
559        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
560         SuppressUnmanagedCodeSecurity]
561        private static extern byte cucul_attr_to_ansi(Int32 a);
562        public byte toAnsi()
563        {
564            return cucul_attr_to_ansi(_attr);
565        }
566
567        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
568         SuppressUnmanagedCodeSecurity]
569        private static extern byte cucul_attr_to_ansi_fg(Int32 a);
570        public byte toAnsiFg()
571        {
572            return cucul_attr_to_ansi_fg(_attr);
573        }
574
575        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
576         SuppressUnmanagedCodeSecurity]
577        private static extern byte cucul_attr_to_ansi_bg(Int32 a);
578        public byte toAnsiBg()
579        {
580            return cucul_attr_to_ansi_bg(_attr);
581        }
582    }
583
584    public class CuculDither : IDisposable
585    {
586        public readonly IntPtr _dither;
587
588        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
589         SuppressUnmanagedCodeSecurity]
590        private static extern IntPtr cucul_create_dither(int bpp, int w,
591                                                         int h, int pitch,
592                                                         ulong rmask,
593                                                         ulong gmask,
594                                                         ulong bmask,
595                                                         ulong amask);
596        public CuculDither(int bpp, Size s, int pitch,
597                           uint rmask, uint gmask, uint bmask, uint amask)
598        {
599            _dither = cucul_create_dither(bpp, s.Width, s.Height, pitch,
600                                          rmask, gmask, bmask, amask);
601        }
602
603        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
604         SuppressUnmanagedCodeSecurity]
605        private static extern int cucul_free_dither(IntPtr d);
606        public void Dispose()
607        {
608            cucul_free_dither(_dither);
609            GC.SuppressFinalize(this);
610        }
611
612        /* TODO: fix this shit */
613
614        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
615         SuppressUnmanagedCodeSecurity]
616        private static extern int cucul_set_dither_palette(IntPtr d,
617                               int[] r, int[] g,
618                               int[] b, int[] a);
619        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
620         SuppressUnmanagedCodeSecurity]
621        private static extern int cucul_set_dither_brightness(IntPtr d, float b);
622        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
623         SuppressUnmanagedCodeSecurity]
624        private static extern int cucul_set_dither_gamma(IntPtr d, float g);
625        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
626         SuppressUnmanagedCodeSecurity]
627        private static extern int cucul_set_dither_contrast(IntPtr d, float c);
628        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
629         SuppressUnmanagedCodeSecurity]
630        private static extern int cucul_set_dither_invert(IntPtr d, int i);
631        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
632         SuppressUnmanagedCodeSecurity]
633        private static extern int cucul_set_dither_antialias(IntPtr d, string s);
634        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
635         SuppressUnmanagedCodeSecurity]
636        private static extern string[] cucul_get_dither_antialias_list(IntPtr d);
637        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
638         SuppressUnmanagedCodeSecurity]
639        private static extern int cucul_set_dither_color(IntPtr d, string s);
640        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
641         SuppressUnmanagedCodeSecurity]
642        private static extern string[] cucul_get_dither_color_list(IntPtr d);
643        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
644         SuppressUnmanagedCodeSecurity]
645        private static extern int cucul_set_dither_charset(IntPtr d, string s);
646        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
647         SuppressUnmanagedCodeSecurity]
648        private static extern string[] cucul_get_dither_charset_list(IntPtr d);
649        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
650         SuppressUnmanagedCodeSecurity]
651        private static extern int cucul_set_dither_mode(IntPtr d, string s);
652        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
653         SuppressUnmanagedCodeSecurity]
654        private static extern string[] cucul_get_dither_mode_list(IntPtr d);
655
656
657        public int setBrightness(float b)
658        {
659            return cucul_set_dither_brightness(_dither, b);
660        }
661
662        public int setGamma(float g)
663        {
664            return cucul_set_dither_gamma(_dither, g);
665        }
666
667        public int setContrast(float c)
668        {
669            return cucul_set_dither_contrast(_dither, c);
670        }
671
672        public int setInvert(int i)
673        {
674            return cucul_set_dither_invert(_dither, i);
675        }
676
677        public int setAntialias(string s)
678        {
679            return cucul_set_dither_antialias(_dither, s);
680        }
681
682        public int setColor(string s)
683        {
684            return cucul_set_dither_color(_dither, s);
685        }
686
687        public int setCharset(string s)
688        {
689            return cucul_set_dither_charset(_dither, s);
690        }
691
692        public int setMode(string s)
693        {
694            return cucul_set_dither_mode(_dither, s);
695        }
696
697        /* <FIXME> */
698        public string[] getAntialiasList()
699        {
700            return cucul_get_dither_antialias_list(_dither);
701        }
702
703        public string[] getColorList()
704        {
705            return cucul_get_dither_color_list(_dither);
706        }
707
708        public string[] getCharsetList()
709        {
710            return cucul_get_dither_charset_list(_dither);
711        }
712
713        public string[] getModeList()
714        {
715            return cucul_get_dither_mode_list(_dither);
716        }
717
718        /* </FIXME> */
719    }
720
721    public class CuculFont : IDisposable
722    {
723        private IntPtr _font;
724        private GCHandle _gch;
725
726        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
727         SuppressUnmanagedCodeSecurity]
728        private static extern IntPtr cucul_load_font(IntPtr data, int len);
729        public CuculFont(string s)
730        {
731            IntPtr name = Marshal.StringToHGlobalAnsi(s);
732            _font = cucul_load_font(name, 0);
733            Marshal.FreeHGlobal(name);
734        }
735
736        public CuculFont(byte[] buf)
737        {
738            GCHandle _gch = GCHandle.Alloc(buf, GCHandleType.Pinned);
739            _font = cucul_load_font(_gch.AddrOfPinnedObject(), buf.Length);
740        }
741
742        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
743         SuppressUnmanagedCodeSecurity]
744        private static extern int cucul_free_font(IntPtr d);
745        public void Dispose()
746        {
747            cucul_free_font(_font);
748            _gch.Free();
749            GC.SuppressFinalize(this);
750        }
751
752        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
753         SuppressUnmanagedCodeSecurity]
754        private static extern IntPtr cucul_get_font_list();
755        public static string[] getList()
756        {
757            IntPtr l = cucul_get_font_list();
758
759            int size;
760            for(size = 0; true; size++)
761                if(Marshal.ReadIntPtr(l, IntPtr.Size * size) == IntPtr.Zero)
762                    break;
763
764            string[] ret = new string[size];
765            for(int i = 0; i < size; i++)
766            {
767                IntPtr s = Marshal.ReadIntPtr(l, IntPtr.Size * i);
768                ret[i] = Marshal.PtrToStringAnsi(s);
769            }
770
771            return ret;
772        }
773
774        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
775         SuppressUnmanagedCodeSecurity]
776        private static extern int cucul_get_font_width(IntPtr font);
777        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
778         SuppressUnmanagedCodeSecurity]
779        private static extern int cucul_get_font_height(IntPtr font);
780        public Size Size
781        {
782            get { return new Size(cucul_get_font_width(_font),
783                                  cucul_get_font_height(_font)); }
784        }
785
786        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
787         SuppressUnmanagedCodeSecurity]
788        private static extern IntPtr cucul_get_font_blocks(IntPtr font);
789        public int[,] getBlocks()
790        {
791            IntPtr l = cucul_get_font_blocks(_font);
792
793            int size;
794            for(size = 1; true; size += 2)
795                if(Marshal.ReadIntPtr(l, IntPtr.Size * size) == IntPtr.Zero)
796                    break;
797
798            int[,] ret = new int[size,2];
799            for(int i = 0; i < size; i++)
800            {
801                ret[i,0] = (int)Marshal.ReadIntPtr(l, IntPtr.Size * i * 2);
802                ret[i,1] = (int)Marshal.ReadIntPtr(l, IntPtr.Size * i * 2 + 1);
803            }
804
805            return ret;
806        }
807    }
808}
809
Note: See TracBrowser for help on using the repository browser.