/* vim: set ft=cpp: */
%%
headers
#include <gtk-canvas.h>
#include "ext/gtk+/php_gtk+.h"
%%
constants




%%
ignore-glob
  *_get_type
%%
ignore gtk_canvas_update_bbox
 
%%
ignore   gtk_canvas_w2c_affine
%%
ignore   gtk_canvas_item_set
%%
ignore gtk_canvas_w2c_d
/* it's not needed- you dont need floating point pixel coords! */ 

%%
ignore   gtk_canvas_item_new

%%
override gtk_canvas_item_reparent

PHP_FUNCTION(gtk_canvas_item_reparent)
{
	zval *new_group;

	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "O", &new_group, gtk_canvasgroup_ce))
		return;

	gtk_canvas_item_reparent(GTK_CANVAS_ITEM(PHP_GTK_GET(this_ptr)), GTK_CANVAS_GROUP(PHP_GTK_GET(new_group)));
	RETURN_NULL();
}


%%
override  gtk_canvas_group_child_bounds

PHP_FUNCTION(gtk_canvas_group_child_bounds)
{
	zval *item;

	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "O", &item, gtk_canvasitem_ce))
		return;

	gtk_canvas_group_child_bounds(GTK_CANVAS_GROUP(PHP_GTK_GET(this_ptr)), GTK_CANVAS_ITEM(PHP_GTK_GET(item)));
	RETURN_NULL();
}

%%
override gtk_canvas_image_new

 
static GtkCanvasPoints* pointsAr;
 
int php_gtk_canvas_points_to_arg(GtkArg *arg, zval *value)
{

	HashTable *points = HASH_OF(value);
	int len,j;
	zval **item;
	php_error(E_WARNING, "TRYING POINTS?");
	 
	 
	/* even number of elements */
	if ((len=zend_hash_num_elements(points)) & 1 == 1) {
		php_error(E_WARNING, "must be an even number of points");
		return 0;
	}

	  /* XXXX - this hack means we don't need to worry about freeing the
	   * GnomeCanvasPoints structure after the function call.  It will not
	   * work if more than one GnomeCanvasPoints structure needs to be
	   * passed in. */
	if (pointsAr) {
		gtk_canvas_points_free(pointsAr);
	}
	pointsAr = gtk_canvas_points_new(len/2);
	
	for (zend_hash_internal_pointer_reset(points), j = 0;
		zend_hash_get_current_data(points, (void **)&item) == SUCCESS;
		zend_hash_move_forward(points), j++) 
	{
		php_error(E_WARNING, "set %d to %s",j,Z_STRVAL_PP(item));
		pointsAr->coords[j] = 100; /*Z_DVAL_PP(item); */
	}
	GTK_VALUE_POINTER(*arg) =  pointsAr;
	 
	return 1;


}
 
 
 
GtkArg *php_gtk_canvas_hash_as_args(zval *hash, GtkType type, gint *nargs)
{
	int i;
	zval **item;
	gchar *err, buf[255];
	ulong num_key;
	GtkArg *arg = NULL;
	GtkArgInfo *info;
	HashTable *ht = HASH_OF(hash);
	
	

	gtk_type_class(type);
	*nargs = zend_hash_num_elements(ht);
	arg = g_new(GtkArg, *nargs);

	for (zend_hash_internal_pointer_reset(ht), i = 0;
		 zend_hash_get_current_data(ht, (void **)&item) == SUCCESS;
		 zend_hash_move_forward(ht), i++) {
		if (zend_hash_get_current_key(ht, &arg[i].name, &num_key, 0) != HASH_KEY_IS_STRING) {
			php_error(E_WARNING, "array keys must be strings");
			g_free(arg);
			return NULL;
		}
		
		
		 if (!strcmp(arg[i].name, "points")) {
			 
			 
			if (!php_gtk_canvas_points_to_arg(&arg[i], *item)) {
				g_snprintf(buf, 255, "argument '%s': expected type %s, found %s",
						   arg[i].name, gtk_type_name(arg[i].type),
						   php_gtk_zval_type_name(*item));
				php_error(E_WARNING, buf);
				g_free(arg);
				return NULL;
			}
			
	    
		
		} else {
 
			err = gtk_object_arg_get_info(type, arg[i].name, &info);
			if (!info) {
				php_error(E_WARNING, "NO INFO FOUND:%s   %s",arg[i].name, err);
				g_free(err);
				g_free(arg);
				return NULL;
			}
	
			arg[i].type = info->type;
			arg[i].name = info->name;
			
			if (!php_gtk_arg_from_value(&arg[i], *item)) {
				g_snprintf(buf, 255, "argument '%s': expected type %s, found %s",
						   arg[i].name, gtk_type_name(arg[i].type),
						   php_gtk_zval_type_name(*item));
				php_error(E_WARNING, buf);
				g_free(arg);
				return NULL;
			}
		 }  
	}

	return arg;
}
  

