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

Last change on this file since 2089 was 2089, checked in by Sam Hocevar, 13 years ago
  • Minor naming convention changes in the C# bindings.
  • Property svn:keywords set to Id
File size: 31.7 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 2089 2007-11-28 07:15:05Z 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
329        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
330         SuppressUnmanagedCodeSecurity]
331        private static extern int cucul_draw_line(IntPtr cv, int x1, int y1,
332                                                  int x2, int y2, uint c);
333        public int drawLine(Point p1, Point p2, uint c)
334        {
335            return cucul_draw_line(_cv, p1.X, p1.Y, p2.X, p2.Y, c);
336        }
337
338        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
339         SuppressUnmanagedCodeSecurity]
340        private static extern int cucul_draw_polyline(IntPtr cv, int[] x,
341                                                      int[] y, int n, uint c);
342        public int drawPolyline(Point[] lp, uint c)
343        {
344            int[] lx = new int[lp.Length];
345            int[] ly = new int[lp.Length];
346            for(int i = 0; i < lp.Length; i++)
347            {
348                lx[i] = lp[i].X;
349                ly[i] = lp[i].Y;
350            }
351            return cucul_draw_polyline(_cv, lx, ly, lp.Length - 1, c);
352        }
353
354        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
355         SuppressUnmanagedCodeSecurity]
356        private static extern int cucul_draw_thin_line(IntPtr cv, int x1,
357                                                       int y1, int x2, int y2);
358        public int drawThinLine(Point p1, Point p2)
359        {
360            return cucul_draw_thin_line(_cv, p1.X, p1.Y, p2.X, p2.Y);
361        }
362
363        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
364         SuppressUnmanagedCodeSecurity]
365        private static extern int cucul_draw_thin_polyline(IntPtr cv, int[] x,
366                                                           int[] y, int n);
367        public int drawThinPolyline(Point[] lp)
368        {
369            int[] lx = new int[lp.Length];
370            int[] ly = new int[lp.Length];
371            for(int i = 0; i < lp.Length; i++)
372            {
373                lx[i] = lp[i].X;
374                ly[i] = lp[i].Y;
375            }
376            return cucul_draw_thin_polyline(_cv, lx, ly, lp.Length - 1);
377        }
378
379        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
380         SuppressUnmanagedCodeSecurity]
381        private static extern int cucul_draw_circle(IntPtr cv, int x, int y,
382                                                    int r, uint c);
383        public int drawCircle(Point p1, int r, uint c)
384        {
385            return cucul_draw_circle(_cv, p1.X, p1.Y, r, c);
386        }
387
388        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
389         SuppressUnmanagedCodeSecurity]
390        private static extern int cucul_draw_ellipse(IntPtr cv, int x, int y,
391                                                     int a, int b, uint c);
392        public int drawEllipse(Point p1, int a, int b, uint c)
393        {
394            return cucul_draw_ellipse(_cv, p1.X, p1.Y, a, b, c);
395        }
396
397        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
398         SuppressUnmanagedCodeSecurity]
399        private static extern int cucul_draw_thin_ellipse(IntPtr cv,
400                                                          int x, int y,
401                                                          int a, int b);
402        public int drawThinEllipse(Point p1, int a, int b)
403        {
404            return cucul_draw_thin_ellipse(_cv, p1.X, p1.Y, a, b);
405        }
406
407        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
408         SuppressUnmanagedCodeSecurity]
409        private static extern int cucul_fill_ellipse(IntPtr cv, int x, int y,
410                                                     int a, int b, uint c);
411        public int fillEllipse(Point p1, int a, int b, uint c)
412        {
413            return cucul_fill_ellipse(_cv, p1.X, p1.Y, a, b, c);
414        }
415
416        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
417         SuppressUnmanagedCodeSecurity]
418        private static extern int cucul_draw_box(IntPtr cv, int x, int y,
419                                                 int w, int h, uint c);
420        public int drawBox(Rectangle r, uint c)
421        {
422            return cucul_draw_box(_cv, r.X, r.Y, r.Width, r.Height, c);
423        }
424
425        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
426         SuppressUnmanagedCodeSecurity]
427        private static extern int cucul_draw_thin_box(IntPtr cv, int x, int y,
428                                                      int w, int h);
429        public int drawThinBox(Rectangle r)
430        {
431            return cucul_draw_thin_box(_cv, r.X, r.Y, r.Width, r.Height);
432        }
433
434        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
435         SuppressUnmanagedCodeSecurity]
436        private static extern int cucul_draw_cp437_box(IntPtr cv, int x, int y,
437                                                       int w, int h);
438        public int drawCp437Box(Rectangle r)
439        {
440            return cucul_draw_cp437_box(_cv, r.X, r.Y, r.Width, r.Height);
441        }
442
443        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
444         SuppressUnmanagedCodeSecurity]
445        private static extern int cucul_fill_box(IntPtr cv, int x, int y,
446                                                 int w, int h, uint c);
447        public int fillBox(Rectangle r, uint c)
448        {
449            return cucul_fill_box(_cv, r.X, r.Y, r.Width, r.Height, c);
450        }
451
452        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
453         SuppressUnmanagedCodeSecurity]
454        private static extern int cucul_draw_triangle(IntPtr cv, int x1,
455                                                      int y1, int x2, int y2,
456                                                      int x3, int y3, uint c);
457        public int drawTriangle(Point p1, Point p2, Point p3, uint c)
458        {
459            return cucul_draw_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
460                                       p3.X, p3.Y, c);
461        }
462
463        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
464         SuppressUnmanagedCodeSecurity]
465        private static extern int cucul_draw_thin_triangle(IntPtr cv,
466                                                           int x1, int y1,
467                                                           int x2, int y2,
468                                                           int x3, int y3);
469        public int drawThinTriangle(Point p1, Point p2, Point p3)
470        {
471            return cucul_draw_thin_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
472                                            p3.X, p3.Y);
473        }
474
475        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
476         SuppressUnmanagedCodeSecurity]
477        private static extern int cucul_fill_triangle(IntPtr cv, int x1,
478                                                      int y1, int x2, int y2,
479                                                      int x3, int y3, uint c);
480        public int fillTriangle(Point p1, Point p2, Point p3, uint c)
481        {
482            return cucul_fill_triangle(_cv, p1.X, p1.Y, p2.X, p2.Y,
483                                       p3.X, p3.Y, c);
484        }
485
486        /* frame handling */
487
488        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
489         SuppressUnmanagedCodeSecurity]
490        private static extern int cucul_get_frame_count(IntPtr cv);
491        public int getFrameCount()
492        {
493            return cucul_get_frame_count(_cv);
494        }
495
496        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
497         SuppressUnmanagedCodeSecurity]
498        private static extern int cucul_set_frame(IntPtr cv, int f);
499        public int setFrame(int f)
500        {
501            return cucul_set_frame(_cv, f);
502        }
503
504        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
505         SuppressUnmanagedCodeSecurity]
506        private static extern string cucul_get_frame_name(IntPtr cv);
507        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
508         SuppressUnmanagedCodeSecurity]
509        private static extern int cucul_set_frame_name(IntPtr cv, string n);
510        public string FrameName
511        {
512            get { return cucul_get_frame_name(_cv); }
513            set { cucul_set_frame_name(_cv, value); }
514        }
515
516        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
517         SuppressUnmanagedCodeSecurity]
518        private static extern int cucul_create_frame(IntPtr cv, int f);
519        public int createFrame(int f)
520        {
521            return cucul_create_frame(_cv, f);
522        }
523
524        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
525         SuppressUnmanagedCodeSecurity]
526        private static extern int cucul_free_frame(IntPtr cv, int f);
527        public int freeFrame(int f)
528        {
529            return cucul_free_frame(_cv, f);
530        }
531
532        /* bitmap dithering */
533
534        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
535         SuppressUnmanagedCodeSecurity]
536        private static extern int cucul_dither_bitmap(IntPtr c, int  x, int y,
537                                                      int w, int h,
538                                                      IntPtr d, IntPtr data);
539        public int ditherBitmap(Rectangle r, CuculDither d, object data)
540        {
541            GCHandle gch = GCHandle.Alloc(data, GCHandleType.Pinned);
542            int ret = cucul_dither_bitmap(_cv, r.X, r.Y, r.Width, r.Height,
543                                          d._dither, gch.AddrOfPinnedObject());
544            gch.Free();
545            return ret;
546        }
547    }
548
549    public class CuculAttr
550    {
551        private int _attr;
552
553        public CuculAttr(int attr)
554        {
555            _attr = attr;
556        }
557
558        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
559         SuppressUnmanagedCodeSecurity]
560        private static extern byte cucul_attr_to_ansi(Int32 a);
561        public byte toAnsi()
562        {
563            return cucul_attr_to_ansi(_attr);
564        }
565
566        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
567         SuppressUnmanagedCodeSecurity]
568        private static extern byte cucul_attr_to_ansi_fg(Int32 a);
569        public byte toAnsiFg()
570        {
571            return cucul_attr_to_ansi_fg(_attr);
572        }
573
574        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
575         SuppressUnmanagedCodeSecurity]
576        private static extern byte cucul_attr_to_ansi_bg(Int32 a);
577        public byte toAnsiBg()
578        {
579            return cucul_attr_to_ansi_bg(_attr);
580        }
581    }
582
583    public class CuculDither : IDisposable
584    {
585        public readonly IntPtr _dither;
586
587        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
588         SuppressUnmanagedCodeSecurity]
589        private static extern IntPtr cucul_create_dither(int bpp, int w,
590                                                         int h, int pitch,
591                                                         ulong rmask,
592                                                         ulong gmask,
593                                                         ulong bmask,
594                                                         ulong amask);
595        public CuculDither(int bpp, Size s, int pitch,
596                           uint rmask, uint gmask, uint bmask, uint amask)
597        {
598            _dither = cucul_create_dither(bpp, s.Width, s.Height, pitch,
599                                          rmask, gmask, bmask, amask);
600        }
601
602        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
603         SuppressUnmanagedCodeSecurity]
604        private static extern int cucul_free_dither(IntPtr d);
605        public void Dispose()
606        {
607            cucul_free_dither(_dither);
608            GC.SuppressFinalize(this);
609        }
610
611        /* TODO: fix this shit */
612
613        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
614         SuppressUnmanagedCodeSecurity]
615        private static extern int cucul_set_dither_palette(IntPtr d,
616                               int[] r, int[] g,
617                               int[] b, int[] a);
618        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
619         SuppressUnmanagedCodeSecurity]
620        private static extern int cucul_set_dither_brightness(IntPtr d, float b);
621        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
622         SuppressUnmanagedCodeSecurity]
623        private static extern int cucul_set_dither_gamma(IntPtr d, float g);
624        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
625         SuppressUnmanagedCodeSecurity]
626        private static extern int cucul_set_dither_contrast(IntPtr d, float c);
627        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
628         SuppressUnmanagedCodeSecurity]
629        private static extern int cucul_set_dither_invert(IntPtr d, int i);
630        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
631         SuppressUnmanagedCodeSecurity]
632        private static extern int cucul_set_dither_antialias(IntPtr d, string s);
633        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
634         SuppressUnmanagedCodeSecurity]
635        private static extern string[] cucul_get_dither_antialias_list(IntPtr d);
636        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
637         SuppressUnmanagedCodeSecurity]
638        private static extern int cucul_set_dither_color(IntPtr d, string s);
639        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
640         SuppressUnmanagedCodeSecurity]
641        private static extern string[] cucul_get_dither_color_list(IntPtr d);
642        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
643         SuppressUnmanagedCodeSecurity]
644        private static extern int cucul_set_dither_charset(IntPtr d, string s);
645        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
646         SuppressUnmanagedCodeSecurity]
647        private static extern string[] cucul_get_dither_charset_list(IntPtr d);
648        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
649         SuppressUnmanagedCodeSecurity]
650        private static extern int cucul_set_dither_mode(IntPtr d, string s);
651        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
652         SuppressUnmanagedCodeSecurity]
653        private static extern string[] cucul_get_dither_mode_list(IntPtr d);
654
655
656        public int setBrightness(float b)
657        {
658            return cucul_set_dither_brightness(_dither, b);
659        }
660
661        public int setGamma(float g)
662        {
663            return cucul_set_dither_gamma(_dither, g);
664        }
665
666        public int setContrast(float c)
667        {
668            return cucul_set_dither_contrast(_dither, c);
669        }
670
671        public int setInvert(int i)
672        {
673            return cucul_set_dither_invert(_dither, i);
674        }
675
676        public int setAntialias(string s)
677        {
678            return cucul_set_dither_antialias(_dither, s);
679        }
680
681        public int setColor(string s)
682        {
683            return cucul_set_dither_color(_dither, s);
684        }
685
686        public int setCharset(string s)
687        {
688            return cucul_set_dither_charset(_dither, s);
689        }
690
691        public int setMode(string s)
692        {
693            return cucul_set_dither_mode(_dither, s);
694        }
695
696        /* <FIXME> */
697        public string[] getAntialiasList()
698        {
699            return cucul_get_dither_antialias_list(_dither);
700        }
701
702        public string[] getColorList()
703        {
704            return cucul_get_dither_color_list(_dither);
705        }
706
707        public string[] getCharsetList()
708        {
709            return cucul_get_dither_charset_list(_dither);
710        }
711
712        public string[] getModeList()
713        {
714            return cucul_get_dither_mode_list(_dither);
715        }
716
717        /* </FIXME> */
718    }
719
720    public class CuculFont : IDisposable
721    {
722        private IntPtr _font;
723        private GCHandle _gch;
724
725        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
726         SuppressUnmanagedCodeSecurity]
727        private static extern IntPtr cucul_load_font(IntPtr data, int len);
728        public CuculFont(string s)
729        {
730            IntPtr name = Marshal.StringToHGlobalAnsi(s);
731            _font = cucul_load_font(name, 0);
732            Marshal.FreeHGlobal(name);
733        }
734
735        public CuculFont(byte[] buf)
736        {
737            GCHandle _gch = GCHandle.Alloc(buf, GCHandleType.Pinned);
738            _font = cucul_load_font(_gch.AddrOfPinnedObject(), buf.Length);
739        }
740
741        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
742         SuppressUnmanagedCodeSecurity]
743        private static extern int cucul_free_font(IntPtr d);
744        public void Dispose()
745        {
746            cucul_free_font(_font);
747            _gch.Free();
748            GC.SuppressFinalize(this);
749        }
750
751        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
752         SuppressUnmanagedCodeSecurity]
753        private static extern IntPtr cucul_get_font_list();
754        public static string[] getList()
755        {
756            IntPtr l = cucul_get_font_list();
757
758            int size;
759            for(size = 0; true; size++)
760                if(Marshal.ReadIntPtr(l, IntPtr.Size * size) == IntPtr.Zero)
761                    break;
762
763            string[] ret = new string[size];
764            for(int i = 0; i < size; i++)
765            {
766                IntPtr s = Marshal.ReadIntPtr(l, IntPtr.Size * i);
767                ret[i] = Marshal.PtrToStringAnsi(s);
768            }
769
770            return ret;
771        }
772
773        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
774         SuppressUnmanagedCodeSecurity]
775        private static extern int cucul_get_font_width(IntPtr font);
776        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
777         SuppressUnmanagedCodeSecurity]
778        private static extern int cucul_get_font_height(IntPtr font);
779        public Size Size
780        {
781            get { return new Size(cucul_get_font_width(_font),
782                                  cucul_get_font_height(_font)); }
783        }
784
785        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
786         SuppressUnmanagedCodeSecurity]
787        private static extern IntPtr cucul_get_font_blocks(IntPtr font);
788        public int[,] getBlocks()
789        {
790            IntPtr l = cucul_get_font_blocks(_font);
791
792            int size;
793            for(size = 1; true; size += 2)
794                if(Marshal.ReadIntPtr(l, IntPtr.Size * size) == IntPtr.Zero)
795                    break;
796
797            int[,] ret = new int[size,2];
798            for(int i = 0; i < size; i++)
799            {
800                ret[i,0] = (int)Marshal.ReadIntPtr(l, IntPtr.Size * i * 2);
801                ret[i,1] = (int)Marshal.ReadIntPtr(l, IntPtr.Size * i * 2 + 1);
802            }
803
804            return ret;
805        }
806
807        [DllImport("libcucul.dll", CallingConvention=CallingConvention.Cdecl),
808         SuppressUnmanagedCodeSecurity]
809        private static extern int cucul_render_canvas(IntPtr cv, IntPtr f,
810                                                      IntPtr buf, int w, int h,
811                                                      int pitch);
812        public int Render(CuculCanvas cv, uint[,] buf, int pitch)
813        {
814            GCHandle gch = GCHandle.Alloc(buf, GCHandleType.Pinned);
815            int ret = cucul_render_canvas(cv._cv, _font,
816                                          gch.AddrOfPinnedObject(),
817                                          buf.GetLength(0), buf.GetLength(1),
818                                          pitch);
819            gch.Free();
820            return ret;
821        }
822    }
823}
824
Note: See TracBrowser for help on using the repository browser.