cacalabs
/
libcaca
peilaus alkaen https://github.com/cacalabs/libcaca.git
1
0
Fork 0
Koodi Ongelmat 0 Julkaisut 7 Wiki Toiminta
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2013 Commitit
1 Haara
200 MiB
 
 
 
 
 
 
Puu: 1a818d4c2d
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from '1a818d4c2d'
${ noResults }
libcaca/ruby/caca-canvas.c

810 rivejä
22 KiB
Raaka Blame Historia 

  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. 

  22. VALUE cCanvas;

  23. 

  24. #define simple_func(x)                                  \

  25. static VALUE x (VALUE self)                             \

  26. {                                                       \

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

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

  29.                                                         \

  30.     return self;                                        \

  31. }

  32. 

  33. #define get_int(x)                                      \

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

  35. {                                                       \

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

  37. }

  38. 

  39. static void canvas_free(void * p)

  40. {

  41.     caca_free_canvas((caca_canvas_t *)p);

  42. }

  43. 

  44. static VALUE canvas_alloc(VALUE klass)

  45. {

  46.     VALUE obj;

  47.     obj = Data_Wrap_Struct(klass, NULL, canvas_free, NULL);

  48.     return obj;

  49. }

  50. 

  51. VALUE canvas_create(caca_canvas_t *canvas)

  52. {

  53.     return Data_Wrap_Struct(cCanvas, NULL, NULL, canvas);

  54. }

  55. 

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

  57. {

  58.     caca_canvas_t *canvas;

  59. 

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

  61. 

  62.     if(canvas == NULL)

  63.     {

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

  65.     }

  66. 

  67.     _SELF = canvas;

  68. 

  69.     return self;

  70. }

  71. 

  72. get_int(canvas_height)

  73. get_int(canvas_width)

  74. 

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

  76. {

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

  78.     return width;

  79. }

  80. 

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

  82. {

  83.     set_canvas_width(self, width);

  84.     return self;

  85. }

  86. 

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

  88. {

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

  90.     return height;

  91. }

  92. 

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

  94. {

  95.     set_canvas_height(self, height);

  96.     return self;

  97. }

  98. 

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

  100. {

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

  102.     return self;

  103. }

  104. 

  105. /****/

  106. 

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

  108. {

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

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

  111.     }

  112.     return self;

  113. }

  114. 

  115. static VALUE wherex(VALUE self)

  116. {

  117.     return INT2NUM(caca_wherex(_SELF));

  118. }

  119. 

  120. static VALUE wherey(VALUE self)

  121. {

  122.     return INT2NUM(caca_wherey(_SELF));

  123. }

  124. 

  125. simple_func(clear_canvas)

  126. 

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

  128. {

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

  130.     return self;

  131. }

  132. 

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

  134. {

  135.     unsigned long int ch;

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

  137.     return INT2NUM(ch);

  138. }

  139. 

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

  141. {

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

  143.     return self;

  144. }

  145. 

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

  147. {

  148.     unsigned long int ch;

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

  150.     return INT2NUM(ch);

  151. }

  152. 

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

  154. {

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

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

  157. 

  158.     return self;

  159. }

  160. 

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

  162. {

  163.     set_attr(self, attr);

  164.     return self;

  165. }

  166. 

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

  168. {

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

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

  171. 

  172.     return self;

  173. }

  174. 

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

  176. {

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

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

  179. 

  180.     return self;

  181. }

  182. 

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

  184. {

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

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

  187.     }

  188.     return self;

  189. }

  190. 

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

  192. {

  193.     int x, y;

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

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

  196.     x = NUM2INT(rx);

  197.     y = NUM2INT(ry);

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

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

  200.     return self;

  201. }

  202. 

  203. 

  204. get_int(canvas_handle_x)

  205. get_int(canvas_handle_y)

  206. 

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

  208. {

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

  210.     return self;

  211. }

  212. 

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

  214.     VALUE x, y, src, mask;

  215.     caca_canvas_t *csrc, *cmask;

  216. 

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

  218. 

  219.     Check_Type(x, T_FIXNUM);

  220.     Check_Type(y, T_FIXNUM);

  221. 

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

  223.     {

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

  225.     }

  226.     Data_Get_Struct(src, caca_canvas_t, csrc);

  227. 

  228.     if(!NIL_P(mask))

  229.     {

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

  231.         {

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

  233.         }

  234.         Data_Get_Struct(mask, caca_canvas_t, cmask);

  235.     }

  236.     else

  237.         cmask = NULL;

  238. 

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

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

  241. 

  242.     return self;

  243. }

  244. 

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

  246. {

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

  248.     {

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

  250.     }

  251.     return self;

  252. }

  253. 

  254. /****/

  255. 

  256. simple_func(invert)

  257. simple_func(flip)

  258. simple_func(flop)

  259. simple_func(rotate_180)

  260. simple_func(rotate_left)

  261. simple_func(rotate_right)

  262. simple_func(stretch_left)

  263. simple_func(stretch_right)

  264. 

  265. /****/

  266. 

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

  268. {

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

  270.     return self;

  271. }

  272. 

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

  274. {

  275.     int i, n;

  276.     int *ax, *ay;

  277.     int error = 0;

  278.     VALUE v, x, y;

  279. 

  280.     n = RARRAY_LEN(points);

  281. 

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

  283.     if(!ax)

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

  285. 

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

  287.     if(!ay)

  288.     {

  289.         free(ax);

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

  291.     }

  292. 

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

  294.     {

  295.         v = rb_ary_entry(points, i);

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

  297.         {

  298.             x = rb_ary_entry(v,0);

  299.             y = rb_ary_entry(v,1);

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

  301.                rb_obj_is_kind_of(y, rb_cInteger))

  302.             {

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

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

  305.             } else

  306.                 error = 1;

  307.         }

  308.         else

  309.             error = 1;

  310.     }

  311. 

  312.     if(error)

  313.     {

  314.         free(ax);

  315.         free(ay);

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

  317.     }

  318. 

  319.     n--;

  320. 

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

  322. 

  323.     free(ax);

  324.     free(ay);

  325. 

  326.     return self;

  327. }

  328. 

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

  330. {

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

  332.     return self;

  333. }

  334. 

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

  336. {

  337.     int i, n;

  338.     int *ax, *ay;

  339.     int error = 0;

  340.     VALUE v, x, y;

  341. 

  342.     n = RARRAY_LEN(points);

  343. 

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

  345.     if(!ax)

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

  347. 

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

  349.     if(!ay)

  350.     {

  351.         free(ax);

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

  353.     }

  354. 

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

  356.     {

  357.         v = rb_ary_entry(points, i);

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

  359.         {

  360.             x = rb_ary_entry(v,0);

  361.             y = rb_ary_entry(v,1);

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

  363.                rb_obj_is_kind_of(y, rb_cInteger))

  364.             {

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

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

  367.             } else

  368.                 error = 1;

  369.         }

  370.         else

  371.             error = 1;

  372.     }

  373. 

  374.     if(error)

  375.     {

  376.         free(ax);

  377.         free(ay);

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

  379.     }

  380. 

  381.     n--;

  382. 

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

  384. 

  385.     free(ax);

  386.     free(ay);

  387. 

  388.     return self;

  389. }

  390. 

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

  392. {

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

  394.     return self;

  395. }

  396. 

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

  398. {

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

  400.     return self;

  401. }

  402. 

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

  404. {

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

  406.     return self;

  407. }

  408. 

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

  410. {

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

  412.     return self;

  413. }

  414. 

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

  416. {

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

  418.     return self;

  419. }

  420. 

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

  422. {

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

  424.     return self;

  425. }

  426. 

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

  428. {

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

  430.     return self;

  431. }

  432. 

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

  434. {

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

  436.     return self;

  437. }

  438. 

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

  440. {

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

  442.     return self;

  443. }

  444. 

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

  446. {

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

  448.     return self;

  449. }

  450. 

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

  452. {

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

  454.     return self;

  455. }

  456. 

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

  458. {

  459.     caca_canvas_t *ctexture;

  460.     int i, l;

  461.     int ccoords[6];

  462.     float cuv[6];

  463.     VALUE v;

  464. 

  465.     l = RARRAY_LEN(coords);

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

  467.     {

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

  469.     }

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

  471.     {

  472.         v = rb_ary_entry(coords, i);

  473.         if(l==6)

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

  475.         else

  476.         {

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

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

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

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

  481.         }

  482.     }

  483. 

  484.     l = RARRAY_LEN(uv);

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

  486.     {

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

  488.     }

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

  490.     {

  491.         v = rb_ary_entry(uv, i);

  492.         if(l==6)

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

  494.         else

  495.         {

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

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

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

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

  500.         }

  501.     }

  502. 

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

  504.     {

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

  506.     }

  507.     Data_Get_Struct(texture, caca_canvas_t, ctexture);

  508. 

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

  510.     return self;

  511. }

  512. 

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

  514. {

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

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

  517.     Check_Type(pixels, T_STRING);

  518. 

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

  520.     return self;

  521. }

  522. 

  523. /****/

  524. 

  525. get_int(frame_count)

  526. 

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

  528. {

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

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

  531. 

  532.     return self;

  533. }

  534. 

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

  536. {

  537.     set_frame(self, id);

  538.     return self;

  539. }

  540. 

  541. static VALUE get_frame_name(VALUE self)

  542. {

  543.     return rb_str_new2(caca_get_frame_name(_SELF));

  544. }

  545. 

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

  547. {

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

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

  550. 

  551.     return self;

  552. }

  553. 

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

  555. {

  556.     set_frame_name(self, name);

  557.     return self;

  558. }

  559. 

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

  561. {

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

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

  564.     }

  565.     return self;

  566. }

  567. 

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

  569. {

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

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

  572.     }

  573.     return self;

  574. }

  575. 

  576. /****/

  577. 

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

  579. {

  580.     void *buf;

  581.     caca_font_t *f;

  582.     VALUE b;

  583. 

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

  585.     {

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

  587.     }

  588. 

  589.     buf = _caca_alloc2d(width, height, 4);

  590.     if(buf == NULL)

  591.     {

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

  593.     }

  594. 

  595.     f = DATA_PTR(font);

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

  597. 

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

  599.     free(buf);

  600.     return b;

  601. }

  602. 

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

  604. {

  605.     long int bytes;

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

  607.     if(bytes <= 0)

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

  609. 

  610.     return self;

  611. }

  612. 

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

  614. {

  615.     long int bytes;

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

  617.     if(bytes <= 0)

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

  619. 

  620.     return self;

  621. }

  622. 

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

  624. {

  625.     long int bytes;

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

  627.     if(bytes <= 0)

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

  629. 

  630.     return self;

  631. }

  632. 

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

  634. {

  635.     long int bytes;

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

  637.     if(bytes <= 0)

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

  639. 

  640.     return self;

  641. }

  642. 

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

  644. {

  645.     size_t bytes;

  646.     void *result;

  647.     VALUE ret;

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

  649.     ret = rb_str_new(result, bytes);

  650.     free(result);

  651.     return ret;

  652. }

  653. 

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

  655. {

  656.     size_t bytes;

  657.     void *result;

  658.     VALUE ret;

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

  660.     ret = rb_str_new(result, bytes);

  661.     free(result);

  662.     return ret;

  663. }

  664. 

  665. get_singleton_double_list(export)

  666. get_singleton_double_list(import)

  667. 

  668. /****/

  669. 

  670. simple_func(disable_dirty_rect)

  671. simple_func(enable_dirty_rect)

  672. get_int(dirty_rect_count)

  673. 

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

  675. {

  676.     int x, y, width, height;

  677.     VALUE ary;

  678.     ary = rb_ary_new();

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

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

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

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

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

  684.     return ary;

  685. }

  686. 

  687. static VALUE dirty_rects(VALUE self)

  688. {

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

  690.     VALUE ary;

  691.     ary = rb_ary_new();

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

  693.     {

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

  695.     }

  696.     return ary;

  697. }

  698. 

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

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

  701. {

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

  703.     return self;

  704. }

  705. 

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

  707. {

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

  709.     return self;

  710. }

  711. 

  712. simple_func(clear_dirty_rect_list)

  713. 

  714. /****/

  715. 

  716. void Init_caca_canvas(VALUE mCaca)

  717. {

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

  719.     rb_define_alloc_func(cCanvas, canvas_alloc);

  720. 

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

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

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

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

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

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

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

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

  729. 

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

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

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

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

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

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

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

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

  738. 

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

  740. 

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

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

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

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

  745. 

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

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

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

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

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

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

  752. 

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

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

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

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

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

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

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

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

  761. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  779. 

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

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

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

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

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

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

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

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

  788. 

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

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

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

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

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

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

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

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

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

  798. 

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

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

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

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

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

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

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

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

  807. 

  808. }