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

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

fix impedence mismatch between libgd alpha (0 = opaque, 127 = transparent) and libcaca alpha (0 = transparent, 255 = opaque)

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