From d0a9b9a03fc7ae74ef8a64593ac6b592526ec4d5 Mon Sep 17 00:00:00 2001 From: pp Date: Wed, 19 May 2004 04:59:31 +0000 Subject: - initial import git-svn-id: https://siedziba.pl:790/svn/repos/php-imlib/trunk@7 455248ca-bdda-0310-9134-f4ebb693071a --- php_imlib.c | 3210 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3210 insertions(+) create mode 100644 php_imlib.c (limited to 'php_imlib.c') diff --git a/php_imlib.c b/php_imlib.c new file mode 100644 index 0000000..fdb60b4 --- /dev/null +++ b/php_imlib.c @@ -0,0 +1,3210 @@ +/* + +----------------------------------------------------------------------+ + | PHP version 4.0 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.02 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available at through the world-wide-web at | + | http://www.php.net/license/2_02.txt. | + | If you did not receive a copy of the PHP license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: Matt McClanahan | + +----------------------------------------------------------------------+ + */ + +#include "php.h" +#include "php_ini.h" +#include "php_imlib.h" +#include "php_globals.h" + +/* #define IMLIB_DEBUG */ + +#ifdef IMLIB_DEBUG +#define ID_PRINTF(format, args...) \ +fprintf(stderr, "php-imlib: " format "\n" , ## args); fflush(stdout) +#endif + +#if HAVE_IMLIB +#ifdef ZTS +int gd_imlib_id; +#else +zend_imlib_globals imlib_globals; +#endif + +static unsigned char third_arg_force_ref[] = { 3, BYREF_NONE, BYREF_NONE, BYREF_FORCE }; +static unsigned char third_and_fourth_arg_force_ref[] = { 4, BYREF_NONE, BYREF_NONE, BYREF_FORCE, BYREF_FORCE }; +static unsigned char second_through_fifth_arg_force_ref[] = { 5, BYREF_NONE, BYREF_FORCE, BYREF_FORCE, BYREF_FORCE, BYREF_FORCE }; +static unsigned char third_through_sixth_arg_force_ref[] = { 6, BYREF_NONE, BYREF_NONE, BYREF_FORCE, BYREF_FORCE, BYREF_FORCE, BYREF_FORCE }; +static int le_imlib_cr; +static int le_imlib_font; +static int le_imlib_img; +static int le_imlib_poly; +static int le_imlib_filter; +static int le_imlib_cm; +#if HAVE_LIBT1 +static int le_ps_font, le_ps_enc; +#endif + +function_entry imlib_functions[] = { + PHP_FE(imlib_add_color_to_color_range,NULL) + PHP_FE(imlib_blend_image_onto_image,NULL) + PHP_FE(imlib_clone_image,NULL) + PHP_FE(imlib_create_color_range,NULL) + PHP_FE(imlib_create_color_modifier,NULL) + PHP_FE(imlib_create_cropped_image,NULL) + PHP_FE(imlib_create_cropped_scaled_image,NULL) + PHP_FE(imlib_create_image,NULL) + PHP_FE(imlib_create_rotated_image,NULL) + PHP_FE(imlib_create_scaled_image,NULL) + PHP_FE(imlib_dump_image,second_arg_force_ref) + PHP_FE(imlib_free_color_range,NULL) + PHP_FE(imlib_free_color_modifier,NULL) + PHP_FE(imlib_free_font,NULL) + PHP_FE(imlib_free_image,NULL) + PHP_FE(imlib_get_text_size,third_and_fourth_arg_force_ref) + PHP_FE(imlib_get_text_advance,third_and_fourth_arg_force_ref) + PHP_FE(imlib_image_blur,NULL) + PHP_FE(imlib_image_draw_ellipse,NULL) + PHP_FE(imlib_image_draw_line,NULL) + PHP_FE(imlib_image_draw_polygon,NULL) + PHP_FE(imlib_image_draw_rectangle,NULL) + PHP_FE(imlib_image_fill_color_range_rectangle,NULL) + PHP_FE(imlib_image_fill_ellipse,NULL) + PHP_FE(imlib_image_fill_polygon,NULL) + PHP_FE(imlib_image_fill_rectangle,NULL) + PHP_FE(imlib_image_flip_horizontal,NULL) + PHP_FE(imlib_image_flip_vertical,NULL) + PHP_FE(imlib_image_flip_diagonal,NULL) + PHP_FE(imlib_image_orientate,NULL) + PHP_FE(imlib_image_format,NULL) + PHP_FE(imlib_image_get_filename,NULL) + PHP_FE(imlib_image_get_height,NULL) + PHP_FE(imlib_image_get_width,NULL) + PHP_FE(imlib_image_has_alpha,NULL) + PHP_FE(imlib_image_modify_alpha,NULL) + PHP_FE(imlib_image_sharpen,NULL) + PHP_FE(imlib_image_set_format,NULL) + PHP_FE(imlib_image_tile_horizontal,NULL) + PHP_FE(imlib_image_tile_vertical,NULL) + PHP_FE(imlib_image_tile,NULL) + PHP_FE(imlib_list_fonts,NULL) + PHP_FE(imlib_load_font,NULL) + PHP_FE(imlib_load_image,second_arg_force_ref) + PHP_FALIAS(imlib_load_image_with_error_return,imlib_load_image,second_arg_force_ref) + PHP_FE(imlib_polygon_add_point,NULL) + PHP_FE(imlib_polygon_contains_point,NULL) + PHP_FE(imlib_polygon_free,NULL) + PHP_FE(imlib_polygon_get_bounds,second_through_fifth_arg_force_ref) + PHP_FE(imlib_polygon_new,NULL) + PHP_FE(imlib_save_image,third_arg_force_ref) + PHP_FALIAS(imlib_save_image_with_error_return,imlib_save_image,third_arg_force_ref) + PHP_FE(imlib_text_draw,NULL) + PHP_FE(imlib_get_cache_size,NULL) + PHP_FE(imlib_set_cache_size,NULL) + PHP_FE(imlib_create_filter,NULL) + PHP_FE(imlib_free_filter,NULL) + PHP_FE(imlib_image_filter,NULL) + PHP_FE(imlib_filter_set,NULL) + PHP_FE(imlib_filter_set_alpha,NULL) + PHP_FE(imlib_filter_set_red,NULL) + PHP_FE(imlib_filter_set_green,NULL) + PHP_FE(imlib_filter_set_blue,NULL) + PHP_FE(imlib_filter_constants,NULL) + PHP_FE(imlib_filter_divisors,NULL) + PHP_FE(imlib_apply_filter,NULL) + PHP_FE(imlib_modify_color_modifier_gamma,NULL) + PHP_FE(imlib_modify_color_modifier_brightness,NULL) + PHP_FE(imlib_modify_color_modifier_contrast,NULL) + PHP_FE(imlib_reset_color_modifier,NULL) + PHP_FE(imlib_apply_color_modifier,NULL) + PHP_FE(imlib_set_color_modifier,NULL) + PHP_FE(imlib_get_color_modifier,third_through_sixth_arg_force_ref) + PHP_FE(imlib_psloadfont,NULL) + PHP_FE(imlib_psfreefont,NULL) + PHP_FE(imlib_psencodefont,NULL) + PHP_FE(imlib_psextendfont,NULL) + PHP_FE(imlib_psslantfont,NULL) + PHP_FE(imlib_pstext,NULL) + PHP_FE(imlib_psbbox,NULL) + + {NULL, NULL, NULL} +}; + +ZEND_DECLARE_MODULE_GLOBALS(imlib) + +PHP_INI_BEGIN() +STD_PHP_INI_ENTRY("imlib.font_path","/usr/local/share/fonts",PHP_INI_SYSTEM|PHP_INI_PERDIR,OnUpdateString,font_path,zend_imlib_globals,imlib_globals) +STD_PHP_INI_ENTRY("imlib.min_cache_size","0",PHP_INI_SYSTEM,OnUpdateInt,min_cache_size,zend_imlib_globals,imlib_globals) +STD_PHP_INI_ENTRY("imlib.max_cache_size","4194304",PHP_INI_SYSTEM,OnUpdateInt,max_cache_size,zend_imlib_globals,imlib_globals) +STD_PHP_INI_ENTRY("imlib.cache_size","0",PHP_INI_SYSTEM|PHP_INI_PERDIR,OnUpdateInt,cache_size,zend_imlib_globals,imlib_globals) +PHP_INI_ENTRY("imlib.font_cache_size","524288",PHP_INI_SYSTEM,OnUpdateFontCacheSize) +STD_PHP_INI_ENTRY("imlib.filter_path",PHP_IMLIB_FILTER_PATH,PHP_INI_SYSTEM,OnUpdateString,filter_path,zend_imlib_globals,imlib_globals) +PHP_INI_END() + +zend_module_entry imlib_module_entry = { + STANDARD_MODULE_HEADER, + "imlib", + imlib_functions, + PHP_MINIT(imlib), + PHP_MSHUTDOWN(imlib), + PHP_RINIT(imlib), + PHP_RSHUTDOWN(imlib), + PHP_MINFO(imlib), + NO_VERSION_YET, + STANDARD_MODULE_PROPERTIES +}; + +PHP_INI_MH(OnUpdateFontCacheSize) +{ + int size; + if (sscanf(new_value,"%d",&size)==1) + { + imlib_set_font_cache_size(size); + return SUCCESS; + } + else + { + return FAILURE; + } +} + +static void _php_imlib_free_cm(PHP_Imlib_Color_Modifier mod) +{ + imlib_context_set_color_modifier(mod->cm); + imlib_free_color_modifier(); + efree(mod); +} + +static void _php_imlib_free_filter(Imlib_Filter fil) +{ + imlib_context_set_filter(fil); + imlib_free_filter(); +} + +static void _php_imlib_free_cr(Imlib_Color_Range cr) +{ + imlib_context_set_color_range(cr); + imlib_free_color_range(); +} + +static void _php_imlib_free_font(PHP_Imlib_Font fn) +{ + imlib_context_set_font(fn->font); + imlib_free_font(); + efree(fn); +} + +static void _php_imlib_free_img(Imlib_Image im) +{ + imlib_context_set_image(im); + imlib_free_image(); +} + +static void _php_imlib_free_poly(ImlibPolygon poly) +{ + imlib_polygon_free(poly); +} + +void _php_imlib_set_cache_size(int size) +{ + IMLIBLS_FETCH(); + if (size>IMLIBG(max_cache_size)) { + size=IMLIBG(max_cache_size); + } + if (sizefilename=strdup(file); + ptr->handle=lt_dlopenext(file); + if (!ptr->handle) goto error; +#ifdef IMLIB_DEBUG + ID_PRINTF("Library loaded, handle=%p. Looking for entry points...",ptr->handle); +#endif + ptr->init=lt_dlsym(ptr->handle,"php_filter_init"); + ptr->deinit=lt_dlsym(ptr->handle,"php_filter_deinit"); + ptr->exec=lt_dlsym(ptr->handle,"php_filter_exec"); + ptr->getfiltercount=lt_dlsym(ptr->handle,"php_filter_getfiltercount"); + ptr->getfilternames=lt_dlsym(ptr->handle,"php_filter_getfilternames"); + ptr->getextinfo=lt_dlsym(ptr->handle,"php_filter_getextinfo"); + ptr->getparams=lt_dlsym(ptr->handle,"php_filter_getparams"); + +#ifdef IMLIB_DEBUG + ID_PRINTF("Function pointers: init=%p, deinit=%p, exec=%p, count=%p, names=%p",ptr->init,ptr->deinit,ptr->exec,ptr->getfiltercount,ptr->getfilternames); +#endif + if (!ptr->getfiltercount || !ptr->getfilternames || !ptr->exec) goto error; +#ifdef IMLIB_DEBUG + ID_PRINTF("Getting filter info..."); +#endif + if (ptr->init) + { + initrv=ptr->init(); + if (initrv==FAILURE) goto error; + } + ptr->filters=ptr->getfiltercount(); + ptr->names=malloc(ptr->filters*sizeof(char*)); + if (!ptr->names) goto error; + ptr->getfilternames(ptr->names); + ptr->next=NULL; + return ptr; +error: +#ifdef IMLIB_DEBUG + ID_PRINTF("Error loading library!"); +#endif + if (ptr) + { + if (ptr->handle) + { + if (ptr->deinit) + { + if (initrv==SUCCESS) ptr->deinit(); + } + lt_dlclose(ptr->handle); + } + if (ptr->names) free(ptr->names); + if (ptr->filename) free(ptr->filename); + free(ptr); + } + return NULL; +} + +void _php_imlib_unload_filter(struct php_imlib_filter* ptr) +{ + if (ptr==NULL) return; + if (ptr->deinit) ptr->deinit(); + if (ptr->names) free(ptr->names); + if (ptr->filename) free(ptr->filename); + lt_dlclose(ptr->handle); + free(ptr); +} + +void _php_imlib_unload_filters() +{ + struct php_imlib_filter* f_ptr; + + IMLIBLS_FETCH(); + f_ptr=IMLIBG(filters); + while (f_ptr!=NULL) + { + struct php_imlib_filter* f_ptr_next; + f_ptr_next=f_ptr->next; + _php_imlib_unload_filter(f_ptr); + f_ptr=f_ptr_next; + } + IMLIBG(filters)=NULL; + + lt_dlexit(); +} + +void _php_imlib_load_filters() +{ + struct php_imlib_filter* f_ptr; + char* path; + DIR* dirp=NULL; + struct dirent *dp; + char** names=NULL; + int names_size,names_index,i; + int ltinitrv=0; + + IMLIBLS_FETCH(); + f_ptr=IMLIBG(filters); + if (f_ptr!=NULL) return; +#ifdef IMLIB_DEBUG + ID_PRINTF("Initializing libltdl..."); +#endif + if ((ltinitrv=lt_dlinit())>0) goto error; + +#ifdef IMLIB_DEBUG + ID_PRINTF("Loading filters..."); +#endif + path=IMLIBG(filter_path); + lt_dladdsearchdir(path); +#ifdef IMLIB_DEBUG + ID_PRINTF("Opening directory %s...",path); +#endif + if ((dirp=opendir(path))==NULL) goto error; + + names_size=20; + names_index=0; + if ((names=malloc(names_size*sizeof(char*)))==NULL) goto error; + +#ifdef IMLIB_DEBUG + ID_PRINTF("Scanning directory..."); +#endif + errno=0; + while ((dp=readdir(dirp))!=NULL) + { + char* name; + + if ((name=strdup(dp->d_name))==NULL) goto error; + if ((strcmp(name, ".")) && (strcmp(name, ".."))) + { + char* ext; + + ext=strchr(name,'.'); + if (ext) + { + *ext='\0'; + for (i=0;i0) + { + IMLIBG(filters)=f_ptr=malloc(sizeof(struct php_imlib_filter)); + + for (i=0;inext=_php_imlib_load_filter(names[i]))!=NULL) + f_ptr=f_ptr->next; + } + IMLIBG(filters)=IMLIBG(filters)->next; + } + goto cleanup; + +error: +#ifdef IMLIB_DEBUG + ID_PRINTF("Error loading filters!"); +#endif + _php_imlib_unload_filters(); +cleanup: + if (names!=NULL) + { + for (i=0;ifilters;i++) + { + if (strcmp(f_ptr->names[i],filter_name)==0) + { + return f_ptr; + } + } + f_ptr=f_ptr->next; + } + return NULL; +} + +Imlib_Image _php_imlib_get_image(zval** im_resource) +{ + Imlib_Image im; + TSRMLS_FETCH(); + MY_ZEND_FETCH_RESOURCE(im, Imlib_Image, im_resource, -1, "Imlib Image", le_imlib_img); + return im; +} + +Imlib_Filter _php_imlib_get_filter(zval** fil_resource) +{ + Imlib_Filter fil; + TSRMLS_FETCH(); + MY_ZEND_FETCH_RESOURCE(fil, Imlib_Filter, fil_resource, -1, "Imlib Filter", le_imlib_filter); + return fil; +} + +void _php_imlib_color_modifier_synch(PHP_Imlib_Color_Modifier cm) +{ + if ((cm->modified)&&(!cm->valid)) + { + fprintf(stderr,"Panic!! Color Modifier in invalid state!"); + return; + } + imlib_context_set_color_modifier(cm->cm); + if (cm->modified) + { + imlib_set_color_modifier_tables(cm->channels[0],cm->channels[1],cm->channels[2],cm->channels[3]); + cm->modified=0; + } + if (!cm->valid) + { + imlib_get_color_modifier_tables(cm->channels[0],cm->channels[1],cm->channels[2],cm->channels[3]); + cm->valid=1; + } + imlib_context_set_color_modifier(NULL); +} + +Imlib_Color_Modifier _php_imlib_get_cm(zval** cm_resource) +{ + PHP_Imlib_Color_Modifier cm; + TSRMLS_FETCH(); + MY_ZEND_FETCH_RESOURCE(cm, Imlib_Color_Modifier, cm_resource, -1, "Imlib Color Modifier", le_imlib_cm); + if (cm->modified) _php_imlib_color_modifier_synch(cm); + cm->valid=0; + return cm->cm; +} + +Imlib_Font _php_imlib_get_font(zval** font_resource) +{ + PHP_Imlib_Font php_font; + TSRMLS_FETCH(); + MY_ZEND_FETCH_RESOURCE(php_font, PHP_Imlib_Font, font_resource, -1, "Imlib Font", le_imlib_font); + return php_font->font; +} + +Imlib_TTF_Encoding _php_imlib_get_encoding(zval** font_resource) +{ + PHP_Imlib_Font php_font; + TSRMLS_FETCH(); + MY_ZEND_FETCH_RESOURCE(php_font, PHP_Imlib_Font, font_resource, -1, "Imlib Font", le_imlib_font); + return php_font->enc; +} + +Imlib_Color_Range _php_imlib_get_cr(zval** cr_resource) +{ + Imlib_Color_Range cr; + TSRMLS_FETCH(); + MY_ZEND_FETCH_RESOURCE(cr, Imlib_Color_Range, cr_resource, -1, "Imlib Color Range", le_imlib_cr); + return cr; +} + +ImlibPolygon _php_imlib_get_poly(zval** poly_resource) +{ + ImlibPolygon poly; + TSRMLS_FETCH(); + MY_ZEND_FETCH_RESOURCE(poly, ImlibPolygon, poly_resource, -1, "Imlib Polygon", le_imlib_poly); + return poly; +} + +#if HAVE_LIBT1 + +/* {{{ _php_imlib_free_ps_font + */ +void _php_imlib_free_ps_font(zend_rsrc_list_entry *rsrc TSRMLS_DC) +{ + int *font = (int *)rsrc->ptr; + + T1_DeleteFont(*font); + efree(font); +} +/* }}} */ + +/* {{{ _php_imlib_free_ps_enc + */ +void _php_imlib_free_ps_enc(zend_rsrc_list_entry *rsrc TSRMLS_DC) +{ + char **enc = (char **)rsrc->ptr; + + T1_DeleteEncoding(enc); +} +/* }}} */ + +#endif + + +#ifdef COMPILE_DL_IMLIB +ZEND_GET_MODULE(imlib) +#endif + +PHP_MINIT_FUNCTION(imlib) +{ + IMLIBLS_FETCH(); + IMLIBG(filters)=NULL; + le_imlib_cr = register_list_destructors(_php_imlib_free_cr,NULL); + le_imlib_font = register_list_destructors(_php_imlib_free_font,NULL); + le_imlib_img = register_list_destructors(_php_imlib_free_img,NULL); + le_imlib_poly = register_list_destructors(_php_imlib_free_poly,NULL); + le_imlib_filter = register_list_destructors(_php_imlib_free_filter,NULL); + le_imlib_cm = register_list_destructors(_php_imlib_free_cm,NULL); +#if HAVE_LIBT1 + T1_SetBitmapPad(8); + T1_InitLib(NO_LOGFILE|IGNORE_CONFIGFILE|IGNORE_FONTDATABASE); + T1_SetLogLevel(T1LOG_DEBUG); + le_ps_font = zend_register_list_destructors_ex(_php_imlib_free_ps_font, NULL, "imlib PS font", module_number); + le_ps_enc = zend_register_list_destructors_ex(_php_imlib_free_ps_enc, NULL, "imlib PS encoding", module_number); +#endif + + REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_RIGHT", IMLIB_TEXT_TO_RIGHT, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_LEFT", IMLIB_TEXT_TO_LEFT, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_DOWN", IMLIB_TEXT_TO_DOWN, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_UP", IMLIB_TEXT_TO_UP, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_ANGLE", IMLIB_TEXT_TO_ANGLE, CONST_CS|CONST_PERSISTENT); + + REGISTER_LONG_CONSTANT("IMLIB_TTF_ENCODING_ISO_8859_1", IMLIB_TTF_ENCODING_ISO_8859_1, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TTF_ENCODING_ISO_8859_2", IMLIB_TTF_ENCODING_ISO_8859_2, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TTF_ENCODING_ISO_8859_3", IMLIB_TTF_ENCODING_ISO_8859_3, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TTF_ENCODING_ISO_8859_4", IMLIB_TTF_ENCODING_ISO_8859_4, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_TTF_ENCODING_ISO_8859_5", IMLIB_TTF_ENCODING_ISO_8859_5, CONST_CS|CONST_PERSISTENT); + + REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_RED", 1, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_GREEN", 2, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_BLUE", 4, CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_ALPHA", 8, CONST_CS|CONST_PERSISTENT); + + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_NONE", IMLIB_LOAD_ERROR_NONE, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST", + IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY", + IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ", + IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT", + IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_TOO_LONG", + IMLIB_LOAD_ERROR_PATH_TOO_LONG, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT", + IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY", + IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE", + IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS", + IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_OUT_OF_MEMORY", + IMLIB_LOAD_ERROR_OUT_OF_MEMORY, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS", + IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE", + IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE", + IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE, + CONST_CS|CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_UNKNOWN", IMLIB_LOAD_ERROR_UNKNOWN, + CONST_CS|CONST_PERSISTENT); + + REGISTER_INI_ENTRIES(); + + return SUCCESS; +} + +PHP_MSHUTDOWN_FUNCTION(imlib) +{ + _php_imlib_unload_filters(); + + UNREGISTER_INI_ENTRIES(); + + return SUCCESS; +} + +PHP_RINIT_FUNCTION(imlib) +{ + char **font_list; + char *pathbuf, *ptr, *end; + int i, font_count; + IMLIBLS_FETCH(); + + /* Set default cache size */ + _php_imlib_set_cache_size(IMLIBG(cache_size)); + font_list = imlib_list_font_path(&font_count); + if (!font_count) { + IMLIBG(saved_path) = NULL; + } else { + /* Save the current path where we can retrieve it later. */ + IMLIBG(saved_path) = (char **) emalloc(sizeof(char *) * (font_count + 1)); + for (i = 0; i < font_count; i++) { + IMLIBG(saved_path)[i] = estrdup(font_list[i]); + } + IMLIBG(saved_path)[i] = NULL; + + /* Now clear the imlib path... */ + for (i = 0; i < font_count; i++) { + imlib_remove_path_from_font_path(IMLIBG(saved_path)[i]); + } + } + + if (!IMLIBG(font_path)) { + return SUCCESS; + } + + /* And repopulate it with the ini-specified default. */ + ptr = pathbuf = estrdup(IMLIBG(font_path)); + + while (ptr && *ptr) { + end = strchr(ptr, ':'); + + if (end != NULL) { + *end = '\0'; + end++; + } + imlib_add_path_to_font_path(ptr); + ptr = end; + } + efree(pathbuf); + + return SUCCESS; +} + +PHP_RSHUTDOWN_FUNCTION(imlib) +{ + char **font_list; + int i, font_count; + IMLIBLS_FETCH(); + + /* Restore cache size */ + _php_imlib_set_cache_size(0); + /* Retrieve the current path and clear it out. */ + font_list = imlib_list_font_path(&font_count); + for (i = 0; i < font_count; i++) { + imlib_remove_path_from_font_path(font_list[i]); + } + + /* Restore the saved font path. */ + if (!IMLIBG(saved_path)) { + return SUCCESS; + } + for (i = 0; IMLIBG(saved_path)[i] != NULL; i++) { + imlib_add_path_to_font_path(IMLIBG(saved_path)[i]); + efree(IMLIBG(saved_path)[i]); + } + + efree(IMLIBG(saved_path)); + return SUCCESS; +} + +PHP_MINFO_FUNCTION(imlib) +{ + struct php_imlib_filter* f_ptr; + int i; + + _php_imlib_load_filters(); + IMLIBLS_FETCH(); + f_ptr=IMLIBG(filters); + + DISPLAY_INI_ENTRIES(); + +#ifdef HAVE_LIBT1 + php_info_print_table_start(); + php_info_print_table_row(2, "T1Lib Support", "enabled"); + php_info_print_table_end(); +#endif + + while (f_ptr!=NULL) + { + char* extinfo[3] = {NULL, NULL, NULL}; + php_info_print_table_start(); + if (f_ptr->getextinfo) f_ptr->getextinfo(extinfo); + if (extinfo[0]) + { + char* infostr; + f_ptr->getextinfo(extinfo); + infostr=emalloc((strlen(extinfo[0])+strlen(f_ptr->filename)+4)*sizeof(char)); + strcpy(infostr,extinfo[0]); + strcat(infostr," ("); + strcat(infostr,f_ptr->filename); + strcat(infostr,")"); + php_info_print_table_row(2, "Filter name", infostr); + efree(infostr); + } + else + { + php_info_print_table_row(2, "Filter name", f_ptr->filename); + } + if (extinfo[1]) php_info_print_table_row(2,"Description",extinfo[1]); + if (extinfo[2]) php_info_print_table_row(2,"Author",extinfo[2]); + + { + char* filters; + filters=estrdup(""); + for (i=0;ifilters;i++) + { + int newlen; + char* params=NULL; + if (f_ptr->getparams) params=f_ptr->getparams(f_ptr->names[i]); + newlen=strlen(filters)+strlen(f_ptr->names[i])+2; + if (params) newlen+=strlen(params)+3; + filters=erealloc(filters,newlen*sizeof(char)); + if (filters) + { + strcat(filters,f_ptr->names[i]); + if (params) + { + strcat(filters," ("); + strcat(filters,params); + strcat(filters,")"); + } + strcat(filters,"\n"); + } + } + php_info_print_table_row(2,"Filters",filters); + efree(filters); + } + f_ptr=f_ptr->next; + php_info_print_table_end(); + } +} + +static void _php_convert_four_longs(zval **zone, zval **ztwo, zval **zthree, + zval **zfour, int *one, int *two, + int *three, int *four) +{ + convert_to_long_ex(zone); + convert_to_long_ex(ztwo); + convert_to_long_ex(zthree); + convert_to_long_ex(zfour); + *one = Z_LVAL_PP(zone); + *two = Z_LVAL_PP(ztwo); + *three = Z_LVAL_PP(zthree); + *four = Z_LVAL_PP(zfour); +} + +static int _php_handle_cliprect_array(zval **dbox, char *func_name, + int *x, int *y, int *w, int *h) +{ + zval **element, ***box_coords; + int i,arrcount; + HashTable *box; + + box = HASH_OF(*dbox); + if (!box) { + php_error(E_WARNING, "Wrong datatype in call to %s, need array",func_name); + return 0; + } + + arrcount = zend_hash_num_elements(box); + if (arrcount != 4) { + php_error(E_WARNING, "Wrong number of array elements in call to %s, need four (x,y,w,h)", + func_name); + return 0; + } + + box_coords = (zval ***)emalloc(arrcount * sizeof(zval **)); + + for (i = 0; i < arrcount; i++) + { + if (zend_hash_index_find(box, i, (void **)&element) == SUCCESS) + { + convert_to_long_ex(element); + box_coords[i] = element; + } + } + *x = Z_LVAL_PP(box_coords[0]); + *y = Z_LVAL_PP(box_coords[1]); + *w = Z_LVAL_PP(box_coords[2]); + *h = Z_LVAL_PP(box_coords[3]); + + efree(box_coords); + return 1; +} + +static int _php_handle_imlib_error(INTERNAL_FUNCTION_PARAMETERS, + Imlib_Load_Error err, const char *img) +{ + int errnum; + + switch (err) + { + case IMLIB_LOAD_ERROR_NONE: + errnum = 0; + break; + case IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST: + php_error(E_WARNING, "%s - File does not exist", img); + errnum = 1; + break; + case IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY: + php_error(E_WARNING, "%s - Directory specified for image filename", img); + errnum = 2; + break; + case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ: + php_error(E_WARNING, "%s - No read access to directory", img); + errnum = 3; + break; + case IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT: + php_error(E_WARNING, "%s - No Imlib2 loader for that file format", img); + errnum = 4; + break; + case IMLIB_LOAD_ERROR_PATH_TOO_LONG: + php_error(E_WARNING, "%s - Path specified is too long", img); + errnum = 5; + break; + case IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT: + php_error(E_WARNING, "%s - Path component does not exist", img); + errnum = 6; + break; + case IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY: + php_error(E_WARNING, "%s - Path component is not a directory", img); + errnum = 7; + break; + case IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE: + php_error(E_WARNING, "%s - Path points outside address space", img); + errnum = 8; + break; + case IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS: + php_error(E_WARNING, "%s - Too many levels of symbolic links", img); + errnum = 9; + break; + case IMLIB_LOAD_ERROR_OUT_OF_MEMORY: + php_error(E_WARNING, "While loading %s - Out of memory", img); + errnum = 10; + break; + case IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS: + php_error(E_WARNING, "While loading %s - Out of file descriptors", img); + errnum = 11; + break; + case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE: + php_error(E_WARNING, "%s - Cannot write to directory", img); + errnum = 12; + break; + case IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE: + php_error(E_WARNING, "%s - Cannot write - out of disk space", img); + errnum = 13; + break; + case IMLIB_LOAD_ERROR_UNKNOWN: + default: + php_error(E_WARNING, "While loading %s - Unknown error.", img); + errnum = 14; + } + return errnum; +} + +static void _php_imlib_draw_something(INTERNAL_FUNCTION_PARAMETERS, void (*func)(), char *func_name) +{ + zval **img, **d1, **d2, **d3, **d4, **dr, **dg, **db, **da, **dbox; + int x,y,w,h,r,g,b,a,cx,cy,cw,ch,argc; + Imlib_Image im; + IMLIBLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + if (argc < 9 || argc > 10 || zend_get_parameters_ex(argc, &img, &d1, &d2, &d3, &d4, &dr, &dg, &db, &da, &dbox) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + _php_convert_four_longs(d1,d2,d3,d4,&x,&y,&w,&h); + _php_convert_four_longs(dr,dg,db,da,&r,&g,&b,&a); + + imlib_context_set_image(im); + imlib_context_set_color(r,g,b,a); + + /* FIXME: This should take an optional antialias option, with on as default */ + imlib_context_set_anti_alias(0); + + if (argc > 9) + { + if (!_php_handle_cliprect_array(dbox, func_name, &cx,&cy,&cw,&ch)) + RETURN_FALSE; + imlib_context_set_cliprect(cx,cy,cw,ch); + } + + (*func)(x,y,w,h); + imlib_context_set_cliprect(0,0,0,0); + RETURN_TRUE; +} + +static void _php_imlib_single_arg(INTERNAL_FUNCTION_PARAMETERS, void (*func)()) +{ + zval **img; + Imlib_Image im; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(im); + (*func)(); +} + +/* We wrap imlib_image_draw_line, because it doesn't return a void like all + the other drawing functions do. So, since we don't care about + Imlib_Updates, we're going to return our own void. Nyeh. */ +static void _php_wrap_draw_line(int x1, int y1, int x2, int y2) +{ + imlib_image_draw_line(x1,y1,x2,y2,0); +} + +/* {{{ proto void imlib_add_color_to_color_range(int cr, int x, int r, int g, int b, int a) + Add a color to a color range at a specified distance from the previous color in the range. A distance of 0 centers it */ +PHP_FUNCTION(imlib_add_color_to_color_range) +{ + zval **crange, **cx, **cr, **cg, **cb, **ca; + int x,r,g,b,a; + Imlib_Color_Range range; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 6 || zend_get_parameters_ex(6, &crange, &cx, &cr, &cg, &cb, &ca) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(range, Imlib_Color_Range, crange, -1, "Imlib Color Range", le_imlib_cr); + + convert_to_long_ex(cx); + x = Z_LVAL_PP(cx); + _php_convert_four_longs(cr,cg,cb,ca,&r,&g,&b,&a); + + imlib_context_set_color_range(range); + imlib_context_set_color(r,g,b,a); + imlib_add_color_to_color_range(x); +} +/* }}} */ + + +/* {{{ proto void imlib_blend_image_onto_image(int dstimg, int srcimg, int malpha, int srcx, int srcy, int srcw, int srch, int dstx, int dsty, int dstw, int dsth, char dither, char blend, char alias) + Blend a rectangular area from an image onto an area of another image, scaling as necessary */ +PHP_FUNCTION(imlib_blend_image_onto_image) +{ + zval **dstimg, **srcimg, **malpha, **srcx, **srcy, **srcw, **srch, **dstx, **dsty, **dstw, **dsth, **dither, **blend, **alias; + Imlib_Image dst,src; + int sx,sy,sw,sh,dx,dy,dw,dh; + int calias, calpha, cblend, cdither; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 14 || zend_get_parameters_ex(14, &dstimg, &srcimg, &malpha, &srcx, &srcy, &srcw, &srch, &dstx, &dsty, &dstw, &dsth, &dither, &blend, &alias) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(src, Imlib_Image, srcimg, -1, "Imlib Image", le_imlib_img); + ZEND_FETCH_RESOURCE(dst, Imlib_Image, dstimg, -1, "Imlib Image", le_imlib_img); + + _php_convert_four_longs(srcx,srcy,srcw,srch,&sx,&sy,&sw,&sh); + _php_convert_four_longs(dstx,dsty,dstw,dsth,&dx,&dy,&dw,&dh); + + convert_to_long_ex(malpha); + convert_to_long_ex(dither); + convert_to_long_ex(blend); + convert_to_long_ex(alias); + calpha = Z_LVAL_PP(malpha); + cdither = Z_LVAL_PP(dither); + cblend = Z_LVAL_PP(blend); + calias = Z_LVAL_PP(alias); + + imlib_context_set_image(dst); + imlib_context_set_anti_alias(calias); + imlib_context_set_dither(cdither); + imlib_context_set_blend(cblend); + imlib_context_set_angle(0); + imlib_blend_image_onto_image(src,calpha,sx,sy,sw,sh,dx,dy,dw,dh); +} +/* }}} */ + + +/* {{{ proto int imlib_clone_image(int img) + Duplicate an image */ +PHP_FUNCTION(imlib_clone_image) +{ + zval **img; + Imlib_Image src,dst; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(src, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(src); + dst = imlib_clone_image(); + + if (dst) ZEND_REGISTER_RESOURCE(return_value, dst, le_imlib_img); +} +/* }}} */ + + +/* {{{ proto int imlib_create_color_range() + Create a new color range */ +PHP_FUNCTION(imlib_create_color_range) +{ + Imlib_Color_Range cr; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + cr = imlib_create_color_range(); + + if (cr) ZEND_REGISTER_RESOURCE(return_value, cr, le_imlib_cr); +} +/* }}} */ + + +/* {{{ proto int imlib_create_color_modifier(void) + Create a new color modifier */ +PHP_FUNCTION(imlib_create_color_modifier) +{ + PHP_Imlib_Color_Modifier cm; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + cm=(PHP_Imlib_Color_Modifier)emalloc(sizeof(PHP_Imlib_Color_Modifier_struct)); + if (!cm) RETURN_FALSE; + + cm->cm = imlib_create_color_modifier(); + cm->modified=0; + cm->valid=0; + + if (cm->cm) ZEND_REGISTER_RESOURCE(return_value, cm, le_imlib_cm); +} +/* }}} */ + +/* {{{ proto int imlib_create_cropped_image(int img, int srcx, int srcy, int srcw, int srch) + Create an image from a cropped region of another image */ +PHP_FUNCTION(imlib_create_cropped_image) +{ + zval **img, **srcx, **srcy, **srcw, **srch; + int sx,sy,sw,sh; + Imlib_Image src,dst; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 5 || zend_get_parameters_ex(5, &img, &srcx, &srcy, &srcw, &srch) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(src, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + _php_convert_four_longs(srcx,srcy,srcw,srch,&sx,&sy,&sw,&sh); + + imlib_context_set_image(src); + dst = imlib_create_cropped_image(sx,sy,sw,sh); + + if (dst) ZEND_REGISTER_RESOURCE(return_value, dst, le_imlib_img); +} +/* }}} */ + + +/* {{{ proto int imlib_create_cropped_scaled_image(int img, int srcx, int srcy, int srcw, int srch, int dstw, int dsth) + Create a scaled image from a cropped region of another image */ +PHP_FUNCTION(imlib_create_cropped_scaled_image) +{ + zval **img, **srcx, **srcy, **srcw, **srch, **dstw, **dsth; + int sx,sy,sw,sh,dw,dh; + Imlib_Image src,dst; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 7 || zend_get_parameters_ex(7, &img, &srcx, &srcy, &srcw, + &srch, &dstw, &dsth) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(src, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + _php_convert_four_longs(srcx,srcy,srcw,srch,&sx,&sy,&sw,&sh); + convert_to_long_ex(dstw); + convert_to_long_ex(dsth); + dw = Z_LVAL_PP(dstw); + dh = Z_LVAL_PP(dsth); + + imlib_context_set_image(src); + dst = imlib_create_cropped_scaled_image(sx,sy, sw,sh, dw,dh); + + if (dst) ZEND_REGISTER_RESOURCE(return_value, dst, le_imlib_img); +} +/* }}} */ + + +/* {{{ proto int imlib_create_image(int w, int h) + Create a new image with the specified dimensions */ +PHP_FUNCTION(imlib_create_image) +{ + zval **nx, **ny; + Imlib_Image im; + int x,y; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &nx, &ny) == FAILURE) { + WRONG_PARAM_COUNT; + } + + convert_to_long_ex(nx); + convert_to_long_ex(ny); + x = Z_LVAL_PP(nx); + y = Z_LVAL_PP(ny); + + im = imlib_create_image(x,y); + + if (im) { + imlib_context_set_image(im); + memset(imlib_image_get_data(), '\0', x * y * sizeof(DATA32)); + + ZEND_REGISTER_RESOURCE(return_value, im, le_imlib_img); + } +} +/* }}} */ + + +/* {{{ proto int imlib_create_rotated_image(int srcimg, int degrees[, int radians]) + Create a rotated copy of an image. If radians is specified, degrees will be ignored. */ +PHP_FUNCTION(imlib_create_rotated_image) +{ + zval **srcimg, **cangle, **crads; + double angle, radians, pi = 3.141592654; + int argc; + Imlib_Image src, dst; + IMLIBLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + if (argc < 2 || argc > 3 || zend_get_parameters_ex(argc, &srcimg, &cangle, &crads) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(src, Imlib_Image, srcimg, -1, "Imlib Image", le_imlib_img); + + if (argc > 2) + { + convert_to_double_ex(crads); + radians = Z_DVAL_PP(crads); + } + else + { + convert_to_double_ex(cangle); + angle = Z_DVAL_PP(cangle); + radians = angle * pi/180; + } + + imlib_context_set_image(src); + dst = imlib_create_rotated_image(radians); + + if (dst) ZEND_REGISTER_RESOURCE(return_value, dst, le_imlib_img); +} +/* }}} */ + + +/* {{{ proto int imlib_create_scaled_image(int img, int dstw, int dsth) + Create a scaled copy of an image. If dstw or dsth is left blank, the aspect ratio of the source image will be preserved. */ +PHP_FUNCTION(imlib_create_scaled_image) +{ + zval **img, **dstw, **dsth; + int sw,sh,dw,dh; + Imlib_Image src,dst; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &img, &dstw, &dsth) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(src, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + convert_to_long_ex(dstw); + convert_to_long_ex(dsth); + dw = Z_LVAL_PP(dstw); + dh = Z_LVAL_PP(dsth); + + if (!dw && !dh) { + RETURN_FALSE; + } + + imlib_context_set_image(src); + sw = imlib_image_get_width(); + sh = imlib_image_get_height(); + if (!dw) { + dw = (int) (((double)dh * sw) / sh); + } + if (!dh) { + dh = (int) (((double) dw * sh) / sw); + } + + dst = imlib_create_cropped_scaled_image(0,0, sw,sh, dw,dh); + + if (dst) ZEND_REGISTER_RESOURCE(return_value, dst, le_imlib_img); +} +/* }}} */ + + +/* {{{ proto bool imlib_dump_image(int img[, int &err[, int quality]]) + Output an image at an optional quality setting */ +PHP_FUNCTION(imlib_dump_image) +{ + int argc, q, fd, retval, output; + char *tmpfile; + zval **img, **quality, **err; + Imlib_Image im; + Imlib_Load_Error im_err; + IMLIBLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + if (argc < 1 || argc > 3 || zend_get_parameters_ex(argc, &img, &err, &quality) == FAILURE) { + WRONG_PARAM_COUNT; + } + + if (argc > 1) { + zval_dtor(*err); + ZVAL_LONG(*err,0); + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + tmpfile = estrdup("/tmp/phpimlib.XXXXXX"); + + if ((fd = mkstemp(tmpfile)) < 0) { + php_error(E_WARNING, "%s: unable to open temporary file", get_active_function_name(TSRMLS_C)); + efree(tmpfile); + RETURN_FALSE; + } + + /* TODO: notify in case of errors? */ + retval = fchmod(fd, S_IRUSR|S_IWUSR); + if (retval != 0) { + php_error(E_WARNING, "%s: could not change permissions on temporary file", get_active_function_name(TSRMLS_C)); + close(fd); + efree(tmpfile); + RETURN_FALSE; + } + + imlib_context_set_image(im); + if(!imlib_image_format()) { + imlib_image_set_format("png"); + } + + if (argc > 2) + { + convert_to_long_ex(quality); + q = Z_LVAL_PP(quality); + imlib_image_attach_data_value("quality",NULL,q,NULL); + } + + imlib_save_image_with_error_return(tmpfile,&im_err); + + if (im_err) + { + close(fd); + unlink(tmpfile); + efree(tmpfile); + if (argc > 1) + { + ZVAL_LONG(*err,im_err); + } + _php_handle_imlib_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, + im_err,tmpfile); + RETURN_FALSE; + } + + /* fseek or something, then read the file and dump it out. */ + lseek(fd, 0, SEEK_SET); + + output = php_header(); + if (output) { + char buf[4096]; + +#if APACHE && defined(CHARSET_EBCDIC) + SLS_FETCH(); + /* This is a binary file already: avoid EBCDIC->ASCII conversion */ + ap_bsetflag(php3_rqst->connection->client, B_EBCDIC2ASCII, 0); +#endif + while ((retval = read(fd, buf, sizeof(buf))) > 0) { + php_write(buf, retval TSRMLS_CC); + } + } + + close(fd); + unlink(tmpfile); + efree(tmpfile); + + if (output) { + RETURN_TRUE; + } else { + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto void imlib_free_color_range(int cr) + Free a color range */ +PHP_FUNCTION(imlib_free_color_range) +{ + zval **fcr; + Imlib_Color_Range cr; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &fcr) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(cr, Imlib_Color_Range, fcr, -1, "Imlib Color Range", le_imlib_cr); + zend_list_delete(Z_LVAL_PP(fcr)); +} +/* }}} */ + + +/* {{{ proto void imlib_free_color_modifier(int cm) + Free a color modifier */ +PHP_FUNCTION(imlib_free_color_modifier) +{ + zval **fcm; + PHP_Imlib_Color_Modifier cm; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &fcm) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(cm, PHP_Imlib_Color_Modifier, fcm, -1, "Imlib Color Modifier", le_imlib_cm); + zend_list_delete(Z_LVAL_PP(fcm)); +} +/* }}} */ + +/* {{{ proto void imlib_free_font(int font) + Free a font */ +PHP_FUNCTION(imlib_free_font) +{ + zval **font; + PHP_Imlib_Font fn; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &font) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(fn, PHP_Imlib_Font, font, -1, "Imlib Font", le_imlib_font); + zend_list_delete(Z_LVAL_PP(font)); +} +/* }}} */ + + +/* {{{ proto void imlib_free_image(int img) + Free an image */ +PHP_FUNCTION(imlib_free_image) +{ + zval **img; + Imlib_Image im; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + zend_list_delete(Z_LVAL_PP(img)); +} +/* }}} */ + + +/* {{{ proto void imlib_get_text_advance(int font, string str, int &horiz_adv, int &vert_adv, int direction) + Determines the horizontal and vertical advance of a string if drawn with a given font in the specified direction*/ +PHP_FUNCTION(imlib_get_text_advance) +{ + zval **font, **textstr, **thoriz_adv, **tvert_adv, **tdir; + PHP_Imlib_Font fn; + const char *text = NULL; + int horiz_adv, vert_adv, dir; + Imlib_TTF_Encoding old_enc; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 5 || zend_get_parameters_ex(5, &font, &textstr, &thoriz_adv, &tvert_adv, &tdir) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(fn, PHP_Imlib_Font, font, -1, "Imlib Font", le_imlib_font); + + zval_dtor(*thoriz_adv); + zval_dtor(*tvert_adv); + + convert_to_string_ex(textstr); + convert_to_long_ex(thoriz_adv); + convert_to_long_ex(tvert_adv); + convert_to_long_ex(tdir); + text = Z_STRVAL_PP(textstr); + horiz_adv = Z_LVAL_PP(thoriz_adv); + vert_adv = Z_LVAL_PP(tvert_adv); + dir = Z_LVAL_PP(tdir); + + imlib_context_set_font(fn->font); + old_enc=imlib_context_get_TTF_encoding(); + imlib_context_set_TTF_encoding(fn->enc); + imlib_context_set_direction(dir); + imlib_get_text_advance(text, &horiz_adv, &vert_adv); + imlib_context_set_TTF_encoding(old_enc); + + ZVAL_LONG(*thoriz_adv,horiz_adv); + ZVAL_LONG(*tvert_adv,vert_adv); +} +/* }}} */ + + +/* {{{ proto void imlib_get_text_size(int font, string str, int &w, int &h, int direction) + Determines the width and height of a string if drawn with a given font in the specified direction */ +PHP_FUNCTION(imlib_get_text_size) +{ + zval **font, **textstr, **tw, **th, **tdir; + PHP_Imlib_Font fn; + const char *text = NULL; + int w,h,dir; + Imlib_TTF_Encoding old_enc; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 5 || zend_get_parameters_ex(5, &font, &textstr, &tw, &th, &tdir) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(fn, PHP_Imlib_Font, font, -1, "Imlib Font", le_imlib_font); + + zval_dtor(*tw); + zval_dtor(*th); + + convert_to_string_ex(textstr); + convert_to_long_ex(tw); + convert_to_long_ex(th); + convert_to_long_ex(tdir); + text = Z_STRVAL_PP(textstr); + w = Z_LVAL_PP(tw); + h = Z_LVAL_PP(th); + dir = Z_LVAL_PP(tdir); + + imlib_context_set_font(fn->font); + old_enc=imlib_context_get_TTF_encoding(); + imlib_context_set_TTF_encoding(fn->enc); + imlib_context_set_direction(dir); + imlib_get_text_size(text, &w, &h); + imlib_context_set_TTF_encoding(old_enc); + + ZVAL_LONG(*tw,w); + ZVAL_LONG(*th,h); +} +/* }}} */ + + +/* {{{ proto void imlib_image_blur(int img, int radius) + Blur an image with a given blur radius */ +PHP_FUNCTION(imlib_image_blur) +{ + zval **img, **radius; + int r; + Imlib_Image im; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &img, &radius) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + convert_to_long_ex(radius); + r = Z_LVAL_PP(radius); + + imlib_context_set_image(im); + imlib_image_blur(r); +} +/* }}} */ + + +/* {{{ proto bool imlib_image_draw_ellipse(int img, int xc, int yc, int w, int h, int r, int g, int b, int a[, array cliprect]) + Draw an ellipse of the specified size and color on an image */ +PHP_FUNCTION(imlib_image_draw_ellipse) +{ + _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_draw_ellipse, + "imlib_image_draw_ellipse"); +} +/* }}} */ + + +/* {{{ proto bool imlib_image_draw_line(int img, int x1, int y1, int x2, int y2, int r, int g, int b, int a[, array cliprect]) + Draw a line of the specified size and color on an image */ +PHP_FUNCTION(imlib_image_draw_line) +{ + _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,_php_wrap_draw_line, + "imlib_image_draw_ellipse"); +} +/* }}} */ + + +/* {{{ proto bool imlib_image_draw_polygon(int img, int polygon, bool closed, int r, int g, int b, int a[, array cliprect]) + Draw the defined polygon on an image */ +PHP_FUNCTION(imlib_image_draw_polygon) +{ + zval **img, **polygon, **pclosed, **pr, **pg, **pb, **pa, **dbox; + int r,g,b,a,cx,cy,cw,ch,argc; + Imlib_Image im; + ImlibPolygon poly; + int closed; + IMLIBLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + if (argc < 7 || argc > 8 || zend_get_parameters_ex(argc, &img, &polygon, &pclosed, &pr, &pg, &pb, &pa, &dbox) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + ZEND_FETCH_RESOURCE(poly, ImlibPolygon, polygon, -1, "Imlib Polygon", le_imlib_poly); + + _php_convert_four_longs(pr,pg,pb,pa,&r,&g,&b,&a); + + convert_to_long_ex(pclosed); + closed = Z_LVAL_PP(pclosed); + + imlib_context_set_image(im); + imlib_context_set_color(r,g,b,a); + + if (argc > 7) + { + if (!_php_handle_cliprect_array(dbox, "imlib_image_draw_polygon", &cx, &cy, &cw, &ch)) + RETURN_FALSE; + imlib_context_set_cliprect(cx,cy,cw,ch); + } + + imlib_image_draw_polygon(poly,closed); + imlib_context_set_cliprect(0,0,0,0); +} +/* }}} */ + + +/* {{{ proto bool imlib_image_draw_rectangle(int img, int x, int y, int w, int h, int r, int g, int b, int a[, array cliprect]) + Draw a rectangle of the specified size and color on an image */ +PHP_FUNCTION(imlib_image_draw_rectangle) +{ + _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_draw_rectangle, + "imlib_image_draw_rectangle"); +} +/* }}} */ + + +/* {{{ proto bool imlib_image_fill_color_range_rectangle(int im, int cr, int x, int y, int width, int height, int angle) + Fill a rectangle with a color range at a given angle on an image */ +PHP_FUNCTION(imlib_image_fill_color_range_rectangle) +{ + zval **fim, **fcr, **fx, **fy, **fwidth, **fheight, **fangle, **fbox; + int x,y,width,height,argc,cx,cy,cw,ch; + double angle; + Imlib_Image im; + Imlib_Color_Range cr; + IMLIBLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + if (argc < 7 || argc > 8 || zend_get_parameters_ex(argc, &fim, &fcr, &fx, &fy, &fwidth, &fheight, &fangle, &fbox) == FAILURE) { + WRONG_PARAM_COUNT; + } + + _php_convert_four_longs(fx,fy,fwidth,fheight,&x,&y,&width,&height); + convert_to_double_ex(fangle); + angle = Z_DVAL_PP(fangle); + + ZEND_FETCH_RESOURCE(cr, Imlib_Color_Range, fcr, -1, "Imlib Color Range", le_imlib_cr); + ZEND_FETCH_RESOURCE(im, Imlib_Image, fim, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_color_range(cr); + imlib_context_set_image(im); + + if (argc > 7) + { + if (!_php_handle_cliprect_array(fbox, "imlib_image_fill_color_range_rectangle", &cx,&cy,&cw,&ch)) + RETURN_FALSE; + imlib_context_set_cliprect(cx,cy,cw,ch); + } + + imlib_image_fill_color_range_rectangle(x,y,width,height, angle); + imlib_context_set_cliprect(0,0,0,0); + RETURN_TRUE; +} +/* }}} */ + + +/* {{{ proto void imlib_image_fill_ellipse(int img, int xc, int yc, int w, int h, int r, int g, int b, int a[, array cliprect]) + Fill an ellipse of the specified size and color on an image */ +PHP_FUNCTION(imlib_image_fill_ellipse) +{ + _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_fill_ellipse, + "imlib_image_fill_ellipse"); +} +/* }}} */ + + +/* {{{ proto bool imlib_image_fill_polygon(int img, int polygon, int r, int g, int b, int a[, array cliprect]) + Draw and fill the defined polygon on an image */ +PHP_FUNCTION(imlib_image_fill_polygon) +{ + zval **img, **polygon, **pr, **pg, **pb, **pa, **dbox; + int r,g,b,a,cx,cy,cw,ch,argc; + Imlib_Image im; + ImlibPolygon poly; + IMLIBLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + if (argc < 6 || argc > 7 || zend_get_parameters_ex(argc, &img, &polygon, &pr, &pg, &pb, &pa, &dbox) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + ZEND_FETCH_RESOURCE(poly, ImlibPolygon, polygon, -1, "Imlib Polygon", le_imlib_poly); + + _php_convert_four_longs(pr,pg,pb,pa,&r,&g,&b,&a); + + imlib_context_set_image(im); + imlib_context_set_color(r,g,b,a); + + if (argc > 6) + { + if (!_php_handle_cliprect_array(dbox, "imlib_image_fill_polygon", &cx, &cy, &cw, &ch)) + RETURN_FALSE; + imlib_context_set_cliprect(cx,cy,cw,ch); + } + + imlib_image_fill_polygon(poly); + imlib_context_set_cliprect(0,0,0,0); + RETURN_TRUE; +} +/* }}} */ + + +/* {{{ proto void imlib_image_fill_rectange(int img, int x, int y, int w, int h, int r, int g, int b, int a[, array cliprect]) + Fill a rectangle of the specified size and color on an image */ +PHP_FUNCTION(imlib_image_fill_rectangle) +{ + _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_fill_rectangle, + "imlib_image_fill_rectangle"); +} +/* }}} */ + + +/* {{{ proto void imlib_image_flip_horizontal(int img) + Flip an image horizontally */ +PHP_FUNCTION(imlib_image_flip_horizontal) +{ + _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_flip_horizontal); +} +/* }}} */ + + +/* {{{ proto void imlib_image_flip_vertical(int img) + Flip an Imlib_Image vertically */ +PHP_FUNCTION(imlib_image_flip_vertical) +{ + _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_flip_vertical); +} +/* }}} */ + + +/* {{{ proto void imlib_image_flip_diagonal(int img) + Flip an image diagonally */ +PHP_FUNCTION(imlib_image_flip_diagonal) +{ + _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_flip_diagonal); +} +/* }}} */ + + +/* {{{ proto void imlib_image_orientate(int img, int stepping) + Orientate an image 90 x steps */ +PHP_FUNCTION(imlib_image_orientate) +{ + zval **img, **stepping; + int r; + Imlib_Image im; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &img, &stepping) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(im); + r = Z_LVAL_PP(stepping); + imlib_image_orientate(r); +} +/* }}} */ + + +/* {{{ proto string imlib_image_format(int img) + Returns the image format of an image */ +PHP_FUNCTION(imlib_image_format) +{ + zval **img; + Imlib_Image im; + char *name; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(im); + name = imlib_image_format(); + if (!name) + RETURN_FALSE; + + RETURN_STRING(name,strlen(name)); +} +/* }}} */ + + +/* {{{ proto string imlib_image_get_filename(int img) + Returns the filename of an image */ +PHP_FUNCTION(imlib_image_get_filename) +{ + zval **img; + Imlib_Image im; + const char *name = NULL; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(im); + name = imlib_image_get_filename(); + if (!name) + RETURN_FALSE; + + RETURN_STRING((char*)name,strlen(name)); +} +/* }}} */ + + +/* {{{ proto int imlib_image_get_height(int img) + Returns the height of an image */ +PHP_FUNCTION(imlib_image_get_height) +{ + zval **img; + Imlib_Image im; + int height; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(im); + height = imlib_image_get_height(); + + RETURN_LONG((long)height); +} +/* }}} */ + + +/* {{{ proto int imlib_image_get_width(int img) + Returns the width of an image */ +PHP_FUNCTION(imlib_image_get_width) +{ + zval **img; + Imlib_Image im; + int width; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(im); + width = imlib_image_get_width(); + + RETURN_LONG((long)width); +} +/* }}} */ + + +/* {{{ proto bool imlib_image_has_alpha(int img) + Return a boolean for whether or not an image has an alpha channel */ +PHP_FUNCTION(imlib_image_has_alpha) +{ + zval **img; + Imlib_Image im; + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &img) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + imlib_context_set_image(im); + if (imlib_image_has_alpha()) + { + RETURN_TRUE; + } + else + { + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto void imlib_image_modify_alpha(int img, int alpha) + Set the alpha channel of an image, or modify it if one was already present */ +PHP_FUNCTION(imlib_image_modify_alpha) +{ + zval **img, **alpha; + Imlib_Image im; + DATA8 map[256]; + Imlib_Color_Modifier *cmod; + int malpha, i; + double ratio; + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &img, &alpha) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + convert_to_long_ex(alpha); + malpha = Z_LVAL_PP(alpha); + ratio = ((double)malpha) / 255; + + imlib_context_set_image(im); + if (imlib_image_has_alpha()) + { + for (i = 0; i < 256; i++) + map[i] = (DATA8) (i * ratio); + } + else + { + for (i = 0; i < 256; i++) + map[i] = malpha; + imlib_image_set_has_alpha(1); + } + + cmod = imlib_create_color_modifier(); + imlib_context_set_color_modifier(cmod); + imlib_set_color_modifier_tables(NULL, NULL, NULL, map); + imlib_apply_color_modifier(); + imlib_free_color_modifier(); +} +/* }}} */ + + +/* {{{ proto void imlib_image_set_format(int img, string format) + Sets the image format of an image. */ +PHP_FUNCTION(imlib_image_set_format) +{ + zval **img, **zformat; + Imlib_Image im; + char *format; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &img, &zformat) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + convert_to_string_ex(zformat); + format = Z_STRVAL_PP(zformat); + if (!format) { + RETURN_FALSE; + } + + imlib_context_set_image(im); + imlib_image_set_format(format); + + RETURN_TRUE; +} +/* }}} */ + + +/* {{{ proto void imlib_image_sharpen(int img, int radius) + Sharpen an image with a given sharpen radius */ +PHP_FUNCTION(imlib_image_sharpen) +{ + zval **img, **radius; + int r; + Imlib_Image im; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &img, &radius) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(im, Imlib_Image, img, -1, "Imlib Image", le_imlib_img); + + convert_to_long_ex(radius); + r = Z_LVAL_PP(radius); + + imlib_context_set_image(im); + imlib_image_sharpen(r); +} +/* }}} */ + + +/* {{{ proto void imlib_image_tile_horizontal(int img) + Tile an image horizontally */ +PHP_FUNCTION(imlib_image_tile_horizontal) +{ + _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_tile_horizontal); +} +/* }}} */ + + +/* {{{ proto void imlib_image_tile_vertical(int img) + Tile an image vertically */ +PHP_FUNCTION(imlib_image_tile_vertical) +{ + _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_tile_vertical); +} +/* }}} */ + + +/* {{{ proto void imlib_image_tile(int img) + Tile an image horizontally and diagonally */ +PHP_FUNCTION(imlib_image_tile) +{ + _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_tile); +} +/* }}} */ + + +/* {{{ proto array imlib_list_fonts() + Return an array of all the fonts available in the font path */ +PHP_FUNCTION(imlib_list_fonts) +{ + int fcount, i; + char **flist = imlib_list_fonts(&fcount); + + if (array_init(return_value) == FAILURE) { + php_error(E_WARNING, "Cannot initialize return value"); + RETURN_FALSE; + } + + if (!fcount) + RETURN_FALSE; + + for (i = 0; i < fcount; i++) + { + /* FIXME: Is 1 the right parameter here? */ + add_next_index_string(return_value, flist[i], 1); + } + + imlib_free_font_list(flist,fcount); +} +/* }}} */ + + +/* {{{ proto int imlib_load_font(string fontname[, string encoding]) + Load a font */ +PHP_FUNCTION(imlib_load_font) +{ + zval **fontname, **encoding; + PHP_Imlib_Font fn; + int argc; + + IMLIBLS_FETCH(); + + argc=ZEND_NUM_ARGS(); + if (argc < 1 || argc > 2 || zend_get_parameters_ex(argc, &fontname, &encoding) == FAILURE) { + WRONG_PARAM_COUNT; + } + + if ((Z_LVAL_PP(encoding)IMLIB_TTF_ENCODING_ISO_8859_5)) + { + php_error(E_NOTICE, "Invalid font encoding ignored"); + argc=1; + } + + fn=(PHP_Imlib_Font)emalloc(sizeof(PHP_Imlib_Font_struct)); + if (!fn) RETURN_FALSE; + + if (argc==2) + { + convert_to_long_ex(encoding); + fn->enc=(Imlib_TTF_Encoding)Z_LVAL_PP(encoding); + imlib_context_set_TTF_encoding(fn->enc); + } + + convert_to_string_ex(fontname); + fn->font = imlib_load_font(Z_STRVAL_PP(fontname)); + + if (!fn->font) + { + efree(fn); + php_error(E_WARNING, "%s - Could not load font.", Z_STRVAL_PP(fontname)); + RETURN_FALSE; + } + if (argc==1) + { + fn->enc=imlib_context_get_TTF_encoding(); + } + + ZEND_REGISTER_RESOURCE(return_value, fn, le_imlib_font); +} +/* }}} */ + + +/* {{{ proto int imlib_load_image(string img[, int &err]) + Load a file into an image, optionally fetch an error parameter */ +PHP_FUNCTION(imlib_load_image) +{ + zval **img, **err; + int argc; + Imlib_Image im; + Imlib_Load_Error im_err; + IMLIBLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + if (argc < 1 || argc > 2 || zend_get_parameters_ex(argc, &img, &err) == FAILURE) { + WRONG_PARAM_COUNT; + } + + convert_to_string_ex(img); + if (argc == 2) { + zval_dtor(*err); + ZVAL_LONG(*err,0); + } + + im = imlib_load_image_with_error_return(Z_STRVAL_PP(img),&im_err); + + if ((im_err) || (!im)) + { + if (argc == 2) { + ZVAL_LONG(*err,im_err); + } + _php_handle_imlib_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, + im_err,Z_STRVAL_PP(img)); + RETURN_FALSE; + } + else + { + ZEND_REGISTER_RESOURCE(return_value, im, le_imlib_img); + } +} +/* }}} */ + + +/* {{{ proto void imlib_polygon_add_point(int polygon, int x, int y) + Add a point to a given polygon */ +PHP_FUNCTION(imlib_polygon_add_point) +{ + zval **polygon, **px, **py; + int x,y; + ImlibPolygon poly; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &polygon, &px, &py) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(poly, ImlibPolygon, polygon, -1, "Imlib Polygon", le_imlib_poly); + + convert_to_long_ex(px); + convert_to_long_ex(py); + x = Z_LVAL_PP(px); + y = Z_LVAL_PP(py); + + imlib_polygon_add_point(poly,x,y); +} +/* }}} */ + + +/* {{{ proto bool imlib_polygon_contains_point(int polygon, int x, int y) + Check if a give point is inside a polygon */ +PHP_FUNCTION(imlib_polygon_contains_point) +{ + zval **polygon, **px, **py; + int x,y,ret; + ImlibPolygon poly; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &polygon, &px, &py) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(poly, ImlibPolygon, polygon, -1, "Imlib Polygon", le_imlib_poly); + + convert_to_long_ex(px); + convert_to_long_ex(py); + x = Z_LVAL_PP(px); + y = Z_LVAL_PP(py); + + ret = imlib_polygon_contains_point(poly,x,y); + + if (ret) + { + RETURN_TRUE; + } + else + { + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto void imlib_polygon_free(int polygon) + Free a polygon */ +PHP_FUNCTION(imlib_polygon_free) +{ + zval **polygon; + ImlibPolygon poly; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &polygon) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(poly, ImlibPolygon, polygon, -1, "Imlib Polygon", le_imlib_poly); + zend_list_delete(Z_LVAL_PP(polygon)); +} +/* }}} */ + + +/* {{{ proto void imlib_polygon_get_bounds(int polygon, int &x1, int &y1, int &x2, int &y2) + Get the bounding coords of a polygon */ +PHP_FUNCTION(imlib_polygon_get_bounds) +{ + zval **polygon, **px1, **py1, **px2, **py2; + int x1,y1,x2,y2; + ImlibPolygon poly; + IMLIBLS_FETCH(); + + if (ZEND_NUM_ARGS() != 5 || zend_get_parameters_ex(5, &polygon, &px1, &py1, &px2, &py2) == FAILURE) { + WRONG_PARAM_COUNT; + } + + ZEND_FETCH_RESOURCE(poly, ImlibPolygon, polygon, -1, "Imlib Polygon", le_imlib_poly); + + zval_dtor(*px1); + zval_dtor(*py1); + zval_dtor(*px2); + zval_dtor(*py2); + + imlib_polygon_get_bounds(poly,&x1,&y1,&x2,&y2); + + ZVAL_LONG(*px1,x1); + ZVAL_LONG(*py1,y1); + ZVAL_