cacalabs
/
libcaca
spogulis no https://github.com/cacalabs/libcaca.git
1
0
Atdalīts 0
Kods Problēmas 0 Laidieni 7 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
2025 Revīzijas
1 Atzars
89 MiB
 
 
 
 
 
 
Koks: 052c6546a1
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '052c6546a1'
${ noResults }
libcaca/ruby/caca-canvas.c

842 rindas
23 KiB
Neapstrādāts Vainot Vēsture 

  1. /*

  2.  *  libcaca Ruby bindings

  3.  *  Copyright © 2007—2014 Pascal Terjan <pterjan@linuxfr.org>

  4.  *              2021 Sam Hocevar <sam@hocevar.net>

  5.  *              All Rights Reserved

  6.  *

  7.  *  This library is free software. It comes without any warranty, to

  8.  *  the extent permitted by applicable law. You can redistribute it

  9.  *  and/or modify it under the terms of the Do What the Fuck You Want

  10.  *  to Public License, Version 2, as published by Sam Hocevar. See

  11.  *  http://www.wtfpl.net/ for more details.

  12.  */

  13. 

  14. #include <ruby.h>

  15. #include <caca.h>

  16. #include <errno.h>

  17. #include "caca-dither.h"

  18. #include "caca-font.h"

  19. #include "caca_internals.h"

  20. #include "common.h"

  21. #include "limits.h"

  22. 

  23. VALUE cCanvas;

  24. 

  25. #define simple_func(x)                                  \

  26. static VALUE x (VALUE self)                             \

  27. {                                                       \

  28.     if( caca_##x (_SELF) <0)                            \

  29.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));    \

  30.                                                         \

  31.     return self;                                        \

  32. }

  33. 

  34. #define get_int(x)                                      \

  35. static VALUE get_##x (VALUE self)                       \

  36. {                                                       \

  37.     return INT2NUM(caca_get_##x (_SELF));               \

  38. }

  39. 

  40. static void canvas_free(void * p)

  41. {

  42.     caca_free_canvas((caca_canvas_t *)p);

  43. }

  44. 

  45. static size_t canvas_size(const void *p)

  46. {

  47.     const caca_canvas_t *cv = (const caca_canvas_t *)p;

  48. 

  49.     if (cv->height * cv->width > INT_MAX / cv->framecount) {

  50.         return INT_MAX;

  51.     }

  52. 

  53.     return cv->height * cv->width * cv->framecount;

  54. }

  55. 

  56. static const rb_data_type_t canvas_dt = {

  57.     .wrap_struct_name  = "Caca::Canvas",

  58.     .function  = {

  59.         .dsize = canvas_size,

  60.         .dfree = canvas_free,

  61.     },

  62. };

  63. 

  64. static const rb_data_type_t display_autocreated_canvas_dt = {

  65.     .wrap_struct_name  = "Caca::Canvas",

  66.     .function  = {

  67.         .dsize = canvas_size,

  68.     },

  69. };

  70. 

  71. static VALUE canvas_alloc(VALUE klass)

  72. {

  73.     VALUE obj;

  74.     obj = TypedData_Wrap_Struct(klass, &canvas_dt, NULL);

  75.     return obj;

  76. }

  77. 

  78. VALUE canvas_create(caca_canvas_t *canvas)

  79. {

  80.     return TypedData_Wrap_Struct(cCanvas, &display_autocreated_canvas_dt, canvas);

  81. }

  82. 

  83. static VALUE canvas_initialize(VALUE self, VALUE width, VALUE height)

  84. {

  85.     caca_canvas_t *canvas;

  86. 

  87.     canvas = caca_create_canvas(NUM2INT(width), NUM2INT(height));

  88. 

  89.     if(canvas == NULL)

  90.     {

  91.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  92.     }

  93. 

  94.     _SELF = canvas;

  95. 

  96.     return self;

  97. }

  98. 

  99. get_int(canvas_height)

  100. get_int(canvas_width)

  101. 

  102. static VALUE set_canvas_width(VALUE self, VALUE width)

  103. {

  104.     caca_set_canvas_size(_SELF, NUM2INT(width), caca_get_canvas_height(_SELF));

  105.     return width;

  106. }

  107. 

  108. static VALUE set_canvas_width2(VALUE self, VALUE width)

  109. {

  110.     set_canvas_width(self, width);

  111.     return self;

  112. }

  113. 

  114. static VALUE set_canvas_height(VALUE self, VALUE height)

  115. {

  116.     caca_set_canvas_size(_SELF, caca_get_canvas_width(_SELF), NUM2INT(height));

  117.     return height;

  118. }

  119. 

  120. static VALUE set_canvas_height2(VALUE self, VALUE height)

  121. {

  122.     set_canvas_height(self, height);

  123.     return self;

  124. }

  125. 

  126. static VALUE set_canvas_size(VALUE self, VALUE height, VALUE width)

  127. {

  128.     caca_set_canvas_size(_SELF, NUM2INT(width), NUM2INT(height));

  129.     return self;

  130. }

  131. 

  132. /****/

  133. 

  134. static VALUE gotoxy(VALUE self, VALUE x, VALUE y)

  135. {

  136.     if( caca_gotoxy(_SELF, NUM2INT(x), NUM2INT(y)) <0) {

  137.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  138.     }

  139.     return self;

  140. }

  141. 

  142. static VALUE wherex(VALUE self)

  143. {

  144.     return INT2NUM(caca_wherex(_SELF));

  145. }

  146. 

  147. static VALUE wherey(VALUE self)

  148. {

  149.     return INT2NUM(caca_wherey(_SELF));

  150. }

  151. 

  152. simple_func(clear_canvas)

  153. 

  154. static VALUE put_char(VALUE self, VALUE x, VALUE y, VALUE ch)

  155. {

  156.     caca_put_char(_SELF, NUM2INT(x), NUM2INT(y), NUM2ULONG(ch));

  157.     return self;

  158. }

  159. 

  160. static VALUE get_char(VALUE self, VALUE x, VALUE y)

  161. {

  162.     unsigned long int ch;

  163.     ch = caca_get_char(_SELF, NUM2INT(x), NUM2INT(y));

  164.     return INT2NUM(ch);

  165. }

  166. 

  167. static VALUE put_str(VALUE self, VALUE x, VALUE y, VALUE str)

  168. {

  169.     caca_put_str(_SELF, NUM2INT(x), NUM2INT(y), StringValuePtr(str));

  170.     return self;

  171. }

  172. 

  173. static VALUE get_attr(VALUE self, VALUE x, VALUE y)

  174. {

  175.     unsigned long int ch;

  176.     ch = caca_get_attr(_SELF, NUM2INT(x), NUM2INT(y));

  177.     return INT2NUM(ch);

  178. }

  179. 

  180. static VALUE set_attr(VALUE self, VALUE attr)

  181. {

  182.     if(caca_set_attr(_SELF, NUM2ULONG(attr)) <0)

  183.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  184. 

  185.     return self;

  186. }

  187. 

  188. static VALUE set_attr2(VALUE self, VALUE attr)

  189. {

  190.     set_attr(self, attr);

  191.     return self;

  192. }

  193. 

  194. static VALUE put_attr(VALUE self, VALUE x, VALUE y, VALUE attr)

  195. {

  196.     if(caca_put_attr(_SELF, NUM2INT(x), NUM2INT(y), NUM2ULONG(attr)) <0)

  197.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  198. 

  199.     return self;

  200. }

  201. 

  202. static VALUE set_color_ansi(VALUE self, VALUE fg, VALUE bg)

  203. {

  204.     if(caca_set_color_ansi(_SELF, NUM2INT(fg), NUM2INT(bg)) <0)

  205.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  206. 

  207.     return self;

  208. }

  209. 

  210. static VALUE set_color_argb(VALUE self, VALUE fg, VALUE bg)

  211. {

  212.     if(caca_set_color_argb(_SELF, NUM2UINT(fg), NUM2UINT(bg)) <0) {

  213.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  214.     }

  215.     return self;

  216. }

  217. 

  218. static VALUE cprintf(int argc, VALUE* argv, VALUE self)

  219. {

  220.     int x, y;

  221.     VALUE rx, ry, format, rest, string;

  222.     rb_scan_args(argc, argv, "3*", &rx, &ry, &format, &rest);

  223.     x = NUM2INT(rx);

  224.     y = NUM2INT(ry);

  225.     string = rb_funcall2(rb_mKernel, rb_intern("sprintf"), argc-2, argv+2);

  226.     caca_put_str(_SELF, x, y, StringValuePtr(string));

  227.     return self;

  228. }

  229. 

  230. 

  231. get_int(canvas_handle_x)

  232. get_int(canvas_handle_y)

  233. 

  234. static VALUE set_canvas_handle(VALUE self, VALUE x, VALUE y)

  235. {

  236.     caca_set_canvas_handle(_SELF, NUM2INT(x), NUM2INT(y));

  237.     return self;

  238. }

  239. 

  240. static VALUE blit(int argc, VALUE* argv, VALUE self) {

  241.     VALUE x, y, src, mask;

  242.     caca_canvas_t *csrc, *cmask;

  243. 

  244.     rb_scan_args(argc, argv, "31", &x, &y, &src, &mask);

  245. 

  246.     Check_Type(x, T_FIXNUM);

  247.     Check_Type(y, T_FIXNUM);

  248. 

  249.     if(CLASS_OF(src) != cCanvas)

  250.     {

  251.         rb_raise(rb_eArgError, "src is not a Caca::Canvas");

  252.     }

  253.     TypedData_Get_Struct(src, caca_canvas_t, &canvas_dt, csrc);

  254. 

  255.     if(!NIL_P(mask))

  256.     {

  257.         if(CLASS_OF(mask) != cCanvas)

  258.         {

  259.             rb_raise(rb_eArgError, "mask is not a Caca::Canvas");

  260.         }

  261.         TypedData_Get_Struct(mask, caca_canvas_t, &canvas_dt, cmask);

  262.     }

  263.     else

  264.         cmask = NULL;

  265. 

  266.     if(caca_blit(_SELF, NUM2INT(x), NUM2INT(y), csrc, cmask)<0)

  267.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  268. 

  269.     return self;

  270. }

  271. 

  272. static VALUE set_canvas_boundaries(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)

  273. {

  274.     if(caca_set_canvas_boundaries(_SELF, NUM2INT(x), NUM2INT(y), NUM2UINT(w), NUM2UINT(h))<0)

  275.     {

  276.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  277.     }

  278.     return self;

  279. }

  280. 

  281. /****/

  282. 

  283. simple_func(invert)

  284. simple_func(flip)

  285. simple_func(flop)

  286. simple_func(rotate_180)

  287. simple_func(rotate_left)

  288. simple_func(rotate_right)

  289. simple_func(stretch_left)

  290. simple_func(stretch_right)

  291. 

  292. /****/

  293. 

  294. static VALUE draw_line(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE ch)

  295. {

  296.     caca_draw_line(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),NUM2ULONG(ch));

  297.     return self;

  298. }

  299. 

  300. static VALUE draw_polyline(VALUE self, VALUE points, VALUE ch)

  301. {

  302.     int i, n;

  303.     int *ax, *ay;

  304.     int error = 0;

  305.     VALUE v, x, y;

  306. 

  307.     n = RARRAY_LEN(points);

  308. 

  309.     ax = (int*)malloc(n*sizeof(int));

  310.     if(!ax)

  311.         rb_raise(rb_eNoMemError,"Out of memory");

  312. 

  313.     ay = (int*)malloc(n*sizeof(int));

  314.     if(!ay)

  315.     {

  316.         free(ax);

  317.         rb_raise(rb_eNoMemError,"Out of memory");

  318.     }

  319. 

  320.     for(i=0; i<n; i++)

  321.     {

  322.         v = rb_ary_entry(points, i);

  323.         if((TYPE(v) == T_ARRAY) && (RARRAY_LEN(v) == 2))

  324.         {

  325.             x = rb_ary_entry(v,0);

  326.             y = rb_ary_entry(v,1);

  327.             if(rb_obj_is_kind_of(x, rb_cInteger) &&

  328.                rb_obj_is_kind_of(y, rb_cInteger))

  329.             {

  330.                 ax[i] = NUM2INT(x);

  331.                 ay[i] = NUM2INT(y);

  332.             } else

  333.                 error = 1;

  334.         }

  335.         else

  336.             error = 1;

  337.     }

  338. 

  339.     if(error)

  340.     {

  341.         free(ax);

  342.         free(ay);

  343.         rb_raise(rb_eArgError, "Invalid list of points");

  344.     }

  345. 

  346.     n--;

  347. 

  348.     caca_draw_polyline(_SELF, ax, ay, n, NUM2ULONG(ch));

  349. 

  350.     free(ax);

  351.     free(ay);

  352. 

  353.     return self;

  354. }

  355. 

  356. static VALUE draw_thin_line(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)

  357. {

  358.     caca_draw_thin_line(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2));

  359.     return self;

  360. }

  361. 

  362. static VALUE draw_thin_polyline(VALUE self, VALUE points)

  363. {

  364.     int i, n;

  365.     int *ax, *ay;

  366.     int error = 0;

  367.     VALUE v, x, y;

  368. 

  369.     n = RARRAY_LEN(points);

  370. 

  371.     ax = (int*)malloc(n*sizeof(int));

  372.     if(!ax)

  373.         rb_raise(rb_eNoMemError,"Out of memory");

  374. 

  375.     ay = (int*)malloc(n*sizeof(int));

  376.     if(!ay)

  377.     {

  378.         free(ax);

  379.         rb_raise(rb_eNoMemError,"Out of memory");

  380.     }

  381. 

  382.     for(i=0; i<n; i++)

  383.     {

  384.         v = rb_ary_entry(points, i);

  385.         if((TYPE(v) == T_ARRAY) && (RARRAY_LEN(v) == 2))

  386.         {

  387.             x = rb_ary_entry(v,0);

  388.             y = rb_ary_entry(v,1);

  389.             if(rb_obj_is_kind_of(x, rb_cInteger) &&

  390.                rb_obj_is_kind_of(y, rb_cInteger))

  391.             {

  392.                 ax[i] = NUM2INT(x);

  393.                 ay[i] = NUM2INT(y);

  394.             } else

  395.                 error = 1;

  396.         }

  397.         else

  398.             error = 1;

  399.     }

  400. 

  401.     if(error)

  402.     {

  403.         free(ax);

  404.         free(ay);

  405.         rb_raise(rb_eArgError, "Invalid list of points");

  406.     }

  407. 

  408.     n--;

  409. 

  410.     caca_draw_thin_polyline(_SELF, ax, ay, n);

  411. 

  412.     free(ax);

  413.     free(ay);

  414. 

  415.     return self;

  416. }

  417. 

  418. static VALUE draw_circle(VALUE self, VALUE x, VALUE y, VALUE r, VALUE ch)

  419. {

  420.     caca_draw_circle(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(r), NUM2ULONG(ch));

  421.     return self;

  422. }

  423. 

  424. static VALUE draw_ellipse(VALUE self, VALUE x, VALUE y, VALUE a, VALUE b, VALUE ch)

  425. {

  426.     caca_draw_ellipse(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(a), NUM2INT(b), NUM2ULONG(ch));

  427.     return self;

  428. }

  429. 

  430. static VALUE draw_thin_ellipse(VALUE self, VALUE x, VALUE y, VALUE a, VALUE b)

  431. {

  432.     caca_draw_thin_ellipse(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(a), NUM2INT(b));

  433.     return self;

  434. }

  435. 

  436. static VALUE fill_ellipse(VALUE self, VALUE x, VALUE y, VALUE a, VALUE b, VALUE ch)

  437. {

  438.     caca_fill_ellipse(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(a), NUM2INT(b), NUM2ULONG(ch));

  439.     return self;

  440. }

  441. 

  442. static VALUE draw_box(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h, VALUE ch)

  443. {

  444.     caca_draw_box(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h), NUM2ULONG(ch));

  445.     return self;

  446. }

  447. 

  448. static VALUE draw_thin_box(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)

  449. {

  450.     caca_draw_thin_box(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h));

  451.     return self;

  452. }

  453. 

  454. static VALUE draw_cp437_box(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)

  455. {

  456.     caca_draw_cp437_box(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h));

  457.     return self;

  458. }

  459. 

  460. static VALUE fill_box(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h, VALUE ch)

  461. {

  462.     caca_fill_box(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h), NUM2ULONG(ch));

  463.     return self;

  464. }

  465. 

  466. static VALUE draw_triangle(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE x3, VALUE y3, VALUE ch)

  467. {

  468.     caca_draw_triangle(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),  NUM2INT(x3), NUM2INT(y3), NUM2ULONG(ch));

  469.     return self;

  470. }

  471. 

  472. static VALUE draw_thin_triangle(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE x3, VALUE y3)

  473. {

  474.     caca_draw_thin_triangle(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),  NUM2INT(x3), NUM2INT(y3));

  475.     return self;

  476. }

  477. 

  478. static VALUE fill_triangle(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE x3, VALUE y3, VALUE ch)

  479. {

  480.     caca_fill_triangle(_SELF, NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2),  NUM2INT(x3), NUM2INT(y3), NUM2ULONG(ch));

  481.     return self;

  482. }

  483. 

  484. static VALUE fill_triangle_textured(VALUE self, VALUE coords, VALUE texture, VALUE uv)

  485. {

  486.     caca_canvas_t *ctexture;

  487.     int i, l;

  488.     int ccoords[6];

  489.     float cuv[6];

  490.     VALUE v;

  491. 

  492.     l = RARRAY_LEN(coords);

  493.     if(l != 6 && l != 3)

  494.     {

  495.         rb_raise(rb_eArgError, "invalid coords list");

  496.     }

  497.     for(i=0; i<l; i++)

  498.     {

  499.         v = rb_ary_entry(coords, i);

  500.         if(l==6)

  501.             ccoords[i] = NUM2INT(v);

  502.         else

  503.         {

  504.             if((TYPE(v) != T_ARRAY) || (RARRAY_LEN(v) != 2))

  505.                 rb_raise(rb_eArgError, "invalid coords list");

  506.             ccoords[2*i] = NUM2INT(rb_ary_entry(v, 0));

  507.             ccoords[2*i+1] = NUM2INT(rb_ary_entry(v, 1));

  508.         }

  509.     }

  510. 

  511.     l = RARRAY_LEN(uv);

  512.     if(l != 6 && l != 3)

  513.     {

  514.         rb_raise(rb_eArgError, "invalid uv list");

  515.     }

  516.     for(i=0; i<l; i++)

  517.     {

  518.         v = rb_ary_entry(uv, i);

  519.         if(l==6)

  520.             cuv[i] = NUM2DBL(v);

  521.         else

  522.         {

  523.             if((TYPE(v) != T_ARRAY) || (RARRAY_LEN(v) != 2))

  524.                 rb_raise(rb_eArgError, "invalid uv list");

  525.             cuv[2*i] = NUM2DBL(rb_ary_entry(v, 0));

  526.             cuv[2*i+1] = NUM2DBL(rb_ary_entry(v, 1));

  527.         }

  528.     }

  529. 

  530.     if(CLASS_OF(texture) != cCanvas)

  531.     {

  532.         rb_raise(rb_eArgError, "texture is not a Caca::Canvas");

  533.     }

  534.     TypedData_Get_Struct(texture, caca_canvas_t, &canvas_dt, ctexture);

  535. 

  536.     caca_fill_triangle_textured(_SELF, ccoords, ctexture, cuv);

  537.     return self;

  538. }

  539. 

  540. static VALUE dither_bitmap(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h, VALUE d, VALUE pixels)

  541. {

  542.     if(CLASS_OF(d) != cDither)

  543.         rb_raise(rb_eArgError, "d is not a Caca::Dither");

  544.     Check_Type(pixels, T_STRING);

  545. 

  546.     caca_dither_bitmap(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h), DATA_PTR(d), StringValuePtr(pixels));

  547.     return self;

  548. }

  549. 

  550. /****/

  551. 

  552. get_int(frame_count)

  553. 

  554. static VALUE set_frame(VALUE self, VALUE id)

  555. {

  556.     if(caca_set_frame(_SELF, NUM2INT(id))<0)

  557.         rb_raise(rb_eArgError, "%s", strerror(errno));

  558. 

  559.     return self;

  560. }

  561. 

  562. static VALUE set_frame2(VALUE self, VALUE id)

  563. {

  564.     set_frame(self, id);

  565.     return self;

  566. }

  567. 

  568. static VALUE get_frame_name(VALUE self)

  569. {

  570.     return rb_str_new2(caca_get_frame_name(_SELF));

  571. }

  572. 

  573. static VALUE set_frame_name(VALUE self, VALUE name)

  574. {

  575.     if(caca_set_frame_name(_SELF, StringValuePtr(name))<0)

  576.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  577. 

  578.     return self;

  579. }

  580. 

  581. static VALUE set_frame_name2(VALUE self, VALUE name)

  582. {

  583.     set_frame_name(self, name);

  584.     return self;

  585. }

  586. 

  587. static VALUE create_frame(VALUE self, VALUE id)

  588. {

  589.     if(caca_create_frame(_SELF, NUM2INT(id))<0) {

  590.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  591.     }

  592.     return self;

  593. }

  594. 

  595. static VALUE free_frame(VALUE self, VALUE id)

  596. {

  597.     if(caca_free_frame(_SELF, NUM2INT(id))<0) {

  598.         rb_raise(rb_eArgError, "%s", strerror(errno));

  599.     }

  600.     return self;

  601. }

  602. 

  603. /****/

  604. 

  605. static VALUE render_canvas(VALUE self, VALUE font, VALUE width, VALUE height, VALUE pitch)

  606. {

  607.     void *buf;

  608.     caca_font_t *f;

  609.     VALUE b;

  610. 

  611.     if(CLASS_OF(font) != cFont)

  612.     {

  613.         rb_raise(rb_eArgError, "First argument is not a Caca::Font");

  614.     }

  615. 

  616.     if (width == 0 || height == 0 || SIZE_MAX / width / height < 4)

  617.     {

  618.         rb_raise(rb_eRangeError, "width * height is too large");

  619.     }

  620. 

  621.     buf = malloc(width * height * 4);

  622.     if(buf == NULL)

  623.     {

  624.         rb_raise(rb_eNoMemError, "Out of memory");

  625.     }

  626. 

  627.     f = DATA_PTR(font);

  628.     caca_render_canvas(_SELF, f, buf, NUM2UINT(width), NUM2UINT(height), NUM2UINT(pitch));

  629. 

  630.     b = rb_str_new(buf, width*height*4);

  631.     free(buf);

  632.     return b;

  633. }

  634. 

  635. static VALUE import_from_memory(VALUE self, VALUE data, VALUE format)

  636. {

  637.     long int bytes;

  638.     bytes = caca_import_canvas_from_memory (_SELF, StringValuePtr(data), RSTRING_LEN(StringValue(data)), StringValuePtr(format));

  639.     if(bytes <= 0)

  640.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  641. 

  642.     return self;

  643. }

  644. 

  645. static VALUE import_area_from_memory(VALUE self, VALUE x, VALUE y, VALUE data, VALUE format)

  646. {

  647.     long int bytes;

  648.     bytes = caca_import_area_from_memory (_SELF, NUM2INT(x), NUM2INT(y), StringValuePtr(data), RSTRING_LEN(StringValue(data)), StringValuePtr(format));

  649.     if(bytes <= 0)

  650.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  651. 

  652.     return self;

  653. }

  654. 

  655. static VALUE import_from_file(VALUE self, VALUE filename, VALUE format)

  656. {

  657.     long int bytes;

  658.     bytes = caca_import_canvas_from_file (_SELF, StringValuePtr(filename), StringValuePtr(format));

  659.     if(bytes <= 0)

  660.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  661. 

  662.     return self;

  663. }

  664. 

  665. static VALUE import_area_from_file(VALUE self, VALUE x, VALUE y, VALUE filename, VALUE format)

  666. {

  667.     long int bytes;

  668.     bytes = caca_import_area_from_file (_SELF, NUM2INT(x), NUM2INT(y), StringValuePtr(filename), StringValuePtr(format));

  669.     if(bytes <= 0)

  670.         rb_raise(rb_eRuntimeError, "%s", strerror(errno));

  671. 

  672.     return self;

  673. }

  674. 

  675. static VALUE export_area_to_memory(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h, VALUE format)

  676. {

  677.     size_t bytes;

  678.     void *result;

  679.     VALUE ret;

  680.     result = caca_export_area_to_memory (_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h), StringValuePtr(format), &bytes);

  681.     ret = rb_str_new(result, bytes);

  682.     free(result);

  683.     return ret;

  684. }

  685. 

  686. static VALUE export_to_memory(VALUE self, VALUE format)

  687. {

  688.     size_t bytes;

  689.     void *result;

  690.     VALUE ret;

  691.     result = caca_export_canvas_to_memory (_SELF, StringValuePtr(format), &bytes);

  692.     ret = rb_str_new(result, bytes);

  693.     free(result);

  694.     return ret;

  695. }

  696. 

  697. get_singleton_double_list(export)

  698. get_singleton_double_list(import)

  699. 

  700. /****/

  701. 

  702. simple_func(disable_dirty_rect)

  703. simple_func(enable_dirty_rect)

  704. get_int(dirty_rect_count)

  705. 

  706. static VALUE dirty_rect(VALUE self, VALUE n)

  707. {

  708.     int x, y, width, height;

  709.     VALUE ary;

  710.     ary = rb_ary_new();

  711.     caca_get_dirty_rect(_SELF, NUM2INT(n), &x, &y, &width, &height);

  712.     rb_ary_push(ary, INT2NUM(x));

  713.     rb_ary_push(ary, INT2NUM(y));

  714.     rb_ary_push(ary, INT2NUM(width));

  715.     rb_ary_push(ary, INT2NUM(height));

  716.     return ary;

  717. }

  718. 

  719. static VALUE dirty_rects(VALUE self)

  720. {

  721.     int n = caca_get_dirty_rect_count(_SELF), i;

  722.     VALUE ary;

  723.     ary = rb_ary_new();

  724.     for(i=0; i<n; i++)

  725.     {

  726.         rb_ary_push(ary, dirty_rect(self, INT2NUM(i)));

  727.     }

  728.     return ary;

  729. }

  730. 

  731. /*FIXME Handle an array for the rect */

  732. static VALUE add_dirty_rect(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)

  733. {

  734.     caca_add_dirty_rect(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h));

  735.     return self;

  736. }

  737. 

  738. static VALUE remove_dirty_rect(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)

  739. {

  740.     caca_remove_dirty_rect(_SELF, NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h));

  741.     return self;

  742. }

  743. 

  744. simple_func(clear_dirty_rect_list)

  745. 

  746. /****/

  747. 

  748. void Init_caca_canvas(VALUE mCaca)

  749. {

  750.     cCanvas = rb_define_class_under(mCaca, "Canvas", rb_cObject);

  751.     rb_define_alloc_func(cCanvas, canvas_alloc);

  752. 

  753.     rb_define_method(cCanvas, "initialize", canvas_initialize, 2);

  754.     rb_define_method(cCanvas, "width", get_canvas_width, 0);

  755.     rb_define_method(cCanvas, "width=", set_canvas_width, 1);

  756.     rb_define_method(cCanvas, "set_width", set_canvas_width2, 1);

  757.     rb_define_method(cCanvas, "height", get_canvas_height, 0);

  758.     rb_define_method(cCanvas, "height=", set_canvas_height, 1);

  759.     rb_define_method(cCanvas, "set_height", set_canvas_height2, 1);

  760.     rb_define_method(cCanvas, "set_size", set_canvas_size, 2);

  761. 

  762.     rb_define_method(cCanvas, "gotoxy", gotoxy, 2);

  763.     rb_define_method(cCanvas, "wherex", wherex, 0);

  764.     rb_define_method(cCanvas, "wherey", wherey, 0);

  765.     rb_define_method(cCanvas, "handle_x", get_canvas_handle_x, 0);

  766.     rb_define_method(cCanvas, "handle_y", get_canvas_handle_y, 0);

  767.     rb_define_method(cCanvas, "set_handle", set_canvas_handle, 2);

  768.     rb_define_method(cCanvas, "blit", blit, -1);

  769.     rb_define_method(cCanvas, "set_boundaries", set_canvas_boundaries, 4);

  770. 

  771.     rb_define_method(cCanvas, "clear", clear_canvas, 0);

  772. 

  773.     rb_define_method(cCanvas, "put_char", put_char, 3);

  774.     rb_define_method(cCanvas, "get_char", get_char, 2);

  775.     rb_define_method(cCanvas, "put_str", put_str, 3);

  776.     rb_define_method(cCanvas, "printf", cprintf, -1);

  777. 

  778.     rb_define_method(cCanvas, "get_attr", get_attr, 2);

  779.     rb_define_method(cCanvas, "attr=", set_attr, 1);

  780.     rb_define_method(cCanvas, "set_attr", set_attr2, 1);

  781.     rb_define_method(cCanvas, "put_attr", put_attr, 3);

  782.     rb_define_method(cCanvas, "set_color_ansi", set_color_ansi, 2);

  783.     rb_define_method(cCanvas, "set_color_argb", set_color_argb, 2);

  784. 

  785.     rb_define_method(cCanvas, "invert", invert, 0);

  786.     rb_define_method(cCanvas, "flip", flip, 0);

  787.     rb_define_method(cCanvas, "flop", flop, 0);

  788.     rb_define_method(cCanvas, "rotate_180", rotate_180, 0);

  789.     rb_define_method(cCanvas, "rotate_left", rotate_left, 0);

  790.     rb_define_method(cCanvas, "rotate_right", rotate_right, 0);

  791.     rb_define_method(cCanvas, "stretch_left", stretch_left, 0);

  792.     rb_define_method(cCanvas, "stretch_right", stretch_right, 0);

  793. 

  794.     rb_define_method(cCanvas, "draw_line", draw_line, 5);

  795.     rb_define_method(cCanvas, "draw_polyline", draw_polyline, 2);

  796.     rb_define_method(cCanvas, "draw_thin_line", draw_thin_line, 4);

  797.     rb_define_method(cCanvas, "draw_thin_polyline", draw_thin_polyline, 1);

  798.     rb_define_method(cCanvas, "draw_circle", draw_circle, 4);

  799.     rb_define_method(cCanvas, "draw_ellipse", draw_ellipse, 5);

  800.     rb_define_method(cCanvas, "draw_thin_ellipse", draw_thin_ellipse, 4);

  801.     rb_define_method(cCanvas, "fill_ellipse", fill_ellipse, 5);

  802.     rb_define_method(cCanvas, "draw_box", draw_box, 5);

  803.     rb_define_method(cCanvas, "draw_thin_box", draw_thin_box, 4);

  804.     rb_define_method(cCanvas, "draw_cp437_box", draw_cp437_box, 4);

  805.     rb_define_method(cCanvas, "fill_box", fill_box, 5);

  806.     rb_define_method(cCanvas, "draw_triangle", draw_triangle, 7);

  807.     rb_define_method(cCanvas, "draw_thin_triangle", draw_thin_triangle, 6);

  808.     rb_define_method(cCanvas, "fill_triangle", fill_triangle, 7);

  809.     rb_define_method(cCanvas, "fill_triangle_textured", fill_triangle_textured, 3);

  810.     rb_define_method(cCanvas, "dither_bitmap", dither_bitmap, 6);

  811. 

  812.     rb_define_method(cCanvas, "frame_count", get_frame_count, 0);

  813.     rb_define_method(cCanvas, "frame=", set_frame, 1);

  814.     rb_define_method(cCanvas, "set_frame", set_frame2, 1);

  815.     rb_define_method(cCanvas, "frame_name", get_frame_name, 0);

  816.     rb_define_method(cCanvas, "frame_name=", set_frame_name, 1);

  817.     rb_define_method(cCanvas, "set_frame_name", set_frame_name2, 1);

  818.     rb_define_method(cCanvas, "create_frame", create_frame, 1);

  819.     rb_define_method(cCanvas, "free_frame", free_frame, 1);

  820. 

  821.     rb_define_method(cCanvas, "render", render_canvas, 4);

  822.     rb_define_method(cCanvas, "import_from_memory", import_from_memory, 2);

  823.     rb_define_method(cCanvas, "import_area_from_memory", import_area_from_memory, 4);

  824.     rb_define_method(cCanvas, "import_from_file", import_from_file, 2);

  825.     rb_define_method(cCanvas, "import_area_from_file", import_area_from_file, 4);

  826.     rb_define_method(cCanvas, "export_to_memory", export_to_memory, 1);

  827.     rb_define_method(cCanvas, "export_area_to_memory", export_area_to_memory, 5);

  828.     rb_define_singleton_method(cCanvas, "export_list", (VALUE (*)(VALUE)) export_list, 0);

  829.     rb_define_singleton_method(cCanvas, "import_list", (VALUE (*)(VALUE)) import_list, 0);

  830. 

  831.     rb_define_method(cCanvas, "disable_dirty_rect", disable_dirty_rect, 0);

  832.     rb_define_method(cCanvas, "enable_dirty_rect", enable_dirty_rect, 0);

  833.     rb_define_method(cCanvas, "dirty_rect_count", get_dirty_rect_count, 0);

  834.     rb_define_method(cCanvas, "dirty_rect", dirty_rect, 1);

  835.     rb_define_method(cCanvas, "dirty_rects", dirty_rects, 0);

  836.     rb_define_method(cCanvas, "add_dirty_rect", add_dirty_rect, 4);

  837.     rb_define_method(cCanvas, "remove_dirty_rect", remove_dirty_rect, 4);

  838.     rb_define_method(cCanvas, "clear_dirty_rect_list", clear_dirty_rect_list, 0);

  839. 

  840. }