PHP_FUNCTION(gtk_canvas_image_new)
{
	 
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_IMAGE;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	
	
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr);

}


%%
override gtk_canvas_line_new

PHP_FUNCTION(gtk_canvas_line_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_LINE;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce, &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 
}


%%
override gtk_canvas_polygon_new
 


PHP_FUNCTION(gtk_canvas_polygon_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_POLYGON;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	GtkCanvasPoints *points; 
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	
	 
 
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}
	
	
	
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 
}




%%
override gtk_canvas_re_new

PHP_FUNCTION(gtk_canvas_re_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_RE;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 
}


%%
override gtk_canvas_rect_new

PHP_FUNCTION(gtk_canvas_rect_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_RECT;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	 
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 
}



%%
override gtk_canvas_ellipse_new

PHP_FUNCTION(gtk_canvas_ellipse_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_ELLIPSE;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	 
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 
}

%%
override gtk_canvas_text_new

PHP_FUNCTION(gtk_canvas_text_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_TEXT;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	 
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 
}



%%
override gtk_canvas_widget_new

PHP_FUNCTION(gtk_canvas_widget_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_WIDGET;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 
}




%%
override gtk_canvas_group_new





PHP_FUNCTION(gtk_canvas_group_new)
{
	zval *parent;
	zval *hash;
	long type = GTK_CANVAS_TYPE_CANVAS_GROUP;
	char *first_arg_name;
	GtkObject *wrapped_obj;
	GtkArg *args;
	guint nargs;
	
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "Oa", &parent, gtk_canvasgroup_ce,  &hash)) {
		php_gtk_invalidate(this_ptr);
		return;
	}
	
	args = php_gtk_hash_as_args(hash,type,&nargs);
	
	wrapped_obj = (GtkObject *)gtk_canvas_item_newv(GTK_CANVAS_GROUP(PHP_GTK_GET(parent)), (GtkType)type, nargs, args);
	if (!wrapped_obj) {
		php_error(E_WARNING, "%s(): could not create GtkCanvasItem object",
				  get_active_function_name(TSRMLS_C));
		php_gtk_invalidate(this_ptr);
		return;
	}

	php_gtk_object_init(wrapped_obj, this_ptr); 

}


%%
override gtk_canvas_item_set_points


 

PHP_FUNCTION(gtk_canvas_item_set_points)
{
	zval *hash;
	GtkCanvasPoints* pointsAr;
	HashTable *phash;
	int len,j;
	zval **item;
	 
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "a", &hash))
		return;
	
	phash = HASH_OF(hash);
	
	if ((len=zend_hash_num_elements(phash)) & 1 == 1) {
		php_error(E_WARNING, "must be an even number of points");
		return;
	}
	pointsAr = gtk_canvas_points_new(len/2);
	
	for (zend_hash_internal_pointer_reset(phash), j = 0;
		zend_hash_get_current_data(phash, (void **)&item) == SUCCESS;
		zend_hash_move_forward(phash), j++) 
	{
      
        convert_to_double(*item);	    
        pointsAr->coords[j] =  Z_DVAL_PP(item); 
	}
	 
	
	 
	gtk_canvas_item_set(GTK_CANVAS_ITEM(PHP_GTK_GET(this_ptr)), "points", pointsAr, NULL);
	
	gtk_canvas_points_unref(pointsAr);
	
	RETURN_NULL();
}




%%
override gtk_canvas_aa_get_type


PHP_FUNCTION(gtk_canvas_aa_get_type)
{
	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), ""))
		return;

	RETURN_LONG(gtk_canvas_get_type());
}




%%
override gtk_canvas_w2c


PHP_FUNCTION(gtk_canvas_w2c)
{
	double wx, wy;
	int rx, ry;
	
	
	
	
	NOT_STATIC_METHOD();
 
	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "dd", &wx, &wy))
		return;
	
	gtk_canvas_w2c(GTK_CANVAS(PHP_GTK_GET(this_ptr)), (float)wx, (float)wy, &rx, &ry);
	
	array_init(return_value);
	add_next_index_long(return_value, (long)rx);
	add_next_index_long(return_value, (long)ry);
	 
}


%%
override gtk_canvas_c2w

PHP_FUNCTION(gtk_canvas_c2w)
{
	long cx, cy;
	double rx, ry;
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "ii", &cx, &cy))
		return;

	gtk_canvas_c2w(GTK_CANVAS(PHP_GTK_GET(this_ptr)), (int)cx, (int)cy, &rx, &ry);
	array_init(return_value);
	add_next_index_double(return_value, rx);
	add_next_index_double(return_value, ry);
}

