source: libcaca/trunk/caca-php/php_caca.c @ 3153

Last change on this file since 3153 was 3153, checked in by nico, 11 years ago
  • Available the compilation of caca-php without gd development files
File size: 58.0 KB
Line 
1/*
2 *  php-caca      Php binding for Libcaca
3 *  Copyright (c) 2008 Vion Nicolas <nico@picapo.net>
4 *
5 *
6 *  This library is free software. It comes without any warranty, to
7 *  the extent permitted by applicable law. You can redistribute it
8 *  and/or modify it under the terms of the Do What The Fuck You Want
9 *  To Public License, Version 2, as published by Sam Hocevar. See
10 *  http://sam.zoy.org/wtfpl/COPYING for more details.
11 */
12
13#ifdef HAVE_CONFIG_H
14#include "config.h"
15#endif
16
17#include "php.h"
18#include "php_caca.h"
19
20#ifdef HAVE_GD
21#include <gd.h>
22#endif
23
24static function_entry caca_functions[] = {
25        PHP_FE(caca_create_canvas, NULL)
26        PHP_FE(caca_set_canvas_size, NULL)
27        PHP_FE(caca_get_canvas_width, NULL)
28        PHP_FE(caca_get_canvas_height, NULL)
29        PHP_FE(caca_get_canvas_chars, NULL)
30        PHP_FE(caca_get_canvas_attrs, NULL)
31        PHP_FE(caca_rand, NULL)
32        PHP_FE(caca_get_version, NULL)
33        PHP_FE(caca_gotoxy, NULL)
34        PHP_FE(caca_get_cursor_x, NULL)
35        PHP_FE(caca_get_cursor_y, NULL)
36        PHP_FE(caca_put_char, NULL)
37        PHP_FE(caca_get_char, NULL)
38        PHP_FE(caca_put_str, NULL)
39        PHP_FE(caca_clear_canvas, NULL)
40        PHP_FE(caca_set_canvas_handle, NULL)
41        PHP_FE(caca_get_canvas_handle_x, NULL)
42        PHP_FE(caca_get_canvas_handle_y, NULL)
43        PHP_FE(caca_blit, NULL)
44        PHP_FE(caca_set_canvas_boundaries, NULL)
45        PHP_FE(caca_invert, NULL)
46        PHP_FE(caca_flip, NULL)
47        PHP_FE(caca_flop, NULL)
48        PHP_FE(caca_rotate_180, NULL)
49        PHP_FE(caca_rotate_left, NULL)
50        PHP_FE(caca_rotate_right, NULL)
51        PHP_FE(caca_stretch_left, NULL)
52        PHP_FE(caca_stretch_right, NULL)
53        PHP_FE(caca_get_attr, NULL)
54        PHP_FE(caca_set_attr, NULL)
55        PHP_FE(caca_put_attr, NULL)
56        PHP_FE(caca_set_color_ansi, NULL)
57        PHP_FE(caca_set_color_argb, NULL)
58        PHP_FE(caca_attr_to_ansi, NULL)
59        PHP_FE(caca_attr_to_ansi_fg, NULL)
60        PHP_FE(caca_attr_to_ansi_bg, NULL)
61        PHP_FE(caca_attr_to_rgb12_fg, NULL)
62        PHP_FE(caca_attr_to_rgb12_bg, NULL)
63        PHP_FE(caca_attr_to_argb64, NULL)
64        PHP_FE(caca_utf8_to_utf32, NULL)
65        PHP_FE(caca_utf32_to_utf8, NULL)
66        PHP_FE(caca_utf32_to_cp437, NULL)
67        PHP_FE(caca_cp437_to_utf32, NULL)
68        PHP_FE(caca_utf32_to_ascii, NULL)
69        PHP_FE(caca_utf32_is_fullwidth, NULL)
70        PHP_FE(caca_draw_line, NULL)
71        PHP_FE(caca_draw_polyline, NULL)
72        PHP_FE(caca_draw_thin_line, NULL)
73        PHP_FE(caca_draw_thin_polyline, NULL)
74        PHP_FE(caca_draw_circle, NULL)
75        PHP_FE(caca_draw_ellipse, NULL)
76        PHP_FE(caca_draw_thin_ellipse, NULL)
77        PHP_FE(caca_fill_ellipse, NULL)
78        PHP_FE(caca_draw_box, NULL)
79        PHP_FE(caca_draw_thin_box, NULL)
80        PHP_FE(caca_draw_cp437_box, NULL)
81        PHP_FE(caca_fill_box, NULL)
82        PHP_FE(caca_draw_triangle, NULL)
83        PHP_FE(caca_draw_thin_triangle, NULL)
84        PHP_FE(caca_fill_triangle, NULL)
85        PHP_FE(caca_get_frame_count, NULL)
86        PHP_FE(caca_set_frame, NULL)
87        PHP_FE(caca_set_frame_name, NULL)
88        PHP_FE(caca_create_frame, NULL)
89        PHP_FE(caca_free_frame, NULL)
90        PHP_FE(caca_create_dither, NULL)
91        PHP_FE(caca_set_dither_palette, NULL)
92        PHP_FE(caca_set_dither_brightness, NULL)
93        PHP_FE(caca_get_dither_brightness, NULL)
94        PHP_FE(caca_set_dither_gamma, NULL)
95        PHP_FE(caca_get_dither_gamma, NULL)
96        PHP_FE(caca_set_dither_contrast, NULL)
97        PHP_FE(caca_get_dither_contrast, NULL)
98        PHP_FE(caca_set_dither_antialias, NULL)
99        PHP_FE(caca_get_dither_antialias_list, NULL)
100        PHP_FE(caca_get_dither_antialias, NULL)
101        PHP_FE(caca_set_dither_color, NULL)
102        PHP_FE(caca_get_dither_color_list, NULL)
103        PHP_FE(caca_get_dither_color, NULL)
104        PHP_FE(caca_set_dither_charset, NULL)
105        PHP_FE(caca_get_dither_charset_list, NULL)
106        PHP_FE(caca_get_dither_charset, NULL)
107        PHP_FE(caca_set_dither_algorithm, NULL)
108        PHP_FE(caca_get_dither_algorithm_list, NULL)
109        PHP_FE(caca_get_dither_algorithm, NULL)
110        PHP_FE(caca_dither_bitmap, NULL)
111        PHP_FE(caca_load_font, NULL)
112        PHP_FE(caca_load_builtin_font, NULL)
113        PHP_FE(caca_get_font_list, NULL)
114        PHP_FE(caca_get_font_width, NULL)
115        PHP_FE(caca_get_font_height, NULL)
116        PHP_FE(caca_get_font_blocks, NULL)
117        PHP_FE(caca_render_canvas, NULL)
118        PHP_FE(caca_canvas_set_figfont, NULL)
119        PHP_FE(caca_put_figchar, NULL)
120        PHP_FE(caca_flush_figlet, NULL)
121        PHP_FE(caca_file_open, NULL)
122        PHP_FE(caca_file_close, NULL)
123        PHP_FE(caca_file_tell, NULL)
124        PHP_FE(caca_file_read, NULL)
125        PHP_FE(caca_file_write, NULL)
126        PHP_FE(caca_file_gets, NULL)
127        PHP_FE(caca_file_eof, NULL)
128        PHP_FE(caca_import_string, NULL)
129        PHP_FE(caca_import_file, NULL)
130        PHP_FE(caca_get_import_list, NULL)
131        PHP_FE(caca_export_string, NULL)
132        PHP_FE(caca_get_export_list, NULL)
133        PHP_FE(caca_create_display, NULL)
134        PHP_FE(caca_create_display_with_driver, NULL)
135        PHP_FE(caca_get_display_driver_list, NULL)
136        PHP_FE(caca_get_display_driver, NULL)
137        PHP_FE(caca_set_display_driver, NULL)
138        PHP_FE(caca_get_canvas, NULL)
139        PHP_FE(caca_refresh_display, NULL)
140        PHP_FE(caca_set_display_time, NULL)
141        PHP_FE(caca_get_display_time, NULL)
142        PHP_FE(caca_get_display_width, NULL)
143        PHP_FE(caca_get_display_height, NULL)
144        PHP_FE(caca_set_display_title, NULL)
145        PHP_FE(caca_set_mouse, NULL)
146        PHP_FE(caca_set_cursor, NULL)
147        PHP_FE(caca_get_event, NULL)
148        PHP_FE(caca_get_mouse_x, NULL)
149        PHP_FE(caca_get_mouse_y, NULL)
150        PHP_FE(caca_get_event_type, NULL)
151        PHP_FE(caca_get_event_key_ch, NULL)
152        PHP_FE(caca_get_event_mouse_button, NULL)
153        PHP_FE(caca_get_event_mouse_x, NULL)
154        PHP_FE(caca_get_event_mouse_y, NULL)
155        PHP_FE(caca_get_event_resize_width, NULL)
156        PHP_FE(caca_get_event_resize_height, NULL)
157
158        {NULL, NULL, NULL}
159};
160
161zend_module_entry caca_module_entry = {
162#if ZEND_MODULE_API_NO >= 20010901
163        STANDARD_MODULE_HEADER,
164#endif
165        PHP_CACA_EXTNAME,
166        caca_functions,
167        PHP_MINIT(caca),
168        NULL,
169        NULL,
170        NULL,
171        PHP_MINFO(caca),
172#if ZEND_MODULE_API_NO >= 20010901
173        PHP_CACA_VERSION,
174#endif
175        STANDARD_MODULE_PROPERTIES
176};
177
178#ifdef COMPILE_DL_CACA
179ZEND_GET_MODULE(caca)
180#endif
181
182PHP_MINFO_FUNCTION(caca) {
183        php_info_print_table_start();
184        php_info_print_table_row(2, "Caca library version", caca_get_version());
185        php_info_print_table_end();
186}
187
188//-------- Caca's ressources destructors -----------//
189
190static void php_caca_canvas_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
191        caca_free_canvas(rsrc->ptr);
192}
193
194static void php_caca_dither_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
195        caca_free_dither(rsrc->ptr);
196}
197
198static void php_caca_font_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
199        caca_free_font(rsrc->ptr);
200}
201
202static void php_caca_file_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
203        caca_file_close(rsrc->ptr);
204}
205
206static void php_caca_display_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
207        caca_free_display(rsrc->ptr);
208}
209
210static void php_caca_event_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
211        efree((caca_event_t *) rsrc->ptr);
212}
213
214//-------- Initialization ---------//
215
216PHP_MINIT_FUNCTION(caca) {
217
218        le_caca_canvas = zend_register_list_destructors_ex(php_caca_canvas_dtor, NULL, PHP_CACA_CANVAS_RES_NAME, module_number);
219        le_caca_dither = zend_register_list_destructors_ex(php_caca_dither_dtor, NULL, PHP_CACA_DITHER_RES_NAME, module_number);
220        le_caca_font = zend_register_list_destructors_ex(php_caca_font_dtor, NULL, PHP_CACA_FONT_RES_NAME, module_number);
221        le_caca_file = zend_register_list_destructors_ex(php_caca_file_dtor, NULL, PHP_CACA_FILE_RES_NAME, module_number);
222        le_caca_display = zend_register_list_destructors_ex(php_caca_display_dtor, NULL, PHP_CACA_DISPLAY_RES_NAME, module_number);
223        le_caca_event = zend_register_list_destructors_ex(php_caca_event_dtor, NULL, PHP_CACA_EVENT_RES_NAME, module_number);
224       
225        REGISTER_LONG_CONSTANT("CACA_BLACK", CACA_BLACK, CONST_CS | CONST_PERSISTENT);
226        REGISTER_LONG_CONSTANT("CACA_BLUE", CACA_BLUE, CONST_CS | CONST_PERSISTENT);
227        REGISTER_LONG_CONSTANT("CACA_GREEN", CACA_GREEN, CONST_CS | CONST_PERSISTENT);
228        REGISTER_LONG_CONSTANT("CACA_CYAN", CACA_CYAN, CONST_CS | CONST_PERSISTENT);
229        REGISTER_LONG_CONSTANT("CACA_RED", CACA_RED, CONST_CS | CONST_PERSISTENT);
230        REGISTER_LONG_CONSTANT("CACA_MAGENTA", CACA_MAGENTA, CONST_CS | CONST_PERSISTENT);
231        REGISTER_LONG_CONSTANT("CACA_BROWN", CACA_BROWN, CONST_CS | CONST_PERSISTENT);
232        REGISTER_LONG_CONSTANT("CACA_LIGHTGRAY", CACA_LIGHTGRAY, CONST_CS | CONST_PERSISTENT);
233        REGISTER_LONG_CONSTANT("CACA_DARKGRAY", CACA_DARKGRAY, CONST_CS | CONST_PERSISTENT);
234        REGISTER_LONG_CONSTANT("CACA_LIGHTBLUE", CACA_LIGHTBLUE, CONST_CS | CONST_PERSISTENT);
235        REGISTER_LONG_CONSTANT("CACA_LIGHTGREEN", CACA_LIGHTGREEN, CONST_CS | CONST_PERSISTENT);
236        REGISTER_LONG_CONSTANT("CACA_LIGHTCYAN", CACA_LIGHTCYAN, CONST_CS | CONST_PERSISTENT);
237        REGISTER_LONG_CONSTANT("CACA_LIGHTRED", CACA_LIGHTRED, CONST_CS | CONST_PERSISTENT);
238        REGISTER_LONG_CONSTANT("CACA_LIGHTMAGENTA", CACA_LIGHTMAGENTA, CONST_CS | CONST_PERSISTENT);
239        REGISTER_LONG_CONSTANT("CACA_YELLOW", CACA_YELLOW, CONST_CS | CONST_PERSISTENT);
240        REGISTER_LONG_CONSTANT("CACA_WHITE", CACA_WHITE, CONST_CS | CONST_PERSISTENT);
241        REGISTER_LONG_CONSTANT("CACA_DEFAULT", CACA_DEFAULT, CONST_CS | CONST_PERSISTENT);
242        REGISTER_LONG_CONSTANT("CACA_TRANSPARENT", CACA_TRANSPARENT, CONST_CS | CONST_PERSISTENT);
243        REGISTER_LONG_CONSTANT("CACA_BOLD", CACA_BOLD, CONST_CS | CONST_PERSISTENT);
244        REGISTER_LONG_CONSTANT("CACA_ITALICS", CACA_ITALICS, CONST_CS | CONST_PERSISTENT);
245        REGISTER_LONG_CONSTANT("CACA_UNDERLINE", CACA_UNDERLINE, CONST_CS | CONST_PERSISTENT);
246        REGISTER_LONG_CONSTANT("CACA_BLINK", CACA_BLINK, CONST_CS | CONST_PERSISTENT);
247
248        REGISTER_LONG_CONSTANT("CACA_EVENT_NONE", CACA_EVENT_NONE, CONST_CS | CONST_PERSISTENT);
249        REGISTER_LONG_CONSTANT("CACA_EVENT_KEY_PRESS", CACA_EVENT_KEY_PRESS, CONST_CS | CONST_PERSISTENT);
250        REGISTER_LONG_CONSTANT("CACA_EVENT_KEY_RELEASE", CACA_EVENT_KEY_RELEASE, CONST_CS | CONST_PERSISTENT);
251        REGISTER_LONG_CONSTANT("CACA_EVENT_MOUSE_PRESS", CACA_EVENT_MOUSE_PRESS, CONST_CS | CONST_PERSISTENT);
252        REGISTER_LONG_CONSTANT("CACA_EVENT_MOUSE_RELEASE", CACA_EVENT_MOUSE_RELEASE, CONST_CS | CONST_PERSISTENT);
253        REGISTER_LONG_CONSTANT("CACA_EVENT_MOUSE_MOTION", CACA_EVENT_MOUSE_MOTION, CONST_CS | CONST_PERSISTENT);
254        REGISTER_LONG_CONSTANT("CACA_EVENT_RESIZE", CACA_EVENT_RESIZE, CONST_CS | CONST_PERSISTENT);
255        REGISTER_LONG_CONSTANT("CACA_EVENT_QUIT", CACA_EVENT_QUIT, CONST_CS | CONST_PERSISTENT);
256        REGISTER_LONG_CONSTANT("CACA_EVENT_ANY", CACA_EVENT_ANY, CONST_CS | CONST_PERSISTENT);
257
258        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_A", CACA_KEY_CTRL_A, CONST_CS | CONST_PERSISTENT);
259        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_B", CACA_KEY_CTRL_B, CONST_CS | CONST_PERSISTENT);
260        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_C", CACA_KEY_CTRL_C, CONST_CS | CONST_PERSISTENT);
261        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_D", CACA_KEY_CTRL_D, CONST_CS | CONST_PERSISTENT);
262        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_E", CACA_KEY_CTRL_E, CONST_CS | CONST_PERSISTENT);
263        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_F", CACA_KEY_CTRL_F, CONST_CS | CONST_PERSISTENT);
264        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_G", CACA_KEY_CTRL_G, CONST_CS | CONST_PERSISTENT);
265        REGISTER_LONG_CONSTANT("CACA_KEY_BACKSPACE", CACA_KEY_BACKSPACE, CONST_CS | CONST_PERSISTENT);
266        REGISTER_LONG_CONSTANT("CACA_KEY_TAB", CACA_KEY_TAB, CONST_CS | CONST_PERSISTENT);
267        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_J", CACA_KEY_CTRL_J, CONST_CS | CONST_PERSISTENT);
268        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_K", CACA_KEY_CTRL_K, CONST_CS | CONST_PERSISTENT);
269        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_L", CACA_KEY_CTRL_L, CONST_CS | CONST_PERSISTENT);
270        REGISTER_LONG_CONSTANT("CACA_KEY_RETURN", CACA_KEY_RETURN, CONST_CS | CONST_PERSISTENT);
271        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_N", CACA_KEY_CTRL_N, CONST_CS | CONST_PERSISTENT);
272        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_O", CACA_KEY_CTRL_O, CONST_CS | CONST_PERSISTENT);
273        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_P", CACA_KEY_CTRL_P, CONST_CS | CONST_PERSISTENT);
274        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_Q", CACA_KEY_CTRL_Q, CONST_CS | CONST_PERSISTENT);
275        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_R", CACA_KEY_CTRL_R, CONST_CS | CONST_PERSISTENT);
276        REGISTER_LONG_CONSTANT("CACA_KEY_PAUSE", CACA_KEY_PAUSE, CONST_CS | CONST_PERSISTENT);
277        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_T", CACA_KEY_CTRL_T, CONST_CS | CONST_PERSISTENT);
278        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_U", CACA_KEY_CTRL_U, CONST_CS | CONST_PERSISTENT);
279        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_V", CACA_KEY_CTRL_V, CONST_CS | CONST_PERSISTENT);
280        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_W", CACA_KEY_CTRL_W, CONST_CS | CONST_PERSISTENT);
281        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_X", CACA_KEY_CTRL_X, CONST_CS | CONST_PERSISTENT);
282        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_Y", CACA_KEY_CTRL_Y, CONST_CS | CONST_PERSISTENT);
283        REGISTER_LONG_CONSTANT("CACA_KEY_CTRL_Z", CACA_KEY_CTRL_Z, CONST_CS | CONST_PERSISTENT);
284        REGISTER_LONG_CONSTANT("CACA_KEY_ESCAPE", CACA_KEY_ESCAPE, CONST_CS | CONST_PERSISTENT);
285        REGISTER_LONG_CONSTANT("CACA_KEY_DELETE", CACA_KEY_DELETE, CONST_CS | CONST_PERSISTENT);
286        REGISTER_LONG_CONSTANT("CACA_KEY_UP", CACA_KEY_UP, CONST_CS | CONST_PERSISTENT);
287        REGISTER_LONG_CONSTANT("CACA_KEY_DOWN", CACA_KEY_DOWN, CONST_CS | CONST_PERSISTENT);
288        REGISTER_LONG_CONSTANT("CACA_KEY_LEFT", CACA_KEY_LEFT, CONST_CS | CONST_PERSISTENT);
289        REGISTER_LONG_CONSTANT("CACA_KEY_RIGHT", CACA_KEY_RIGHT, CONST_CS | CONST_PERSISTENT);
290        REGISTER_LONG_CONSTANT("CACA_KEY_INSERT", CACA_KEY_INSERT, CONST_CS | CONST_PERSISTENT);
291        REGISTER_LONG_CONSTANT("CACA_KEY_HOME", CACA_KEY_HOME, CONST_CS | CONST_PERSISTENT);
292        REGISTER_LONG_CONSTANT("CACA_KEY_END", CACA_KEY_END, CONST_CS | CONST_PERSISTENT);
293        REGISTER_LONG_CONSTANT("CACA_KEY_PAGEUP", CACA_KEY_PAGEUP, CONST_CS | CONST_PERSISTENT);
294        REGISTER_LONG_CONSTANT("CACA_KEY_PAGEDOWN", CACA_KEY_PAGEDOWN, CONST_CS | CONST_PERSISTENT);
295        REGISTER_LONG_CONSTANT("CACA_KEY_F1", CACA_KEY_F1, CONST_CS | CONST_PERSISTENT);
296        REGISTER_LONG_CONSTANT("CACA_KEY_F2", CACA_KEY_F2, CONST_CS | CONST_PERSISTENT);
297        REGISTER_LONG_CONSTANT("CACA_KEY_F3", CACA_KEY_F3, CONST_CS | CONST_PERSISTENT);
298        REGISTER_LONG_CONSTANT("CACA_KEY_F4", CACA_KEY_F4, CONST_CS | CONST_PERSISTENT);
299        REGISTER_LONG_CONSTANT("CACA_KEY_F5", CACA_KEY_F5, CONST_CS | CONST_PERSISTENT);
300        REGISTER_LONG_CONSTANT("CACA_KEY_F6", CACA_KEY_F6, CONST_CS | CONST_PERSISTENT);
301        REGISTER_LONG_CONSTANT("CACA_KEY_F7", CACA_KEY_F7, CONST_CS | CONST_PERSISTENT);
302        REGISTER_LONG_CONSTANT("CACA_KEY_F8", CACA_KEY_F8, CONST_CS | CONST_PERSISTENT);
303        REGISTER_LONG_CONSTANT("CACA_KEY_F9", CACA_KEY_F9, CONST_CS | CONST_PERSISTENT);
304        REGISTER_LONG_CONSTANT("CACA_KEY_F10", CACA_KEY_F10, CONST_CS | CONST_PERSISTENT);
305        REGISTER_LONG_CONSTANT("CACA_KEY_F11", CACA_KEY_F11, CONST_CS | CONST_PERSISTENT);
306        REGISTER_LONG_CONSTANT("CACA_KEY_F12", CACA_KEY_F12, CONST_CS | CONST_PERSISTENT);
307        REGISTER_LONG_CONSTANT("CACA_KEY_F13", CACA_KEY_F13, CONST_CS | CONST_PERSISTENT);
308        REGISTER_LONG_CONSTANT("CACA_KEY_F14", CACA_KEY_F14, CONST_CS | CONST_PERSISTENT);
309        REGISTER_LONG_CONSTANT("CACA_KEY_F15", CACA_KEY_F15, CONST_CS | CONST_PERSISTENT);
310
311        return SUCCESS;
312}
313
314//---------- Some usefull macros ---------------//
315
316#define FETCH_CANVAS(canvas) \
317        zval *_zval; \
318        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) { \
319                RETURN_FALSE; \
320        } \
321        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
322
323#define FETCH_DISPLAY(display) \
324        zval *_zval; \
325        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) { \
326                RETURN_FALSE; \
327        } \
328        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
329
330#define FETCH_EVENT(event) \
331        zval *_zval; \
332        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) { \
333                RETURN_FALSE; \
334        } \
335        ZEND_FETCH_RESOURCE(event, caca_event_t*, &_zval, -1, PHP_CACA_EVENT_RES_NAME, le_caca_event);
336
337#define FETCH_LONG(l) \
338        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &l) == FAILURE) { \
339                RETURN_FALSE; \
340        }
341
342#define RETURN_CHAR(c) \
343        char *str = emalloc(2); \
344        str[0] = c; \
345        str[1] = '\0'; \
346        RETURN_STRING(str, 0);
347
348#define RETURN_SUCCESS(i) \
349        RETURN_BOOL((i) == 0);
350
351//---------- Some usefull functions --------------------//
352
353//Fetch external php resources such as gd resouces
354
355void *fetch_external_resource(zval *_zval, char const *type_name) {
356        int resource_id = _zval->value.lval;
357        int resource_type;
358        void *result = zend_list_find(resource_id, &resource_type);
359        if (!result)
360                return NULL;
361        char *resource_type_name = zend_rsrc_list_get_rsrc_type(resource_id);
362        return (strcmp(resource_type_name, type_name) == 0) ? result : NULL;
363}
364
365//Fetch buffer of pixels from gdImage
366
367#ifdef HAVE_GD
368void *gd_get_pixels(gdImage *img) {
369        void *result;
370        int j, pitch;           
371        if (img->trueColor)  {
372                pitch = img->sx * sizeof(int);
373                result = malloc(img->sy * pitch);
374                for (j = 0; j < img->sy; j++)
375                        memcpy(result + (j * pitch), (const void *) img->tpixels[j], pitch);
376        }
377        else {
378                pitch = img->sx * sizeof(char);
379                result = malloc(img->sy * pitch);
380                for (j = 0; j < img->sy; j++)
381                        memcpy(result + (j * pitch), (const void *) img->pixels[j], pitch);
382        }
383        return result;
384}
385
386int gd_load_palette(gdImage *img, caca_dither_t *dither) {
387        if (!img || img->trueColor || gdMaxColors != 256) {
388                return -1;
389        }
390
391        uint32_t r[256], g[256], b[256], a[256];
392        int i;
393        for (i = 0; i < 256; i++) {
394                r[i] = img->red[i] << 4;
395                g[i] = img->green[i] << 4;
396                b[i] = img->blue[i] << 4;
397                a[i] = img->alpha[i] << 4;
398        }
399
400        return caca_set_dither_palette(dither, &r[0], &g[0], &b[0], &a[0]);
401}
402#endif
403//------- Caca's functions ----------------//
404
405PHP_FUNCTION(caca_create_canvas) {
406        long width, height = 0;
407        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &width, &height) == FAILURE) {
408                RETURN_FALSE;
409        }
410        caca_canvas_t *canvas = caca_create_canvas(width, height);
411        if (!canvas) {
412                RETURN_FALSE;
413        }
414        ZEND_REGISTER_RESOURCE(return_value, canvas, le_caca_canvas);
415}
416
417PHP_FUNCTION(caca_set_canvas_size) {
418        zval *_zval;
419        long width, height = 0;
420        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &width, &height) == FAILURE) {
421                RETURN_FALSE;
422        }
423        caca_canvas_t *canvas;
424        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
425        RETURN_SUCCESS(caca_set_canvas_size(canvas, width, height));
426}
427
428PHP_FUNCTION(caca_get_canvas_width) {
429        caca_canvas_t *canvas;
430        FETCH_CANVAS(canvas);
431        RETURN_LONG(caca_get_canvas_width(canvas));
432}
433
434PHP_FUNCTION(caca_get_canvas_height) {
435        caca_canvas_t *canvas;
436        FETCH_CANVAS(canvas);
437        RETURN_LONG(caca_get_canvas_height(canvas));
438}
439
440PHP_FUNCTION(caca_get_canvas_chars) {
441        caca_canvas_t *canvas;
442        FETCH_CANVAS(canvas);
443        RETURN_STRING((char *) caca_get_canvas_chars(canvas), 1);
444}
445
446PHP_FUNCTION(caca_get_canvas_attrs) {
447        caca_canvas_t *canvas;
448        FETCH_CANVAS(canvas);
449        RETURN_STRING((char *) caca_get_canvas_attrs(canvas), 1);
450}
451
452PHP_FUNCTION(caca_rand) {
453        long min, max = 0;
454        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &min, &max) == FAILURE) {
455                RETURN_FALSE;
456        }
457        RETURN_LONG(caca_rand(min, max));
458}
459
460PHP_FUNCTION(caca_get_version) {
461        RETURN_STRING((char *) caca_get_version(), 1);
462}
463
464PHP_FUNCTION(caca_gotoxy) {
465        zval *_zval;
466        long x, y = 0;
467        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &x, &y) == FAILURE) {
468                RETURN_FALSE;
469        }
470        caca_canvas_t *canvas;
471        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
472        RETURN_SUCCESS(caca_gotoxy(canvas, x, y));
473}
474
475PHP_FUNCTION(caca_get_cursor_x) {
476        caca_canvas_t *canvas;
477        FETCH_CANVAS(canvas);
478        RETURN_LONG(caca_get_cursor_x(canvas));
479}
480
481PHP_FUNCTION(caca_get_cursor_y) {
482        caca_canvas_t *canvas;
483        FETCH_CANVAS(canvas);
484        RETURN_LONG(caca_get_cursor_y(canvas));
485}
486
487PHP_FUNCTION(caca_put_char) {
488        zval *_zval;
489        long x, y, c;
490        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &_zval, &x, &y, &c) == FAILURE) {
491                RETURN_FALSE;
492        }
493        caca_canvas_t *canvas;
494        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
495        RETURN_SUCCESS(caca_put_char(canvas, x, y, c));
496}
497
498PHP_FUNCTION(caca_get_char) {
499        zval *_zval;
500        long x, y = 0;
501        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &x, &y) == FAILURE) {
502                RETURN_FALSE;
503        }
504        caca_canvas_t *canvas;
505        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
506        RETURN_CHAR(caca_get_char(canvas, x, y));
507}
508
509PHP_FUNCTION(caca_put_str) {
510        zval *_zval;
511        char *str;
512        long x, y, str_len = 0;
513        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlls", &_zval, &x, &y, &str, &str_len) == FAILURE) {
514                RETURN_FALSE;
515        }
516        caca_canvas_t *canvas;
517        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
518        RETURN_SUCCESS(caca_put_str(canvas, x, y, str));
519}
520
521PHP_FUNCTION(caca_clear_canvas) {
522        caca_canvas_t *canvas;
523        FETCH_CANVAS(canvas);
524        RETURN_LONG(caca_clear_canvas(canvas));
525}
526
527PHP_FUNCTION(caca_set_canvas_handle) {
528        zval *_zval;
529        long x, y = 0;
530        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &x, &y) == FAILURE) {
531                RETURN_FALSE;
532        }
533        caca_canvas_t *canvas;
534        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
535        RETURN_SUCCESS(caca_set_canvas_handle(canvas, x, y));
536}
537
538PHP_FUNCTION(caca_get_canvas_handle_x) {
539        caca_canvas_t *canvas;
540        FETCH_CANVAS(canvas);
541        RETURN_LONG(caca_get_canvas_handle_x(canvas));
542}
543
544PHP_FUNCTION(caca_get_canvas_handle_y) {
545        caca_canvas_t *canvas;
546        FETCH_CANVAS(canvas);
547        RETURN_LONG(caca_get_canvas_handle_y(canvas));
548}
549
550PHP_FUNCTION(caca_blit) {
551        zval *_zval1, *_zval2, *_zval3 = NULL;
552        long x, y = 0;
553        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllr|r", &_zval1, &x, &y, &_zval2, &_zval3) == FAILURE) {
554                RETURN_FALSE;
555        }
556        caca_canvas_t *dst, *src, *mask = NULL;
557        ZEND_FETCH_RESOURCE(dst, caca_canvas_t*, &_zval1, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
558        ZEND_FETCH_RESOURCE(src, caca_canvas_t*, &_zval2, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
559        if (_zval3) {
560                ZEND_FETCH_RESOURCE(mask, caca_canvas_t*, &_zval3, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
561        }
562        RETURN_SUCCESS(caca_blit(dst, x, y, src, NULL));
563}
564
565PHP_FUNCTION(caca_set_canvas_boundaries) {
566        zval *_zval;
567        long x, y, width, height = 0;
568        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &_zval, &x, &y, &width, &height) == FAILURE) {
569                RETURN_FALSE;
570        }
571        caca_canvas_t *canvas;
572        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
573        RETURN_SUCCESS(caca_set_canvas_boundaries(canvas, x, y, width, height));
574}
575
576PHP_FUNCTION(caca_invert) {
577        caca_canvas_t *canvas;
578        FETCH_CANVAS(canvas);
579        RETURN_SUCCESS(caca_invert(canvas));
580}
581
582PHP_FUNCTION(caca_flip) {
583        caca_canvas_t *canvas;
584        FETCH_CANVAS(canvas);
585        RETURN_SUCCESS(caca_flip(canvas));
586}
587
588PHP_FUNCTION(caca_flop) {
589        caca_canvas_t *canvas;
590        FETCH_CANVAS(canvas);
591        RETURN_SUCCESS(caca_flop(canvas));
592}
593
594PHP_FUNCTION(caca_rotate_180) {
595        caca_canvas_t *canvas;
596        FETCH_CANVAS(canvas);
597        RETURN_SUCCESS(caca_rotate_180(canvas));
598}
599
600PHP_FUNCTION(caca_rotate_left) {
601        caca_canvas_t *canvas;
602        FETCH_CANVAS(canvas);
603        RETURN_SUCCESS(caca_rotate_left(canvas));
604}
605
606PHP_FUNCTION(caca_rotate_right) {
607        caca_canvas_t *canvas;
608        FETCH_CANVAS(canvas);
609        RETURN_SUCCESS(caca_rotate_right(canvas));
610}
611
612PHP_FUNCTION(caca_stretch_left) {
613        caca_canvas_t *canvas;
614        FETCH_CANVAS(canvas);
615        RETURN_SUCCESS(caca_stretch_left(canvas));
616}
617
618PHP_FUNCTION(caca_stretch_right) {
619        caca_canvas_t *canvas;
620        FETCH_CANVAS(canvas);
621        RETURN_SUCCESS(caca_stretch_right(canvas));
622}
623
624PHP_FUNCTION(caca_get_attr) {
625        zval *_zval;
626        long x, y = 0;
627        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &x, &y) == FAILURE) {
628                RETURN_FALSE;
629        }
630        caca_canvas_t *canvas;
631        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
632        RETURN_LONG(caca_get_attr(canvas, x, y));
633}
634
635PHP_FUNCTION(caca_set_attr) {
636        zval *_zval;
637        long attr = 0;
638        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &attr) == FAILURE) {
639                RETURN_FALSE;
640        }
641        caca_canvas_t *canvas;
642        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
643        RETURN_SUCCESS(caca_set_attr(canvas, attr));
644}
645
646PHP_FUNCTION(caca_put_attr) {
647        zval *_zval;
648        long x, y, attr = 0;
649        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &_zval, &x, &y, &attr) == FAILURE) {
650                RETURN_FALSE;
651        }
652        caca_canvas_t *canvas;
653        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
654        RETURN_SUCCESS(caca_put_attr(canvas, x, y, attr));
655}
656
657PHP_FUNCTION(caca_set_color_ansi) {
658        zval *_zval;
659        long foreground, background = 0;
660        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &foreground, &background) == FAILURE) {
661                RETURN_FALSE;
662        }
663        caca_canvas_t *canvas;
664        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
665        RETURN_SUCCESS(caca_set_color_ansi(canvas, foreground, background));
666}
667
668PHP_FUNCTION(caca_set_color_argb) {
669        zval *_zval;
670        long foreground, background = 0;
671        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &_zval, &foreground, &background) == FAILURE) {
672                RETURN_FALSE;
673        }
674        caca_canvas_t *canvas;
675        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
676        RETURN_SUCCESS(caca_set_color_argb(canvas, foreground, background));
677}
678
679PHP_FUNCTION(caca_attr_to_ansi) {
680        long l;
681        FETCH_LONG(l);
682        RETURN_LONG(caca_attr_to_ansi(l));
683}
684
685PHP_FUNCTION(caca_attr_to_ansi_fg) {
686        long l;
687        FETCH_LONG(l);
688        RETURN_LONG(caca_attr_to_ansi_fg(l));
689}
690
691PHP_FUNCTION(caca_attr_to_ansi_bg) {
692        long l;
693        FETCH_LONG(l);
694        RETURN_LONG(caca_attr_to_ansi_bg(l));
695}
696
697PHP_FUNCTION(caca_attr_to_rgb12_fg) {
698        long l;
699        FETCH_LONG(l);
700        RETURN_LONG(caca_attr_to_rgb12_fg(l));
701}
702
703PHP_FUNCTION(caca_attr_to_rgb12_bg) {
704        long l;
705        FETCH_LONG(l);
706        RETURN_LONG(caca_attr_to_rgb12_bg(l));
707}
708
709PHP_FUNCTION(caca_attr_to_argb64) {
710        //TODO: write or delete
711}
712
713PHP_FUNCTION(caca_utf8_to_utf32) {
714        //TODO: write or delete
715}
716
717PHP_FUNCTION(caca_utf32_to_utf8) {
718        //TODO: write or delete
719}
720
721PHP_FUNCTION(caca_utf32_to_cp437) {
722        long l;
723        FETCH_LONG(l);
724        RETURN_LONG(caca_utf32_to_cp437(l));
725}
726
727PHP_FUNCTION(caca_cp437_to_utf32) {
728        long l;
729        FETCH_LONG(l);
730        RETURN_LONG(caca_cp437_to_utf32(l));
731}
732
733PHP_FUNCTION(caca_utf32_to_ascii) {
734        long l;
735        FETCH_LONG(l);
736        RETURN_CHAR(caca_utf32_to_ascii(l));
737}
738
739PHP_FUNCTION(caca_utf32_is_fullwidth) {
740}
741
742PHP_FUNCTION(caca_draw_line) {
743        zval *_zval;
744        long xa, ya, xb, yb, c;
745        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &_zval, &xa, &ya, &xb, &yb, &c) == FAILURE) {
746                RETURN_FALSE;
747        }
748        caca_canvas_t *canvas;
749        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
750        RETURN_SUCCESS(caca_draw_line(canvas, xa, ya, xb, yb, c));
751}
752
753PHP_FUNCTION(caca_draw_polyline) {
754        zval *zval_res, *zval_arr;
755        long c;
756
757        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ral", &zval_res, &zval_arr, &c) == FAILURE) {
758                RETURN_FALSE;
759        }
760
761        caca_canvas_t *canvas;
762        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &zval_res, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
763
764        HashTable *arr_hash = Z_ARRVAL_P(zval_arr);
765        int lenmax = zend_hash_num_elements(arr_hash);
766        int *tbl_x, *tbl_y;
767        int tbl_count = 0;
768        tbl_x = malloc(sizeof(int) * lenmax);
769        tbl_y = malloc(sizeof(int) * lenmax);
770       
771        HashPosition pos;
772        zval **pt, **x, **y;
773        for (
774                zend_hash_internal_pointer_reset_ex(arr_hash, &pos);
775                zend_hash_get_current_data_ex(arr_hash, (void**) &pt, &pos) == SUCCESS;
776                zend_hash_move_forward_ex(arr_hash, &pos)
777        ) {
778                if (
779                        Z_TYPE_P(*pt) == IS_ARRAY
780                        && (zend_hash_index_find(Z_ARRVAL_P(*pt), 0, (void**) &x) != FAILURE)
781                        && (zend_hash_index_find(Z_ARRVAL_P(*pt), 1, (void**) &y) != FAILURE)
782                ) {
783                        convert_to_long_ex(x);
784                        convert_to_long_ex(y);
785                        tbl_x[tbl_count] = Z_LVAL_PP(x);
786                        tbl_y[tbl_count] = Z_LVAL_PP(y);
787                        tbl_count++;
788                }
789        }
790        int res = caca_draw_polyline(canvas, tbl_x, tbl_y, tbl_count - 1, c);
791        free(tbl_x);
792        free(tbl_y);
793        RETURN_SUCCESS(res);
794}
795
796PHP_FUNCTION(caca_draw_thin_line) {
797        zval *_zval;
798        long xa, ya, xb, yb = 0;
799        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &_zval, &xa, &ya, &xb, &yb) == FAILURE) {
800                RETURN_FALSE;
801        }
802        caca_canvas_t *canvas;
803        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
804        RETURN_SUCCESS(caca_draw_thin_line(canvas, xa, ya, xb, yb));
805}
806
807PHP_FUNCTION(caca_draw_thin_polyline) {
808        zval *zval_res, *zval_arr;
809        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &zval_res, &zval_arr) == FAILURE) {
810                RETURN_FALSE;
811        }
812
813        caca_canvas_t *canvas;
814        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &zval_res, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
815
816        HashTable *arr_hash = Z_ARRVAL_P(zval_arr);
817        int lenmax = zend_hash_num_elements(arr_hash);
818        int *tbl_x, *tbl_y;
819        int tbl_count = 0;
820        tbl_x = malloc(sizeof(int) * lenmax);
821        tbl_y = malloc(sizeof(int) * lenmax);
822
823        if (!tbl_x || !tbl_y) {
824                RETURN_FALSE;
825        }
826       
827        HashPosition pos;
828        zval **pt, **x, **y;
829        for (
830                zend_hash_internal_pointer_reset_ex(arr_hash, &pos);
831                zend_hash_get_current_data_ex(arr_hash, (void**) &pt, &pos) == SUCCESS;
832                zend_hash_move_forward_ex(arr_hash, &pos)
833        ) {
834                if (
835                        Z_TYPE_P(*pt) == IS_ARRAY
836                        && (zend_hash_index_find(Z_ARRVAL_P(*pt), 0, (void**) &x) != FAILURE)
837                        && (zend_hash_index_find(Z_ARRVAL_P(*pt), 1, (void**) &y) != FAILURE)
838                ) {
839                        convert_to_long_ex(x);
840                        convert_to_long_ex(y);
841                        tbl_x[tbl_count] = Z_LVAL_PP(x);
842                        tbl_y[tbl_count] = Z_LVAL_PP(y);
843                        tbl_count++;
844                }
845        }
846        int res = caca_draw_thin_polyline(canvas, tbl_x, tbl_y, tbl_count - 1);
847        free(tbl_x);
848        free(tbl_y);
849        RETURN_SUCCESS(res);
850}
851
852PHP_FUNCTION(caca_draw_circle) {
853        zval *_zval;
854        long x, y, r, c;
855        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &_zval, &x, &y, &r, &c) == FAILURE) {
856                RETURN_FALSE;
857        }
858        caca_canvas_t *canvas;
859        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
860        RETURN_SUCCESS(caca_draw_circle(canvas, x, y, r, c));
861}
862
863PHP_FUNCTION(caca_draw_ellipse) {
864        zval *_zval;
865        long xa, ya, xb, yb, c = 0;
866        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &_zval, &xa, &ya, &xb, &yb, &c) == FAILURE) {
867                RETURN_FALSE;
868        }
869        caca_canvas_t *canvas;
870        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
871        RETURN_SUCCESS(caca_draw_ellipse(canvas, xa, ya, xb, yb, c));
872}
873
874PHP_FUNCTION(caca_draw_thin_ellipse) {
875        zval *_zval;
876        long xa, ya, xb, yb = 0;
877        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &_zval, &xa, &ya, &xb, &yb) == FAILURE) {
878                RETURN_FALSE;
879        }
880        caca_canvas_t *canvas;
881        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
882        RETURN_SUCCESS(caca_draw_thin_ellipse(canvas, xa, ya, xb, yb));
883}
884
885PHP_FUNCTION(caca_fill_ellipse) {
886        zval *_zval;
887        long xa, ya, xb, yb, c;
888        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &_zval, &xa, &ya, &xb, &yb, &c) == FAILURE) {
889                RETURN_FALSE;
890        }
891        caca_canvas_t *canvas;
892        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
893        RETURN_SUCCESS(caca_fill_ellipse(canvas, xa, ya, xb, yb, c));
894}
895
896PHP_FUNCTION(caca_draw_box) {
897        zval *_zval;
898        long xa, ya, xb, yb, c;
899        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &_zval, &xa, &ya, &xb, &yb, &c) == FAILURE) {
900                RETURN_FALSE;
901        }
902        caca_canvas_t *canvas;
903        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
904        RETURN_SUCCESS(caca_draw_box(canvas, xa, ya, xb, yb, c));
905}
906
907PHP_FUNCTION(caca_draw_thin_box) {
908        zval *_zval;
909        long xa, ya, xb, yb = 0;
910        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &_zval, &xa, &ya, &xb, &yb) == FAILURE) {
911                RETURN_FALSE;
912        }
913        caca_canvas_t *canvas;
914        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
915        RETURN_SUCCESS(caca_draw_thin_box(canvas, xa, ya, xb, yb));
916}
917
918PHP_FUNCTION(caca_draw_cp437_box) {
919        zval *_zval;
920        long xa, ya, xb, yb;
921        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &_zval, &xa, &ya, &xb, &yb) == FAILURE) {
922                RETURN_FALSE;
923        }
924        caca_canvas_t *canvas;
925        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
926        RETURN_SUCCESS(caca_draw_cp437_box(canvas, xa, ya, xb, yb));
927}
928
929PHP_FUNCTION(caca_fill_box) {
930        zval *_zval;
931        long xa, ya, xb, yb, c;
932        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &_zval, &xa, &ya, &xb, &yb, &c) == FAILURE) {
933                RETURN_FALSE;
934        }
935        caca_canvas_t *canvas;
936        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
937        RETURN_SUCCESS(caca_fill_box(canvas, xa, ya, xb, yb, c));
938}
939
940PHP_FUNCTION(caca_draw_triangle) {
941        zval *_zval;
942        long xa, ya, xb, yb, xc, yc, c;
943        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllllll", &_zval, &xa, &ya, &xb, &yb, &xc, &yc, &c) == FAILURE) {
944                RETURN_FALSE;
945        }
946        caca_canvas_t *canvas;
947        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
948        RETURN_SUCCESS(caca_draw_triangle(canvas, xa, ya, xb, yb, xc, yc, c));
949}
950
951PHP_FUNCTION(caca_draw_thin_triangle) {
952        zval *_zval;
953        long xa, ya, xb, yb, xc, yc = 0;
954        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllllll", &_zval, &xa, &ya, &xb, &yb, &xc, &yc) == FAILURE) {
955                RETURN_FALSE;
956        }
957        caca_canvas_t *canvas;
958        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
959        RETURN_SUCCESS(caca_draw_thin_triangle(canvas, xa, ya, xb, yb, xc, yc));
960}
961
962PHP_FUNCTION(caca_fill_triangle) {
963        zval *_zval;
964        long xa, ya, xb, yb, xc, yc, c = 0;
965        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllllll", &_zval, &xa, &ya, &xb, &yb, &xc, &yc, &c) == FAILURE) {
966                RETURN_FALSE;
967        }
968        caca_canvas_t *canvas;
969        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
970        RETURN_SUCCESS(caca_fill_triangle(canvas, xa, ya, xb, yb, xc, yc, c));
971}
972
973PHP_FUNCTION(caca_get_frame_count) {
974        zval *_zval;
975        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
976                RETURN_FALSE;
977        }
978        caca_canvas_t *canvas;
979        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
980        RETURN_LONG(caca_get_canvas_count(canvas));
981}
982
983PHP_FUNCTION(caca_set_frame) {
984        zval *_zval;
985        long id;
986        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &id) == FAILURE) {
987                RETURN_FALSE;
988        }
989        caca_canvas_t *canvas;
990        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
991        RETURN_SUCCESS(caca_set_frame(canvas, id));
992}
993
994PHP_FUNCTION(caca_set_frame_name) {
995        zval *_zval;
996        char *str;
997        long str_len;
998        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
999                RETURN_FALSE;
1000        }
1001        caca_canvas_t *canvas;
1002        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1003        RETURN_SUCCESS(caca_set_frame_name(canvas, str));
1004}
1005
1006PHP_FUNCTION(caca_create_frame) {
1007        zval *_zval;
1008        long id;
1009        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &id) == FAILURE) {
1010                RETURN_FALSE;
1011        }
1012        caca_canvas_t *canvas;
1013        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1014        RETURN_SUCCESS(caca_create_frame(canvas, id));
1015}
1016
1017PHP_FUNCTION(caca_free_frame) {
1018        zval *_zval;
1019        long id;
1020        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &id) == FAILURE) {
1021                RETURN_FALSE;
1022        }
1023        caca_canvas_t *canvas;
1024        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1025        RETURN_SUCCESS(caca_free_frame(canvas, id));
1026}
1027
1028PHP_FUNCTION(caca_create_dither) {
1029        zval *_zval;
1030        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1031                RETURN_FALSE;
1032        }
1033#ifdef HAVE_GD
1034        gdImage *img = fetch_external_resource(_zval, "gd");
1035        if (!img) {
1036                RETURN_FALSE;
1037        }
1038
1039        caca_dither_t *dither;
1040        if (img->trueColor)
1041                dither = caca_create_dither(sizeof(int) * 8, img->sx, img->sy, img->sx * sizeof(int), 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000);
1042        else
1043                dither = caca_create_dither(sizeof(char) * 8, img->sx, img->sy, img->sx * sizeof(char), 0, 0, 0, 0);
1044
1045        if (!dither) {
1046                RETURN_FALSE;
1047        }
1048
1049        ZEND_REGISTER_RESOURCE(return_value, dither, le_caca_dither);
1050#else
1051        RETURN_FALSE
1052#endif
1053}
1054
1055PHP_FUNCTION(caca_set_dither_palette) {
1056        zval *zval_res, *arr;
1057        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &zval_res, &arr) == FAILURE) {
1058                RETURN_FALSE;
1059        }
1060
1061        caca_dither_t *dither;
1062        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &zval_res, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_dither);
1063
1064        uint32_t tbl[4][256];
1065        zval **color, **value;
1066        int i, j;
1067        for (i = 0; i < 256; i++) {
1068                if (zend_hash_index_find(Z_ARRVAL_P(arr), i, (void**) &color) == FAILURE || Z_TYPE_P(*color) != IS_ARRAY) {
1069                        RETURN_FALSE;
1070                }
1071                for (j = 0; j < 4; j++) {
1072                        if (zend_hash_index_find(Z_ARRVAL_P(*color), j, (void**) &value) == FAILURE) {
1073                                RETURN_FALSE;
1074                        }
1075                        convert_to_long_ex(value);
1076                        tbl[j][i] = Z_LVAL_PP(value);
1077                }
1078        }
1079        RETURN_SUCCESS(caca_set_dither_palette(dither, tbl[0], tbl[1], tbl[2], tbl[3]));
1080}
1081
1082PHP_FUNCTION(caca_set_dither_brightness) {
1083        zval *_zval;
1084        double value;
1085        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rd", &_zval, &value) == FAILURE) {
1086                RETURN_FALSE;
1087        }
1088        caca_dither_t *dither;
1089        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1090        RETURN_SUCCESS(caca_set_dither_brightness(dither, value));
1091}
1092
1093PHP_FUNCTION(caca_get_dither_brightness) {
1094        zval *_zval;
1095        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1096                RETURN_FALSE;
1097        }
1098        caca_dither_t *dither;
1099        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1100        RETURN_DOUBLE(caca_get_dither_brightness(dither));
1101}
1102
1103PHP_FUNCTION(caca_set_dither_gamma) {
1104        zval *_zval;
1105        double value;
1106        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rd", &_zval, &value) == FAILURE) {
1107                RETURN_FALSE;
1108        }
1109        caca_dither_t *dither;
1110        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1111        RETURN_SUCCESS(caca_set_dither_gamma(dither, value));
1112}
1113
1114PHP_FUNCTION(caca_get_dither_gamma) {
1115        zval *_zval;
1116        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1117                RETURN_FALSE;
1118        }
1119        caca_dither_t *dither;
1120        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1121        RETURN_DOUBLE(caca_get_dither_gamma(dither));
1122}
1123
1124PHP_FUNCTION(caca_set_dither_contrast) {
1125        zval *_zval;
1126        double value;
1127        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rd", &_zval, &value) == FAILURE) {
1128                RETURN_FALSE;
1129        }
1130        caca_dither_t *dither;
1131        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1132        RETURN_SUCCESS(caca_set_dither_contrast(dither, value));
1133}
1134
1135PHP_FUNCTION(caca_get_dither_contrast) {
1136        zval *_zval;
1137        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1138                RETURN_FALSE;
1139        }
1140        caca_dither_t *dither;
1141        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1142        RETURN_DOUBLE(caca_get_dither_contrast(dither));
1143}
1144
1145PHP_FUNCTION(caca_set_dither_antialias) {
1146        zval *_zval;
1147        int str_len;
1148        char *str;
1149        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
1150                RETURN_FALSE;
1151        }
1152        caca_dither_t *dither;
1153        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1154        RETURN_SUCCESS(caca_set_dither_antialias(dither, str));
1155}
1156
1157PHP_FUNCTION(caca_get_dither_antialias_list) {
1158        zval *_zval;
1159        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1160                RETURN_FALSE;
1161        }
1162        caca_dither_t *dither;
1163        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1164
1165        char const * const *list = caca_get_dither_antialias_list(dither);
1166        int i;
1167        array_init(return_value);       
1168        for(i = 0; list[i]; i += 1)
1169                add_next_index_string(return_value, (char*) list[i], 1);
1170}
1171
1172PHP_FUNCTION(caca_get_dither_antialias) {
1173        zval *_zval;
1174        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1175                RETURN_FALSE;
1176        }
1177        caca_dither_t *dither;
1178        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1179        RETURN_STRING((char *) caca_get_dither_antialias(dither), 1);
1180}
1181
1182PHP_FUNCTION(caca_set_dither_color) {
1183        zval *_zval;
1184        int str_len;
1185        char *str;
1186        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
1187                RETURN_FALSE;
1188        }
1189        caca_dither_t *dither;
1190        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1191        RETURN_SUCCESS(caca_set_dither_color(dither, str));
1192}
1193
1194PHP_FUNCTION(caca_get_dither_color_list) {
1195        zval *_zval;
1196        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1197                RETURN_FALSE;
1198        }
1199        caca_dither_t *dither;
1200        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1201
1202        char const * const *list = caca_get_dither_antialias_list(dither);
1203        int i;
1204        array_init(return_value);       
1205        for(i = 0; list[i]; i += 2)
1206                add_assoc_string(return_value, (char*) list[i], (char*) list[i + 1], 1);
1207}
1208
1209PHP_FUNCTION(caca_get_dither_color) {
1210        zval *_zval;
1211        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1212                RETURN_FALSE;
1213        }
1214        caca_dither_t *dither;
1215        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1216        RETURN_STRING((char *) caca_get_dither_color(dither), 1);
1217}
1218
1219PHP_FUNCTION(caca_set_dither_charset) {
1220        zval *_zval;
1221        int str_len;
1222        char *str;
1223        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
1224                RETURN_FALSE;
1225        }
1226        caca_dither_t *dither;
1227        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1228        RETURN_SUCCESS(caca_set_dither_charset(dither, str));
1229}
1230
1231PHP_FUNCTION(caca_get_dither_charset_list) {
1232        zval *_zval;
1233        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1234                RETURN_FALSE;
1235        }
1236        caca_dither_t *dither;
1237        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1238
1239        char const * const *list = caca_get_dither_charset_list(dither);
1240        int i;
1241        array_init(return_value);       
1242        for(i = 0; list[i]; i += 2)
1243                add_assoc_string(return_value, (char*) list[i], (char*) list[i + 1], 1);
1244}
1245
1246PHP_FUNCTION(caca_get_dither_charset) {
1247        zval *_zval;
1248        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1249                RETURN_FALSE;
1250        }
1251        caca_dither_t *dither;
1252        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1253        RETURN_STRING((char *) caca_get_dither_charset(dither), 1);
1254}
1255
1256PHP_FUNCTION(caca_set_dither_algorithm) {
1257        zval *_zval;
1258        int str_len;
1259        char *str;
1260        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
1261                RETURN_FALSE;
1262        }
1263        caca_dither_t *dither;
1264        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1265        RETURN_SUCCESS(caca_set_dither_algorithm(dither, str));
1266}
1267
1268PHP_FUNCTION(caca_get_dither_algorithm_list) {
1269        zval *_zval;
1270        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1271                RETURN_FALSE;
1272        }
1273        caca_dither_t *dither;
1274        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1275
1276        char const * const *list = caca_get_dither_algorithm_list(dither);
1277        int i;
1278        array_init(return_value);       
1279        for(i = 0; list[i]; i += 2)
1280                add_assoc_string(return_value, (char*) list[i], (char*) list[i + 1], 1);
1281}
1282
1283PHP_FUNCTION(caca_get_dither_algorithm) {
1284        zval *_zval;
1285        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1286                RETURN_FALSE;
1287        }
1288        caca_dither_t *dither;
1289        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1290        RETURN_STRING((char *) caca_get_dither_algorithm(dither), 1);
1291}
1292
1293PHP_FUNCTION(caca_dither_bitmap) {
1294        zval *_zval1, *_zval2, *_zval3;
1295        long x, y, w, h = 0;
1296        zend_bool load_palette = 1;
1297        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllllrr|b", &_zval1, &x, &y, &w, &h, &_zval2, &_zval3, &load_palette) == FAILURE) {
1298                RETURN_FALSE;
1299        }
1300
1301        caca_canvas_t *canvas;
1302        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval1, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1303        caca_dither_t *dither;
1304        ZEND_FETCH_RESOURCE(dither, caca_dither_t*, &_zval2, -1, PHP_CACA_DITHER_RES_NAME, le_caca_dither);
1305
1306#ifdef HAVE_GD
1307        gdImage *img = fetch_external_resource(_zval3, "gd");
1308        if (!img) {
1309                RETURN_FALSE;
1310        }
1311
1312        void *pixels = gd_get_pixels(img);
1313        if (!pixels) {
1314                RETURN_FALSE;
1315        }
1316
1317        //load palette if image is not true color
1318        if (load_palette && !img->trueColor && gd_load_palette(img, dither) != 0) {
1319                RETURN_FALSE;
1320        }
1321
1322        caca_dither_bitmap(canvas, x, y, w, h, dither, pixels);
1323        free(pixels);
1324        RETURN_TRUE;
1325#else
1326        RETURN_FALSE;
1327#endif
1328}
1329
1330PHP_FUNCTION(caca_load_font) {
1331        char *str;
1332        long str_len;
1333        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
1334                RETURN_FALSE;
1335        }
1336        caca_font_t *font = caca_load_font(str, str_len);
1337        if (!font) {
1338                RETURN_FALSE;
1339        }
1340        ZEND_REGISTER_RESOURCE(return_value, font, le_caca_font);
1341}
1342
1343PHP_FUNCTION(caca_load_builtin_font) {
1344        char *str;
1345        long str_len;
1346        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
1347                RETURN_FALSE;
1348        }
1349        caca_font_t *font = caca_load_font(str, 0);
1350        if (!font) {
1351                RETURN_FALSE;
1352        }
1353        ZEND_REGISTER_RESOURCE(return_value, font, le_caca_font);
1354}
1355
1356PHP_FUNCTION(caca_get_font_list) {
1357        char const * const *list = caca_get_font_list();
1358        int i;
1359        array_init(return_value);       
1360        for(i = 0; list[i]; i += 1)
1361                add_next_index_string(return_value, (char*) list[i], 1);
1362}
1363
1364PHP_FUNCTION(caca_get_font_width) {
1365        zval *_zval;
1366        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1367                RETURN_FALSE;
1368        }
1369        caca_font_t *font;
1370        ZEND_FETCH_RESOURCE(font, caca_font_t*, &_zval, -1, PHP_CACA_FONT_RES_NAME, le_caca_font);
1371        RETURN_LONG(caca_get_font_width(font));
1372}
1373
1374PHP_FUNCTION(caca_get_font_height) {
1375        zval *_zval;
1376        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1377                RETURN_FALSE;
1378        }
1379        caca_font_t *font;
1380        ZEND_FETCH_RESOURCE(font, caca_font_t*, &_zval, -1, PHP_CACA_FONT_RES_NAME, le_caca_font);
1381        RETURN_LONG(caca_get_font_height(font));
1382}
1383
1384PHP_FUNCTION(caca_get_font_blocks) {
1385        zval *_zval;
1386        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1387                RETURN_FALSE;
1388        }
1389        caca_font_t *font;
1390        ZEND_FETCH_RESOURCE(font, caca_font_t*, &_zval, -1, PHP_CACA_FONT_RES_NAME, le_caca_font);
1391
1392        uint32_t const *list = caca_get_font_blocks(font);
1393
1394        int i;
1395        array_init(return_value);       
1396        for(i = 0; list[i]; i += 1)
1397                add_next_index_long(return_value, list[i]);
1398}
1399
1400PHP_FUNCTION(caca_render_canvas) {
1401        zval *_zval1, *_zval2, *_zval3;
1402        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrr", &_zval1, &_zval2, &_zval3) == FAILURE) {
1403                RETURN_FALSE;
1404        }
1405        caca_canvas_t *canvas;
1406        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval1, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1407        caca_font_t *font;
1408        ZEND_FETCH_RESOURCE(font, caca_font_t*, &_zval2, -1, PHP_CACA_FONT_RES_NAME, le_caca_font);
1409
1410#ifdef HAVE_GD
1411        gdImage *img = fetch_external_resource(_zval3, "gd");
1412        if (!img || !img->trueColor) {
1413                RETURN_FALSE;
1414        }
1415
1416        int pitch = img->sx * 4;
1417        uint8_t *buffer = malloc(pitch * img->sy);
1418        if (!buffer) {
1419                RETURN_FALSE;
1420        }
1421
1422        caca_render_canvas(canvas, font, (void *) buffer, img->sx, img->sy, pitch);
1423        int i, j;
1424        for (i = 0; i < img->sy; i++) {
1425                for (j = 0; j < img->sx; j++) {
1426                        uint8_t *src = buffer + i * pitch + j * 4;
1427                        img->tpixels[i][j] = *(src + 3) | (*(src + 2) << 8) | (*(src + 1) << 16) | (*(src + 0) << 24);
1428                }
1429        }
1430       
1431        free(buffer);
1432        RETURN_TRUE;
1433#else
1434        RETURN_FALSE;
1435#endif
1436}
1437
1438PHP_FUNCTION(caca_canvas_set_figfont) {
1439        zval *_zval;
1440        char *font;
1441        long font_len;
1442        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &font, &font_len) == FAILURE) {
1443                RETURN_FALSE;
1444        }
1445        caca_canvas_t *canvas;
1446        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1447        RETURN_SUCCESS(caca_canvas_set_figfont(canvas, font));
1448}
1449
1450PHP_FUNCTION(caca_put_figchar) {
1451        zval *_zval;
1452        long c;
1453        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &c) == FAILURE) {
1454                RETURN_FALSE;
1455        }
1456        caca_canvas_t *canvas;
1457        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1458
1459        RETURN_SUCCESS(caca_put_figchar(canvas, c));
1460}
1461
1462PHP_FUNCTION(caca_flush_figlet) {
1463        zval *_zval;
1464        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1465                RETURN_FALSE;
1466        }
1467        caca_canvas_t *canvas;
1468        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1469        RETURN_SUCCESS(caca_flush_figlet(canvas));
1470}
1471
1472PHP_FUNCTION(caca_file_open) {
1473        char *path, *mode;
1474        long path_len, mode_len;
1475        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &path, &path_len, &mode, &mode_len) == FAILURE) {
1476                RETURN_FALSE;
1477        }
1478        caca_file_t *file = caca_file_open(path, mode);
1479        if (!file) {
1480                RETURN_FALSE;
1481        }
1482        ZEND_REGISTER_RESOURCE(return_value, file, le_caca_file);
1483}
1484
1485PHP_FUNCTION(caca_file_close) {
1486        zval *_zval;
1487        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1488                RETURN_FALSE;
1489        }
1490        caca_file_t *file;
1491        ZEND_FETCH_RESOURCE(file, caca_file_t*, &_zval, -1, PHP_CACA_FILE_RES_NAME, le_caca_file);
1492
1493        int res = caca_file_close(file);
1494
1495        //Delete php resource
1496        zend_list_delete(_zval->value.lval);
1497        RETURN_SUCCESS(res);
1498}
1499
1500PHP_FUNCTION(caca_file_tell) {
1501        zval *_zval;
1502        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1503                RETURN_FALSE;
1504        }
1505        caca_file_t *file;
1506        ZEND_FETCH_RESOURCE(file, caca_file_t*, &_zval, -1, PHP_CACA_FILE_RES_NAME, le_caca_file);
1507        RETURN_LONG(caca_file_tell(file));
1508}
1509
1510PHP_FUNCTION(caca_file_read) {
1511        zval *_zval;
1512        long len;
1513        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &len) == FAILURE) {
1514                RETURN_FALSE;
1515        }
1516        caca_file_t *file;
1517        ZEND_FETCH_RESOURCE(file, caca_file_t*, &_zval, -1, PHP_CACA_FILE_RES_NAME, le_caca_file);
1518
1519        if (len < 1) {
1520                RETURN_FALSE;
1521        }
1522        char *buffer = emalloc(len);
1523        if (!buffer) {
1524                RETURN_FALSE;
1525        }
1526        caca_file_read(file, buffer, len);
1527
1528        return_value->type = IS_STRING;
1529        return_value->value.str.len = len;
1530        return_value->value.str.val = buffer;
1531}
1532
1533PHP_FUNCTION(caca_file_write) {
1534        zval *_zval;
1535        char *buf;
1536        long buf_len = 0;
1537        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &buf, &buf_len) == FAILURE) {
1538                RETURN_FALSE;
1539        }
1540        caca_file_t *file;
1541        ZEND_FETCH_RESOURCE(file, caca_file_t*, &_zval, -1, PHP_CACA_FILE_RES_NAME, le_caca_file);
1542        RETURN_LONG(caca_file_write(file, buf, buf_len));
1543}
1544
1545PHP_FUNCTION(caca_file_gets) {
1546        zval *_zval;
1547        long len = 0;
1548        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &len) == FAILURE) {
1549                RETURN_FALSE;
1550        }
1551        caca_file_t *file;
1552        ZEND_FETCH_RESOURCE(file, caca_file_t*, &_zval, -1, PHP_CACA_FILE_RES_NAME, le_caca_file);
1553
1554        if (len < 1) {
1555                RETURN_FALSE;
1556        }
1557        char *buffer = emalloc(len);
1558        if (!buffer) {
1559                RETURN_FALSE;
1560        }
1561        char *result = caca_file_gets(file, buffer, len);
1562        if (!result) {
1563                RETURN_FALSE;
1564        }
1565        return_value->type = IS_STRING;
1566        return_value->value.str.len = len;
1567        return_value->value.str.val = result;
1568}
1569
1570PHP_FUNCTION(caca_file_eof) {
1571        zval *_zval;
1572        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1573                RETURN_FALSE;
1574        }
1575        caca_file_t *file;
1576        ZEND_FETCH_RESOURCE(file, caca_file_t*, &_zval, -1, PHP_CACA_FILE_RES_NAME, le_caca_file);
1577        RETURN_BOOL(caca_file_eof(file) != 0);
1578}
1579
1580PHP_FUNCTION(caca_import_string) {
1581        zval *_zval;
1582        char *src, *format;
1583        long src_len, format_len = 0;
1584        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &_zval, &src, &src_len, &format, &format_len) == FAILURE) {
1585                RETURN_FALSE;
1586        }
1587        caca_canvas_t *canvas;
1588        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1589
1590        RETURN_LONG(caca_import_memory(canvas, src, src_len, format));
1591}
1592
1593PHP_FUNCTION(caca_import_file) {
1594        zval *_zval;
1595        char *filename, *format;
1596        long filename_len, format_len = 0;
1597        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &_zval, &filename, &filename_len, &format, &format_len) == FAILURE) {
1598                RETURN_FALSE;
1599        }
1600        caca_canvas_t *canvas;
1601        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1602
1603        RETURN_LONG(caca_import_file(canvas, filename, format));
1604}
1605
1606PHP_FUNCTION(caca_get_import_list) {
1607        char const * const *list = caca_get_import_list();
1608        int i;
1609        array_init(return_value);       
1610        for(i = 0; list[i]; i += 2)
1611                add_assoc_string(return_value, (char*) list[i], (char*) list[i + 1], 1);
1612}
1613
1614PHP_FUNCTION(caca_export_string) {
1615        zval *_zval;
1616        char *type;
1617        long type_len;
1618        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &type, &type_len) == FAILURE) {
1619                RETURN_FALSE;
1620        }
1621        caca_canvas_t *canvas;
1622        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1623
1624        void *buffer, *copy;
1625        size_t len;
1626        buffer = caca_export_memory(canvas, type, &len);
1627        copy = emalloc(len);
1628        if (!buffer || !copy) {
1629                RETURN_FALSE;
1630        }
1631        memcpy(copy, buffer, len);
1632        free(buffer);
1633
1634        return_value->type = IS_STRING;
1635        return_value->value.str.len = len;
1636        return_value->value.str.val = copy;
1637}
1638
1639PHP_FUNCTION(caca_get_export_list) {
1640        char const * const *list = caca_get_export_list();
1641        int i;
1642        array_init(return_value);       
1643        for(i = 0; list[i]; i += 2)
1644                add_assoc_string(return_value, (char*) list[i], (char*) list[i + 1], 1);
1645}
1646
1647PHP_FUNCTION(caca_create_display) {
1648        caca_canvas_t *canvas;
1649        FETCH_CANVAS(canvas);
1650
1651        caca_display_t *display = caca_create_display(canvas);
1652        if (!display) {
1653                RETURN_FALSE;
1654        }
1655        ZEND_REGISTER_RESOURCE(return_value, display, le_caca_display);
1656}
1657
1658PHP_FUNCTION(caca_create_display_with_driver) {
1659        zval *_zval;
1660        char *str;
1661        long str_len = 0;
1662        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
1663                RETURN_FALSE;
1664        }
1665        caca_canvas_t *canvas;
1666        ZEND_FETCH_RESOURCE(canvas, caca_canvas_t*, &_zval, -1, PHP_CACA_CANVAS_RES_NAME, le_caca_canvas);
1667
1668        caca_display_t *display = caca_create_display_with_driver(canvas, str);
1669        if (!display) {
1670                RETURN_FALSE;
1671        }
1672        ZEND_REGISTER_RESOURCE(return_value, display, le_caca_display);
1673}
1674
1675PHP_FUNCTION(caca_get_display_driver_list) {
1676        char const * const *list = caca_get_display_driver_list();
1677        int i;
1678        array_init(return_value);       
1679        for(i = 0; list[i]; i += 2)
1680                add_assoc_string(return_value, (char*) list[i], (char*) list[i + 1], 1);
1681}
1682
1683PHP_FUNCTION(caca_get_display_driver) {
1684        zval *_zval;
1685        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1686                RETURN_FALSE;
1687        }
1688        caca_display_t *display;
1689        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1690        RETURN_STRING((char *) caca_get_display_driver(display), 1);
1691}
1692
1693PHP_FUNCTION(caca_set_display_driver) {
1694        zval *_zval;
1695        char *str;
1696        long str_len;
1697        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
1698                RETURN_FALSE;
1699        }
1700        caca_display_t *display;
1701        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1702        RETURN_SUCESS(caca_set_display_driver(display, str));
1703}
1704
1705PHP_FUNCTION(caca_get_canvas) {
1706        zval *_zval;
1707        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &_zval) == FAILURE) {
1708                RETURN_FALSE;
1709        }
1710        caca_display_t *display;
1711        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1712        caca_canvas_t *canvas = caca_get_canvas(display);
1713        if (!canvas) {
1714                RETURN_FALSE;
1715        }
1716        ZEND_REGISTER_RESOURCE(return_value, canvas, le_caca_canvas);
1717}
1718
1719PHP_FUNCTION(caca_refresh_display) {
1720        caca_display_t *display;
1721        FETCH_DISPLAY(display);
1722        RETURN_SUCCESS(caca_refresh_display(display));
1723}
1724
1725PHP_FUNCTION(caca_set_display_time) {
1726        zval *_zval;
1727        long value = 0;
1728        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &value) == FAILURE) {
1729                RETURN_FALSE;
1730        }
1731        caca_display_t *display;
1732        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1733        RETURN_SUCCESS(caca_set_display_time(display, value));
1734}
1735
1736PHP_FUNCTION(caca_get_display_time) {
1737        caca_display_t *display;
1738        FETCH_DISPLAY(display);
1739        RETURN_LONG(caca_get_display_time(display));
1740}
1741
1742PHP_FUNCTION(caca_get_display_width) {
1743        caca_display_t *display;
1744        FETCH_DISPLAY(display);
1745        RETURN_LONG(caca_get_display_width(display));
1746}
1747
1748PHP_FUNCTION(caca_get_display_height) {
1749        caca_display_t *display;
1750        FETCH_DISPLAY(display);
1751        RETURN_LONG(caca_get_display_height(display));
1752}
1753
1754PHP_FUNCTION(caca_set_display_title) {
1755        zval *_zval;
1756        char *str;
1757        long str_len = 0;
1758        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &_zval, &str, &str_len) == FAILURE) {
1759                RETURN_FALSE;
1760        }
1761        caca_display_t *display;
1762        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1763        RETURN_SUCCESS(caca_set_display(display, str));
1764}
1765
1766PHP_FUNCTION(caca_set_mouse) {
1767        zval *_zval;
1768        long value = 0;
1769        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &value) == FAILURE) {
1770                RETURN_FALSE;
1771        }
1772        caca_display_t *display;
1773        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1774        RETURN_SUCCESS(caca_set_mouse(display, value));
1775}
1776
1777PHP_FUNCTION(caca_set_cursor) {
1778        zval *_zval;
1779        long value = 0;
1780        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &_zval, &value) == FAILURE) {
1781                RETURN_FALSE;
1782        }
1783        caca_display_t *display;
1784        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1785        RETURN_SUCCESS(caca_set_cursor(display, value));
1786}
1787
1788PHP_FUNCTION(caca_get_event) {
1789        zval *_zval = NULL;
1790        long g, aa = 0;
1791        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|l", &_zval, &g, &aa) == FAILURE) {
1792                RETURN_FALSE;
1793        }
1794        caca_display_t *display;
1795        ZEND_FETCH_RESOURCE(display, caca_display_t*, &_zval, -1, PHP_CACA_DISPLAY_RES_NAME, le_caca_display);
1796
1797        caca_event_t *event = emalloc(sizeof(caca_event_t));
1798        if (!event) {
1799                RETURN_FALSE;
1800        }
1801
1802        caca_get_event(display, g, event, aa);
1803
1804        if (caca_get_event_type(event) == CACA_EVENT_NONE) {
1805                efree(event);   
1806                RETURN_FALSE;
1807        }
1808        ZEND_REGISTER_RESOURCE(return_value, event, le_caca_event);
1809}
1810
1811PHP_FUNCTION(caca_get_mouse_x) {
1812        caca_display_t *display;
1813        FETCH_DISPLAY(display);
1814        RETURN_LONG(caca_get_mouse_x(display));
1815}
1816
1817PHP_FUNCTION(caca_get_mouse_y) {
1818        caca_display_t *display;
1819        FETCH_DISPLAY(display);
1820        RETURN_LONG(caca_get_mouse_y(display));
1821}
1822
1823PHP_FUNCTION(caca_get_event_type) {
1824        caca_event_t *event;
1825        FETCH_EVENT(event);
1826        RETURN_LONG(caca_get_event_type(event));
1827}
1828
1829PHP_FUNCTION(caca_get_event_key_ch) {
1830        caca_event_t *event;
1831        FETCH_EVENT(event);
1832        RETURN_LONG(caca_get_event_key_ch(event));
1833}
1834
1835PHP_FUNCTION(caca_get_event_mouse_button) {
1836        caca_event_t *event;
1837        FETCH_EVENT(event);
1838        RETURN_LONG(caca_get_event_mouse_button(event));
1839}
1840
1841PHP_FUNCTION(caca_get_event_mouse_x) {
1842        caca_event_t *event;
1843        FETCH_EVENT(event);
1844        RETURN_LONG(caca_get_event_mouse_x(event));
1845}
1846
1847PHP_FUNCTION(caca_get_event_mouse_y) {
1848        caca_event_t *event;
1849        FETCH_EVENT(event);
1850        RETURN_LONG(caca_get_event_mouse_y(event));
1851}
1852
1853PHP_FUNCTION(caca_get_event_resize_width) {
1854        caca_event_t *event;
1855        FETCH_EVENT(event);
1856        RETURN_LONG(caca_get_event_resize_width(event));
1857}
1858
1859PHP_FUNCTION(caca_get_event_resize_height) {
1860        caca_event_t *event;
1861        FETCH_EVENT(event);
1862        RETURN_LONG(caca_get_event_resize_height(event));
1863}
1864
Note: See TracBrowser for help on using the repository browser.