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

Last change on this file since 3262 was 3260, checked in by bsittler, 11 years ago

fix typo in PHP binding of caca_set_Attr that caused segfault on linux; also remove workaround for spurious extra-argument requirement from two of the PHP examples

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