source: libcaca/trunk/ruby/cucul-canvas.c @ 2004

Last change on this file since 2004 was 2004, checked in by Pascal Terjan, 12 years ago
  • Improve type checking of arguments
  • Property svn:eol-style set to native
File size: 18.0 KB
Line 
1/*
2 *  libcucul Ruby bindings
3 *  Copyright (c) 2007 Pascal Terjan <pterjan@linuxfr.org>
4 *
5 *  This library is free software. It comes without any warranty, to
6 *  the extent permitted by applicable law. You can redistribute it
7 *  and/or modify it under the terms of the Do What The Fuck You Want
8 *  To Public License, Version 2, as published by Sam Hocevar. See
9 *  http://sam.zoy.org/wtfpl/COPYING for more details.
10 */
11
12#include <ruby.h>
13#include <cucul.h>
14#include <errno.h>
15#include "cucul-font.h"
16#include "common.h"
17
18VALUE cCanvas;
19
20#define simple_func(x)                                  \
21static VALUE x (VALUE self)                             \
22{                                                       \
23    if( cucul_##x (_SELF) <0)                           \
24        rb_raise(rb_eRuntimeError, strerror(errno));    \
25                                                        \
26    return self;                                        \
27}
28
29#define get_int(x)                                      \
30static VALUE get_##x (VALUE self)                       \
31{                                                       \
32    return INT2NUM(cucul_get_##x (_SELF));              \
33}
34
35static void canvas_free(void * p)
36{
37    cucul_free_canvas((cucul_canvas_t *)p);
38}
39
40static VALUE canvas_alloc(VALUE klass)
41{
42    cucul_canvas_t *canvas;
43    VALUE obj;
44   
45    canvas = cucul_create_canvas(0, 0);
46    obj = Data_Wrap_Struct(klass, 0, canvas_free, canvas);
47   
48    return obj;
49}
50
51static VALUE canvas_initialize(VALUE self, VALUE width, VALUE height)
52{
53    unsigned int w, h;
54
55    w = NUM2INT(width);
56    h = NUM2INT(height);
57   
58    cucul_set_canvas_size(_SELF, w, h);
59   
60    return self;
61}
62
63get_int(canvas_height)
64get_int(canvas_width)
65
66static VALUE set_canvas_width(VALUE self, VALUE width)
67{
68    cucul_set_canvas_size(_SELF, NUM2INT(width), cucul_get_canvas_height(_SELF));
69    return width;
70}
71
72static VALUE set_canvas_width2(VALUE self, VALUE width)
73{
74    set_canvas_width(self, width);
75    return self;
76}
77
78static VALUE set_canvas_height(VALUE self, VALUE height)
79{
80    cucul_set_canvas_size(_SELF, cucul_get_canvas_width(_SELF), NUM2INT(height));
81    return height;
82}
83
84static VALUE set_canvas_height2(VALUE self, VALUE height)
85{
86    set_canvas_height(self, height);
87    return self;
88}
89
90static VALUE set_canvas_size(VALUE self, VALUE height, VALUE width)
91{
92    cucul_set_canvas_size(_SELF, NUM2INT(width), NUM2INT(height));
93    return self;
94}
95
96/****/
97
98static VALUE gotoxy(VALUE self, VALUE x, VALUE y)
99{
100    if( cucul_gotoxy(_SELF, NUM2INT(x), NUM2INT(y)) <0) {
101        rb_raise(rb_eRuntimeError, strerror(errno));
102    }
103    return self;
104}
105
106get_int(cursor_x)
107get_int(cursor_y)
108
109simple_func(clear_canvas)
110
111static VALUE put_char(VALUE self, VALUE x, VALUE y, VALUE ch)
112{
113    cucul_put_char(_SELF, NUM2INT(x), NUM2INT(y), NUM2ULONG(ch));
114    return self;
115}
116
117static VALUE get_char(VALUE self, VALUE x, VALUE y)
118{
119    unsigned long int ch;
120    ch = cucul_get_char(_SELF, NUM2INT(x), NUM2INT(y));
121    return INT2NUM(ch);
122}
123
124static VALUE put_str(VALUE self, VALUE x, VALUE y, VALUE str)
125{
126    cucul_put_str(_SELF, NUM2INT(x), NUM2INT(y), StringValuePtr(str));
127    return self;
128}
129
130static VALUE get_attr(VALUE self, VALUE x, VALUE y)
131{
132    unsigned long int ch;
133    ch = cucul_get_attr(_SELF, NUM2INT(x), NUM2INT(y));
134    return INT2NUM(ch);
135}
136
137static VALUE set_attr(VALUE self, VALUE attr)
138{
139    if(cucul_set_attr(_SELF, NUM2ULONG(attr)) <0)
140        rb_raise(rb_eRuntimeError, strerror(errno));
141
142    return self;
143}
144
145static VALUE set_attr2(VALUE self, VALUE attr)
146{
147    set_attr(self, attr);
148    return self;
149}
150
151static VALUE put_attr(VALUE self, VALUE x, VALUE y, VALUE attr)
152{
153    if(cucul_put_attr(_SELF, NUM2INT(x), NUM2INT(y), NUM2ULONG(attr)) <0)
154        rb_raise(rb_eRuntimeError, strerror(errno));
155
156    return self;
157}
158
159static VALUE set_color_ansi(VALUE self, VALUE fg, VALUE bg)
160{
161    if(cucul_set_color_ansi(_SELF, NUM2INT(fg), NUM2INT(bg)) <0)
162        rb_raise(rb_eRuntimeError, strerror(errno));
163
164    return self;
165}
166
167static VALUE set_color_argb(VALUE self, VALUE fg, VALUE bg)
168{
169    if(cucul_set_color_argb(_SELF, NUM2UINT(fg), NUM2UINT(bg)) <0) {
170        rb_raise(rb_eRuntimeError, strerror(errno));
171    }
172    return self;
173}
174
175static VALUE cprintf(int argc, VALUE* argv, VALUE self)
176{
177    int x, y;
178    VALUE rx, ry, format, rest, string;
179    rb_scan_args(argc, argv, "3*", &rx, &ry, &format, &rest);
180    x = NUM2INT(rx);
181    y = NUM2INT(ry);
182    string = rb_funcall2(rb_mKernel, rb_intern("sprintf"), argc-2, argv+2);
183    cucul_put_str(_SELF, x, y, StringValuePtr(string));
184    return self;
185}
186
187
188get_int(canvas_handle_x)
189get_int(canvas_handle_y)
190
191static VALUE set_canvas_handle(VALUE self, VALUE x, VALUE y)
192{
193    cucul_set_canvas_handle(_SELF, NUM2INT(x), NUM2INT(y));
194    return self;
195}
196
197static VALUE blit(int argc, VALUE* argv, VALUE self) {
198    VALUE x, y, src, mask;
199    cucul_canvas_t *csrc, *cmask;
200
201    rb_scan_args(argc, argv, "31", &x, &y, &src, &mask);
202
203    Check_Type(x, T_FIXNUM);
204    Check_Type(y, T_FIXNUM);
205
206    if(CLASS_OF(src) != cCanvas)
207    {
208        rb_raise(rb_eArgError, "src is not a Cucul::Canvas");
209    }
210    Data_Get_Struct(src, cucul_canvas_t, csrc);
211
212    if(!NIL_P(mask))
213    {
214        if(CLASS_OF(mask) != cCanvas)
215        {
216            rb_raise(rb_eArgError, "mask is not a Cucul::Canvas");
217        }
218        Data_Get_Struct(mask, cucul_canvas_t, cmask);
219    }
220    else
221        cmask = NULL;
222   
223    if(cucul_blit(_SELF, NUM2INT(x), NUM2INT(y), csrc, cmask)<0)
224        rb_raise(rb_eRuntimeError, strerror(errno));
225
226    return self;
227}
228
229static VALUE set_canvas_boundaries(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)
230{
231    if(cucul_set_canvas_boundaries(_SELF, NUM2INT(x), NUM2INT(y), NUM2UINT(w), NUM2UINT(h))<0)
232    {
233        rb_raise(rb_eRuntimeError, strerror(errno));
234    }
235    return self;
236}
237
238/****/
239
240simple_func(invert)
241simple_func(flip)
242simple_func(flop)
243simple_func(rotate_180)
244simple_func(rotate_left)
245simple_func(rotate_right)
246simple_func(stretch_left)
247simple_func(stretch_right)
248
249/****/
250
251static VALUE draw_line(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE ch)
252{
253    cucul_draw_line(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),NUM2ULONG(ch));
254    return self;
255}
256
257static VALUE draw_polyline(VALUE self, VALUE points, VALUE ch)
258{
259    int i, n;
260    int *ax, *ay;
261    int error = 0;
262    VALUE v, x, y;
263
264    n = RARRAY(points)->len;
265
266    ax = (int*)malloc(n*sizeof(int));
267    if(!ax)
268        rb_raise(rb_eNoMemError,"Out of memory");
269
270    ay = (int*)malloc(n*sizeof(int));
271    if(!ay)
272    {
273        free(ax);
274        rb_raise(rb_eNoMemError,"Out of memory");
275    }
276
277    for(i=0; i<n; i++)
278    {
279        v = rb_ary_entry(points, i);
280        if((TYPE(v) == T_ARRAY) && (RARRAY(v)->len == 2))
281        {
282            x = rb_ary_entry(v,0);
283            y = rb_ary_entry(v,1);
284            if(rb_obj_is_kind_of(x, rb_cInteger) &&
285               rb_obj_is_kind_of(y, rb_cInteger))
286            {
287                ax[i] = NUM2INT(x);
288                ay[i] = NUM2INT(y);
289            } else
290                error = 1;
291        }
292        else
293            error = 1;
294    }
295
296    if(error)
297    {
298        free(ax);
299        free(ay);
300        rb_raise(rb_eArgError, "Invalid list of points");
301    }
302
303    n--;
304
305    cucul_draw_polyline(_SELF, ax, ay, n, NUM2ULONG(ch));
306
307    free(ax);
308    free(ay);
309
310    return self;
311}
312
313static VALUE draw_thin_line(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
314{
315    cucul_draw_thin_line(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2));
316    return self;
317}
318
319static VALUE draw_thin_polyline(VALUE self, VALUE points)
320{
321    int i, n;
322    int *ax, *ay;
323    int error = 0;
324    VALUE v, x, y;
325
326    n = RARRAY(points)->len;
327
328    ax = (int*)malloc(n*sizeof(int));
329    if(!ax)
330        rb_raise(rb_eNoMemError,"Out of memory");
331
332    ay = (int*)malloc(n*sizeof(int));
333    if(!ay)
334    {
335        free(ax);
336        rb_raise(rb_eNoMemError,"Out of memory");
337    }
338
339    for(i=0; i<n; i++)
340    {
341        v = rb_ary_entry(points, i);
342        if((TYPE(v) == T_ARRAY) && (RARRAY(v)->len == 2))
343        {
344            x = rb_ary_entry(v,0);
345            y = rb_ary_entry(v,1);
346            if(rb_obj_is_kind_of(x, rb_cInteger) &&
347               rb_obj_is_kind_of(y, rb_cInteger))
348            {
349                ax[i] = NUM2INT(x);
350                ay[i] = NUM2INT(y);
351            } else
352                error = 1;
353        }
354        else
355            error = 1;
356    }
357
358    if(error)
359    {
360        free(ax);
361        free(ay);
362        rb_raise(rb_eArgError, "Invalid list of points");
363    }
364
365    n--;
366
367    cucul_draw_thin_polyline(_SELF, ax, ay, n);
368
369    free(ax);
370    free(ay);
371
372    return self;
373}
374
375static VALUE draw_circle(VALUE self, VALUE x, VALUE y, VALUE r, VALUE ch)
376{
377    cucul_draw_circle(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(r), NUM2ULONG(ch));
378    return self;
379}
380
381static VALUE draw_ellipse(VALUE self, VALUE x, VALUE y, VALUE a, VALUE b, VALUE ch)
382{
383    cucul_draw_ellipse(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(a), NUM2INT(b), NUM2ULONG(ch));
384    return self;
385}
386
387static VALUE draw_thin_ellipse(VALUE self, VALUE x, VALUE y, VALUE a, VALUE b)
388{
389    cucul_draw_thin_ellipse(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(a), NUM2INT(b));
390    return self;
391}
392
393static VALUE fill_ellipse(VALUE self, VALUE x, VALUE y, VALUE a, VALUE b, VALUE ch)
394{
395    cucul_fill_ellipse(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(a), NUM2INT(b), NUM2ULONG(ch));
396    return self;
397}
398
399static VALUE draw_box(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE ch)
400{
401    cucul_draw_box(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2), NUM2ULONG(ch));
402    return self;
403}
404
405static VALUE draw_thin_box(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
406{
407    cucul_draw_thin_box(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2));
408    return self;
409}
410
411static VALUE draw_cp437_box(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
412{
413    cucul_draw_cp437_box(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2));
414    return self;
415}
416
417static VALUE fill_box(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE ch)
418{
419    cucul_fill_box(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2), NUM2ULONG(ch));
420    return self;
421}
422
423static VALUE draw_triangle(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE x3, VALUE y3, VALUE ch)
424{
425    cucul_draw_triangle(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),  NUM2INT(x3), NUM2INT(y3), NUM2ULONG(ch));
426    return self;
427}
428
429static VALUE draw_thin_triangle(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE x3, VALUE y3)
430{
431    cucul_draw_thin_triangle(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),  NUM2INT(x3), NUM2INT(y3));
432    return self;
433}
434
435static VALUE fill_triangle(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE x3, VALUE y3, VALUE ch)
436{
437    cucul_fill_triangle(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),  NUM2INT(x3), NUM2INT(y3), NUM2ULONG(ch));
438    return self;
439}
440
441/****/
442
443get_int(frame_count)
444
445static VALUE set_frame(VALUE self, VALUE id)
446{
447    if(cucul_set_frame(_SELF, NUM2INT(id))<0)
448        rb_raise(rb_eArgError, strerror(errno));
449
450    return self;
451}
452
453static VALUE set_frame2(VALUE self, VALUE id)
454{
455    set_frame(self, id);
456    return self;
457}
458
459static VALUE get_frame_name(VALUE self)
460{
461    return rb_str_new2(cucul_get_frame_name(_SELF));
462}
463
464static VALUE set_frame_name(VALUE self, VALUE name)
465{
466    if(cucul_set_frame_name(_SELF, StringValuePtr(name))<0)
467        rb_raise(rb_eRuntimeError, strerror(errno));
468
469    return self;
470}
471
472static VALUE set_frame_name2(VALUE self, VALUE name)
473{
474    set_frame_name(self, name);
475    return self;
476}
477
478static VALUE create_frame(VALUE self, VALUE id)
479{
480    if(cucul_create_frame(_SELF, NUM2INT(id))<0) {
481        rb_raise(rb_eRuntimeError, strerror(errno));
482    }
483    return self;
484}
485
486static VALUE free_frame(VALUE self, VALUE id)
487{
488    if(cucul_free_frame(_SELF, NUM2INT(id))<0) {
489        rb_raise(rb_eArgError, strerror(errno));
490    }
491    return self;
492}
493
494/****/
495
496static VALUE render_canvas(VALUE self, VALUE font, VALUE width, VALUE height, VALUE pitch)
497{
498    void *buf;
499    cucul_font_t *f;
500    VALUE b;
501
502    if(CLASS_OF(font) != cFont)
503    {
504        rb_raise(rb_eArgError, "First argument is not a Cucul::Font");
505    }
506
507    buf = malloc(width*height*4);
508    if(buf == NULL)
509    {
510        rb_raise(rb_eNoMemError, "Out of memory");
511    }
512
513    f = DATA_PTR(font);
514    cucul_render_canvas(_SELF, f, buf, NUM2UINT(width), NUM2UINT(height), NUM2UINT(pitch));
515
516    b = rb_str_new(buf, width*height*4);
517    free(buf);
518    return b;
519}
520
521static VALUE import_memory(VALUE self, VALUE data, VALUE format)
522{
523    long int bytes;
524    bytes = cucul_import_memory (_SELF, StringValuePtr(data), RSTRING(StringValue(data))->len, StringValuePtr(format));
525    if(bytes <= 0)
526        rb_raise(rb_eRuntimeError, strerror(errno));
527
528    return self;
529}
530
531static VALUE import_file(VALUE self, VALUE filename, VALUE format)
532{
533    long int bytes;
534    bytes = cucul_import_file (_SELF, StringValuePtr(filename), StringValuePtr(format));
535    if(bytes <= 0)
536        rb_raise(rb_eRuntimeError, strerror(errno));
537
538    return self;
539}
540
541static VALUE export_memory(VALUE self, VALUE format)
542{
543    unsigned long int bytes;
544    void *result;
545    VALUE ret;
546    result = cucul_export_memory (_SELF, StringValuePtr(format), &bytes);
547    ret = rb_str_new(result, bytes);
548    free(result);
549    return ret;
550}
551
552static VALUE export_list(void)
553{
554    VALUE ary, ary2;
555   
556    char const* const* list;
557   
558    list = cucul_get_export_list();
559   
560    ary = rb_ary_new();
561   
562    while (*list != NULL)
563    {
564        ary2 = rb_ary_new();
565        rb_ary_push(ary2, rb_str_new2(*list));
566        list++;
567        rb_ary_push(ary2, rb_str_new2(*list));
568        list++;
569        rb_ary_push(ary, ary2);
570    }
571
572    return ary;
573}
574
575static VALUE import_list(void)
576{
577    VALUE ary, ary2;
578   
579    char const* const* list;
580   
581    list = cucul_get_import_list();
582   
583    ary = rb_ary_new();
584   
585    while (*list != NULL)
586    {
587        ary2 = rb_ary_new();
588        rb_ary_push(ary2, rb_str_new2(*list));
589        list++;
590        rb_ary_push(ary2, rb_str_new2(*list));
591        list++;
592        rb_ary_push(ary, ary2);
593    }
594
595    return ary;
596}
597
598/****/
599
600void Init_cucul_canvas(VALUE mCucul)
601{
602    cCanvas = rb_define_class_under(mCucul, "Canvas", rb_cObject);
603    rb_define_alloc_func(cCanvas, canvas_alloc);
604
605    rb_define_method(cCanvas, "initialize", canvas_initialize, 2);
606    rb_define_method(cCanvas, "width", get_canvas_width, 0);
607    rb_define_method(cCanvas, "width=", set_canvas_width, 1);
608    rb_define_method(cCanvas, "set_width", set_canvas_width2, 1);
609    rb_define_method(cCanvas, "height", get_canvas_height, 0);
610    rb_define_method(cCanvas, "height=", set_canvas_height, 1);
611    rb_define_method(cCanvas, "set_height", set_canvas_height2, 1);
612    rb_define_method(cCanvas, "set_size", set_canvas_size, 2);
613       
614    rb_define_method(cCanvas, "gotoxy", gotoxy, 2);
615    rb_define_method(cCanvas, "cursor_x", get_cursor_x, 0);
616    rb_define_method(cCanvas, "cursor_y", get_cursor_y, 0);
617    rb_define_method(cCanvas, "handle_x", get_canvas_handle_x, 0);
618    rb_define_method(cCanvas, "handle_y", get_canvas_handle_y, 0);
619    rb_define_method(cCanvas, "set_handle", set_canvas_handle, 2);
620    rb_define_method(cCanvas, "blit", blit, -1);
621    rb_define_method(cCanvas, "set_boundaries", set_canvas_boundaries, 4);
622
623    rb_define_method(cCanvas, "clear", clear_canvas, 0);
624   
625    rb_define_method(cCanvas, "put_char", put_char, 3);
626    rb_define_method(cCanvas, "get_char", get_char, 2);
627    rb_define_method(cCanvas, "put_str", put_str, 3);
628    rb_define_method(cCanvas, "printf", cprintf, -1);
629
630    rb_define_method(cCanvas, "get_attr", get_attr, 3);
631    rb_define_method(cCanvas, "attr=", set_attr, 1);
632    rb_define_method(cCanvas, "set_attr", set_attr2, 1);
633    rb_define_method(cCanvas, "put_attr", put_attr, 3);
634    rb_define_method(cCanvas, "set_color_ansi", set_color_ansi, 2);
635    rb_define_method(cCanvas, "set_color_argb", set_color_argb, 2);
636
637    rb_define_method(cCanvas, "invert", invert, 0);
638    rb_define_method(cCanvas, "flip", flip, 0);
639    rb_define_method(cCanvas, "flop", flop, 0);
640    rb_define_method(cCanvas, "rotate_180", rotate_180, 0);
641    rb_define_method(cCanvas, "rotate_left", rotate_left, 0);
642    rb_define_method(cCanvas, "rotate_right", rotate_right, 0);
643    rb_define_method(cCanvas, "stretch_left", stretch_left, 0);
644    rb_define_method(cCanvas, "stretch_right", stretch_right, 0);
645
646    rb_define_method(cCanvas, "draw_line", draw_line, 5);
647    rb_define_method(cCanvas, "draw_polyline", draw_polyline, 2);
648    rb_define_method(cCanvas, "draw_thin_line", draw_thin_line, 4);
649    rb_define_method(cCanvas, "draw_thin_polyline", draw_thin_polyline, 1);
650    rb_define_method(cCanvas, "draw_circle", draw_circle, 4);
651    rb_define_method(cCanvas, "draw_ellipse", draw_ellipse, 5);
652    rb_define_method(cCanvas, "draw_thin_ellipse", draw_thin_ellipse, 4);
653    rb_define_method(cCanvas, "fill_ellipse", fill_ellipse, 5);
654    rb_define_method(cCanvas, "draw_box", draw_box, 5);
655    rb_define_method(cCanvas, "draw_thin_box", draw_thin_box, 4);
656    rb_define_method(cCanvas, "draw_cp437_box", draw_cp437_box, 4);
657    rb_define_method(cCanvas, "fill_box", fill_box, 5);
658    rb_define_method(cCanvas, "draw_triangle", draw_triangle, 7);
659    rb_define_method(cCanvas, "draw_thin_triangle", draw_thin_triangle, 6);
660    rb_define_method(cCanvas, "fill_triangle", fill_triangle, 7);
661
662    rb_define_method(cCanvas, "frame_count", get_frame_count, 0);
663    rb_define_method(cCanvas, "frame=", set_frame, 1);
664    rb_define_method(cCanvas, "set_frame", set_frame2, 1);
665    rb_define_method(cCanvas, "frame_name", get_frame_name, 0);
666    rb_define_method(cCanvas, "frame_name=", set_frame_name, 1);
667    rb_define_method(cCanvas, "set_frame_name", set_frame_name2, 1);
668    rb_define_method(cCanvas, "create_frame", create_frame, 1);
669    rb_define_method(cCanvas, "free_frame", free_frame, 1);
670
671    rb_define_method(cCanvas, "render", render_canvas, 4);
672    rb_define_method(cCanvas, "import_memory", import_memory, 2);
673    rb_define_method(cCanvas, "import_file", import_file, 2);
674    rb_define_method(cCanvas, "export_memory", export_memory, 1);
675    rb_define_singleton_method(cCanvas, "export_list", export_list, 0);
676    rb_define_singleton_method(cCanvas, "import_list", import_list, 0);
677   
678}
679
Note: See TracBrowser for help on using the repository browser.