%%
override gtk_canvas_window_to_world

PHP_FUNCTION(gtk_canvas_window_to_world)
{
	double winx, winy;
	double rx, ry;
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "dd", &winx, &winy))
		return;

	gtk_canvas_window_to_world(GTK_CANVAS(PHP_GTK_GET(this_ptr)), (float)winx, (float)winy, &rx, &ry);
	array_init(return_value);
	add_next_index_double(return_value, rx);
	add_next_index_double(return_value, ry);
}
%%
override gtk_canvas_world_to_window

PHP_FUNCTION(gtk_canvas_world_to_window)
{
	double worldx, worldy;
	double rx, ry;
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "dd", &worldx, &worldy))
		return;

	gtk_canvas_world_to_window(GTK_CANVAS(PHP_GTK_GET(this_ptr)), (float)worldx, (float)worldy, &rx, &ry);
	array_init(return_value);
	add_next_index_double(return_value, rx);
	add_next_index_double(return_value, ry);
}
%%
override gtk_canvas_get_scroll_region

PHP_FUNCTION(gtk_canvas_get_scroll_region)
{
	double x1, y1, x2, y2;
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), ""))
		return;

	gtk_canvas_get_scroll_region(GTK_CANVAS(PHP_GTK_GET(this_ptr)), &x1, &y1, &x2, &y2);
	array_init(return_value);
	add_next_index_double(return_value, x1);
	add_next_index_double(return_value, y1);
	add_next_index_double(return_value, x2);
	add_next_index_double(return_value, y2);
}
%%
override gtk_canvas_get_scroll_offsets

PHP_FUNCTION(gtk_canvas_get_scroll_offsets)
{
	gint cx, cy;
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), ""))
		return;

	gtk_canvas_get_scroll_offsets(GTK_CANVAS(PHP_GTK_GET(this_ptr)), &cx, &cy);
	array_init(return_value);
	add_next_index_long(return_value, (long)cx);
	add_next_index_long(return_value, (long)cy);
 
}

%%
override gtk_canvas_item_i2w_affine

PHP_FUNCTION(gtk_canvas_item_i2w_affine)
{
	double affine[6];

	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "dddddd", &affine[0], &affine[1], &affine[2], &affine[3], &affine[4], &affine[5]))
		return;

	gtk_canvas_item_i2w_affine(GTK_CANVAS_ITEM(PHP_GTK_GET(this_ptr)), affine);
	RETURN_NULL();
}

%%
override gtk_canvas_item_i2c_affine

PHP_FUNCTION(gtk_canvas_item_i2c_affine)
{
	double affine[6];

	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "dddddd", &affine[0], &affine[1], &affine[2], &affine[3], &affine[4], &affine[5]))
		return;
	
	gtk_canvas_item_i2c_affine(GTK_CANVAS_ITEM(PHP_GTK_GET(this_ptr)), affine);
	RETURN_NULL();
}

%%
override gtk_canvas_item_scale

/* scale is not actually defined in the code - it's in the headers! - 
to make this work, you need to modify the x/y insert postion, and divide it
by the scale factor... other wise it scales from 0,0...
the first 2 args are dummy's as it should be implemented as per the headers really..

*/

PHP_FUNCTION(gtk_canvas_item_scale)
{
	double  x,y,scale_x, scale_y;
	double affine[6];
	
	NOT_STATIC_METHOD();

	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), "dddd",&x,&y, &scale_x, &scale_y))
		return;
	
	
	art_affine_scale(affine, scale_x,scale_y);
	/*art_affine_point(affine_B */
	gtk_canvas_item_affine_relative (GTK_CANVAS_ITEM(PHP_GTK_GET(this_ptr)), affine);

	
	RETURN_NULL();
}
 %%
override gtk_canvas_item_get_bounds

PHP_FUNCTION(gtk_canvas_item_get_bounds)
{
	double x1, y1, x2, y2;
 
	
	NOT_STATIC_METHOD();
 
	if (!php_gtk_parse_args(ZEND_NUM_ARGS(), ""))
		return;

	
	gtk_canvas_item_get_bounds(GTK_CANVAS_ITEM(PHP_GTK_GET(this_ptr)), &x1, &y1, &x2, &y2);
	
	array_init(return_value);
	add_next_index_long(return_value, (long)x1);
	add_next_index_long(return_value, (long)y1);
	add_next_index_long(return_value, (long)x2);
	add_next_index_long(return_value, (long)y2);
	 
}