#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

/* Copyright (C) 1997, Kenneth Albanowski.
   This code may be distributed under the same terms as Perl itself. */

#if !defined(PERLIO_IS_STDIO) && defined(HASATTRIBUTE)
# undef printf
#endif
    
#include <gdk/gdk.h>
#include <gtk/gtk.h>

#if !defined(PERLIO_IS_STDIO) && defined(HASATTRIBUTE)
# define printf PerlIO_stdoutf
#endif

#include "PerlGtkInt.h"
#include "MiscTypes.h"
#include "GdkTypes.h"
#include "GtkTypes.h"
#include "GtkDefs.h"

SV * newSVGdkBitmap(GdkBitmap * x) { return newSVGdkWindow(x); }
GdkBitmap * SvGdkBitmap(SV * x) { return SvGdkWindow(x); }
SV * newSVGdkPixmap(GdkPixmap * x) { return newSVGdkWindow(x); }
GdkPixmap * SvGdkPixmap(SV * x) { return SvGdkWindow(x); }

/*SV * newSVGdkWindowRef(GdkWindow * w) { return newSVMiscRef(w, "Gtk::Gdk::Window",0); }
GdkWindow * SvGdkWindowRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Window"); }

SV * newSVGdkPixmapRef(GdkPixmap * w) { return newSVMiscRef(w, "Gtk::Gdk::Pixmap",0); }
GdkPixmap * SvGdkPixmapRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Pixmap"); }

SV * newSVGdkBitmapRef(GdkBitmap * w) { return newSVMiscRef(w, "Gtk::Gdk::Bitmap",0); }
GdkBitmap * SvGdkBitmapRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Bitmap"); }

SV * newSVGdkColormapRef(GdkColormap * w) { return newSVMiscRef(w, "Gtk::Gdk::Colormap",0); }
GdkColormap * SvGdkColormapRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Colormap"); }*/

/*SV * newSVGdkColor(GdkColor * c) { return newSVMiscRef(c, "Gtk::Gdk::Color",0); }
GdkColor * SvGdkColor(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Color"); }*/

SV * newSVGdkRegion(GdkRegion * c) { return newSVMiscRef(c, "Gtk::Gdk::Region",0); }
GdkRegion * SvGdkRegion(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Region"); }

SV * newSVGdkCursorRef(GdkCursor * w) { return newSVMiscRef(w, "Gtk::Gdk::Cursor",0); }
GdkCursor * SvGdkCursorRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Cursor"); }

SV * newSVGdkVisualRef(GdkVisual * w) { return newSVMiscRef(w, "Gtk::Gdk::Visual",0); }
GdkVisual * SvGdkVisualRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Visual"); }

SV * newSVGdkGCRef(GdkGC * g) { return newSVMiscRef(g, "Gtk::Gdk::GC",0); }
GdkGC * SvGdkGCRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::GC"); }

SV * newSVGdkFontRef(GdkFont * f) { return newSVMiscRef(f, "Gtk::Gdk::Font",0); }
GdkFont * SvGdkFontRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Font"); }

/*SV * newSVGdkImageRef(GdkImage * i) { return newSVMiscRef(i, "Gtk::Gdk::Image",0); }
GdkImage * SvGdkImageRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::Image"); }*/

SV * newSVGdkWindow(GdkWindow * value) {
	int n = 0;
	SV * result;
	result = newSVMiscRef(value, 
		(value && (gdk_window_get_type(value) == GDK_WINDOW_PIXMAP)) ? 
			"Gtk::Gdk::Pixmap" :
			"Gtk::Gdk::Window"
		, &n);
	if (n && value)
		gdk_window_ref(value);
	return result;
}

GdkWindow * SvGdkWindow(SV * value) { return (GdkWindow*)SvMiscRef(value, "Gtk::Gdk::Pixmap"); }


SV * newSVGdkRectangle(GdkRectangle * rect)
{
	AV * a;
	SV * r;
	
	if (!rect)
		return newSVsv(&PL_sv_undef);
		
	a = newAV();
	r = newRV((SV*)a);
	SvREFCNT_dec(a);
	
	av_push(a, newSViv(rect->x));
	av_push(a, newSViv(rect->y));
	av_push(a, newSViv(rect->width));
	av_push(a, newSViv(rect->height));
	
	return r;
}

GdkRectangle * SvGdkRectangle(SV * data, GdkRectangle * rect)
{
	AV * a;
	SV ** s;

	if ((!data) || (!SvOK(data)) || (!SvRV(data)) || (SvTYPE(SvRV(data)) != SVt_PVAV))
		return 0;
		
	a = (AV*)SvRV(data);

	if (av_len(a) != 3)
		croak("rectangle must have four elements");

	if (!rect)
		rect = pgtk_alloc_temp(sizeof(GdkRectangle));
	
	rect->x = SvIV(*av_fetch(a, 0, 0));
	rect->y = SvIV(*av_fetch(a, 1, 0));
	rect->width = SvIV(*av_fetch(a, 2, 0));
	rect->height = SvIV(*av_fetch(a, 3, 0));
	
	return rect;
}

SV * newSVGdkGCValues(GdkGCValues * v)
{
	HV * h;
	SV * r;
	
	if (!v)
		return newSVsv(&PL_sv_undef);
		
	h = newHV();
	r = newRV((SV*)h);
	SvREFCNT_dec(h);

	hv_store(h, "foreground", 10, newSVMiscRef(&v->foreground, "Gtk::Gdk::Color",0), 0);
	hv_store(h, "background", 10, newSVMiscRef(&v->background, "Gtk::Gdk::Color",0), 0);
	hv_store(h, "font", 4, newSVMiscRef(v->font, "Gtk::Gdk::Font",0), 0);
	hv_store(h, "function", 8, newSVGdkFunction(v->function), 0);
	hv_store(h, "fill", 4, newSVGdkFill(v->fill), 0);
	hv_store(h, "tile", 4, newSVMiscRef(v->tile, "Gtk::Gdk::Pixmap",0), 0);
	hv_store(h, "stipple", 7, newSVMiscRef(v->stipple, "Gtk::Gdk::Pixmap",0), 0);
	hv_store(h, "clip_mask", 9, newSVMiscRef(v->clip_mask, "Gtk::Gdk::Pixmap",0), 0);
	hv_store(h, "subwindow_mode", 14, newSVGdkSubwindowMode(v->subwindow_mode), 0);
	hv_store(h, "ts_x_origin", 11, newSViv(v->ts_x_origin), 0);
	hv_store(h, "ts_y_origin", 11, newSViv(v->ts_y_origin), 0);
	hv_store(h, "clip_x_origin", 13, newSViv(v->clip_x_origin), 0);
	hv_store(h, "clip_x_origin", 13, newSViv(v->clip_y_origin), 0);
	hv_store(h, "graphics_exposures", 18, newSViv(v->graphics_exposures), 0);
	hv_store(h, "line_width", 10, newSViv(v->line_width), 0);
	hv_store(h, "line_style", 10, newSVGdkLineStyle(v->line_style), 0);
	hv_store(h, "cap_style", 9, newSVGdkCapStyle(v->cap_style), 0);
	hv_store(h, "join_style", 10, newSVGdkJoinStyle(v->join_style), 0);
	
	return r;
}

GdkGCValues * SvGdkGCValues(SV * data, GdkGCValues * v, GdkGCValuesMask * m)
{
	HV * h;
	SV ** s;

	if ((!data) || (!SvOK(data)) || (!SvRV(data)) || (SvTYPE(SvRV(data)) != SVt_PVHV))
		return 0;
		
	h = (HV*)SvRV(data);

	if (!v)
		v = pgtk_alloc_temp(sizeof(GdkGCValues));
	
	memset(v,0,sizeof(GdkGCValues));

	if ((s=hv_fetch(h, "foreground", 10, 0)) && SvOK(*s)) {
		SvSetGdkColor(*s, &v->foreground);
		*m |= GDK_GC_FOREGROUND;
	}
	if ((s=hv_fetch(h, "background", 10, 0)) && SvOK(*s)) {
		SvSetGdkColor(*s, &v->background);
		*m |= GDK_GC_BACKGROUND;
	}
	if ((s=hv_fetch(h, "font", 4, 0)) && SvOK(*s)) {
		v->font = SvMiscRef(*s, "Gtk::Gdk::Font");
		*m |= GDK_GC_FONT;
	}
	if ((s=hv_fetch(h, "function", 8, 0)) && SvOK(*s)) {
		v->function = SvGdkFunction(*s);
		*m |= GDK_GC_FUNCTION;
	}
	if ((s=hv_fetch(h, "fill", 4, 0)) && SvOK(*s)) {
		v->function = SvGdkFill(*s);
		*m |= GDK_GC_FILL;
	}
	if ((s=hv_fetch(h, "tile", 4, 0)) && SvOK(*s)) {
		v->tile = SvMiscRef(*s, "Gtk::Gdk::Pixmap");
		*m |= GDK_GC_TILE;
	}
	if ((s=hv_fetch(h, "stipple", 7, 0)) && SvOK(*s)) {
		v->stipple = SvMiscRef(*s, "Gtk::Gdk::Pixmap");
		*m |= GDK_GC_STIPPLE;
	}
	if ((s=hv_fetch(h, "clip_mask", 9, 0)) && SvOK(*s)) {
		v->clip_mask = SvMiscRef(*s, "Gtk::Gdk::Pixmap");
		*m |= GDK_GC_CLIP_MASK;
	}
	if ((s=hv_fetch(h, "subwindow_mode", 14, 0)) && SvOK(*s)) {
		v->subwindow_mode = SvGdkSubwindowMode(*s);
		*m |= GDK_GC_SUBWINDOW;
	}
	if ((s=hv_fetch(h, "ts_x_origin", 11, 0)) && SvOK(*s)) {
		v->ts_x_origin = SvIV(*s);
		*m |= GDK_GC_TS_X_ORIGIN;
	}
	if ((s=hv_fetch(h, "ts_y_origin", 11, 0)) && SvOK(*s)) {
		v->ts_y_origin = SvIV(*s);
		*m |= GDK_GC_TS_Y_ORIGIN;
	}
	if ((s=hv_fetch(h, "clip_x_origin", 13, 0)) && SvOK(*s)) {
		v->clip_x_origin = SvIV(*s);
		*m |= GDK_GC_CLIP_X_ORIGIN;
	}
	if ((s=hv_fetch(h, "clip_y_origin", 13, 0)) && SvOK(*s)) {
		v->clip_y_origin = SvIV(*s);
		*m |= GDK_GC_CLIP_Y_ORIGIN;
	}
	if ((s=hv_fetch(h, "graphics_exposures", 18, 0)) && SvOK(*s)) {
		v->graphics_exposures = SvIV(*s);
		*m |= GDK_GC_EXPOSURES;
	}
	if ((s=hv_fetch(h, "line_width", 10, 0)) && SvOK(*s)) {
		v->line_width= SvIV(*s);
		*m |= GDK_GC_LINE_WIDTH;
	}
	if ((s=hv_fetch(h, "line_style", 10, 0)) && SvOK(*s)) {
		v->line_style= SvGdkLineStyle(*s);
		*m |= GDK_GC_LINE_STYLE;
	}
	if ((s=hv_fetch(h, "cap_style", 9, 0)) && SvOK(*s)) {
		v->cap_style = SvGdkCapStyle(*s);
		*m |= GDK_GC_CAP_STYLE;
	}
	if ((s=hv_fetch(h, "join_style", 10, 0)) && SvOK(*s)) {
		v->join_style = SvGdkJoinStyle(*s);
		*m |= GDK_GC_JOIN_STYLE;
	}
	return v;
}

SV * newSVGdkDeviceInfo(GdkDeviceInfo * v)
{
	HV * h;
	SV * r;
	
	if (!v)
		return newSVsv(&PL_sv_undef);
		
	h = newHV();
	r = newRV((SV*)h);
	SvREFCNT_dec(h);

	hv_store(h, "deviceid", 8, newSViv(v->deviceid), 0);
	hv_store(h, "name", 4, newSVpv(v->name, 0), 0);
	hv_store(h, "source", 6, newSVGdkInputSource(v->source), 0);
	hv_store(h, "mode", 4, newSVGdkInputMode(v->mode), 0);
	hv_store(h, "has_cursor", 10, newSViv(v->has_cursor), 0);
	hv_store(h, "num_axes", 8, newSViv(v->num_axes), 0);
	if (v->axes) {
		int i;
		AV * a = newAV();
		for(i=0;i<v->num_axes;i++) {
			av_push(a, newSVGdkAxisUse(v->axes[i]));
		}
		hv_store(h, "axes", 4, newRV((SV*)a), 0);
		SvREFCNT_dec(a);
	}

	return r;
}

SV * newSVGdkTimeCoord(GdkTimeCoord * v)
{
	HV * h;
	SV * r;
	
	if (!v)
		return newSVsv(&PL_sv_undef);
		
	h = newHV();
	r = newRV((SV*)h);
	SvREFCNT_dec(h);

	hv_store(h, "time", 4, newSViv(v->time), 0);
	hv_store(h, "x", 1, newSVnv(v->x), 0);
	hv_store(h, "y", 1, newSVnv(v->y), 0);
	hv_store(h, "pressure", 8, newSVnv(v->pressure), 0);
	hv_store(h, "xtilt", 5, newSVnv(v->xtilt), 0);
	hv_store(h, "ytilt", 5, newSVnv(v->ytilt), 0);

	return r;
}

SV * newSVGdkAtom(GdkAtom a)
{
	SV *s = newSViv(0);
	sv_setuv(s, a);
	return s;
}

GdkAtom SvGdkAtom(SV * data)
{
	return SvUV(data);
}

SV * newSVGdkEvent(GdkEvent * e)
{
	HV * h;
	GdkEvent * e2;
	SV * r;
	int n;
	
	if (!e)
		return newSVsv(&PL_sv_undef);
	/* gdk_event_copy() will segfault otherwise */
	if (!e->any.window)
		return newSVsv(&PL_sv_undef);
 
 
        h = newHV();
        /*r = newSVMiscRef(e, "Gtk::Gdk::Event", &n);*/

	/*h = (HV*)SvRV(r);*/
	r = newRV((SV*)h);
	SvREFCNT_dec(h);

	sv_bless(r, gv_stashpv("Gtk::Gdk::Event", FALSE));
 
	e2 = gdk_event_copy(e);
	
	hv_store(h, "_ptr", 4, newSViv((long)e2), 0);
	
	/*printf("Turning GdkEvent %d, type %d, into SV %d, ptr %d\n", e, e->type, r, e2);*/
	
	hv_store(h, "type", 4, newSVGdkEventType(e->type), 0);
	hv_store(h, "window", 6, newSVGdkWindow(e->any.window), 0);
	hv_store(h, "send_event", 10, newSViv(e->any.send_event), 0);
	switch (e->type) {
	case GDK_EXPOSE:
		hv_store(h, "area", 4, newSVGdkRectangle(&e->expose.area), 0);
		hv_store(h, "count", 5, newSViv(e->expose.count), 0);
		break;
	case GDK_VISIBILITY_NOTIFY:
		hv_store(h, "state", 5, newSVGdkVisibilityState(e->visibility.state), 0);
		break;
	case GDK_MOTION_NOTIFY:
		hv_store(h, "is_hint", 7, newSViv(e->motion.is_hint), 0);
		hv_store(h, "x", 1, newSVnv(e->motion.x), 0);
		hv_store(h, "y", 1, newSVnv(e->motion.y), 0);
		hv_store(h, "pressure", 8, newSVnv(e->motion.pressure), 0);
		hv_store(h, "xtilt", 5, newSVnv(e->motion.xtilt), 0);
		hv_store(h, "ytilt", 5, newSVnv(e->motion.ytilt), 0);
		hv_store(h, "time", 4, newSViv(e->motion.time), 0);
		hv_store(h, "state", 5, newSViv(e->motion.state), 0);
		hv_store(h, "source", 6, newSVGdkInputSource(e->motion.source), 0);
		hv_store(h, "deviceid", 8, newSViv(e->motion.deviceid), 0);
		hv_store(h, "x_root", 6, newSVnv(e->motion.x_root), 0);
		hv_store(h, "y_root", 6, newSVnv(e->motion.y_root), 0);
		break;
	case GDK_BUTTON_PRESS:
	case GDK_2BUTTON_PRESS:
	case GDK_3BUTTON_PRESS:
	case GDK_BUTTON_RELEASE:
		hv_store(h, "x", 1, newSViv(e->button.x), 0);
		hv_store(h, "y", 1, newSViv(e->button.y), 0);
		hv_store(h, "time", 4, newSViv(e->button.time), 0);
		hv_store(h, "pressure", 8, newSVnv(e->button.pressure), 0);
		hv_store(h, "xtilt", 5, newSVnv(e->button.xtilt), 0);
		hv_store(h, "ytilt", 5, newSVnv(e->button.ytilt), 0);
		hv_store(h, "state", 5, newSViv(e->button.state), 0);
		hv_store(h, "button", 6, newSViv(e->button.button), 0);
		hv_store(h, "source", 6, newSVGdkInputSource(e->button.source), 0);
		hv_store(h, "deviceid", 8, newSViv(e->button.deviceid), 0);
		hv_store(h, "x_root", 6, newSVnv(e->button.x_root), 0);
		hv_store(h, "y_root", 6, newSVnv(e->button.y_root), 0);
		break;
	case GDK_KEY_PRESS:
	case GDK_KEY_RELEASE:
		hv_store(h, "time", 4, newSViv(e->key.time), 0);
		hv_store(h, "state", 5, newSVnv(e->key.state), 0);
		hv_store(h, "keyval", 6, newSViv(e->key.keyval), 0);
		hv_store(h, "string", 6, newSVpvn(e->key.string, e->key.length), 0);
		break;
	case GDK_FOCUS_CHANGE:
		hv_store(h, "in", 2, newSViv(e->focus_change.in), 0);
		break;
	case GDK_ENTER_NOTIFY:
	case GDK_LEAVE_NOTIFY:
		hv_store(h, "window", 6, newSVGdkWindow(e->crossing.window), 0);
		hv_store(h, "subwindow", 9, newSVGdkWindow(e->crossing.subwindow), 0);
		hv_store(h, "time", 4, newSViv(e->crossing.time), 0);
		hv_store(h, "x", 1, newSVnv(e->crossing.x), 0);
		hv_store(h, "y", 1, newSVnv(e->crossing.y), 0);
		hv_store(h, "x_root", 6, newSVnv(e->crossing.x_root), 0);
		hv_store(h, "y_root", 6, newSVnv(e->crossing.y_root), 0);
		hv_store(h, "detail", 6, newSVGdkNotifyType(e->crossing.detail), 0);
		hv_store(h, "mode", 4, newSVGdkCrossingMode(e->crossing.mode), 0);
		hv_store(h, "focus", 5, newSVnv(e->crossing.focus), 0);
		hv_store(h, "state", 5, newSVnv(e->crossing.state), 0);
		break;
	case GDK_CONFIGURE:
		hv_store(h, "x", 1, newSViv(e->configure.x), 0);
		hv_store(h, "y", 1, newSViv(e->configure.y), 0);
		hv_store(h, "width", 5, newSViv(e->configure.width), 0);
		hv_store(h, "height", 6, newSViv(e->configure.height), 0);
		break;
	case GDK_PROPERTY_NOTIFY:
		hv_store(h, "time", 4, newSViv(e->property.time), 0);
		hv_store(h, "state", 5, newSVnv(e->property.state), 0);
		hv_store(h, "atom", 4, newSVGdkAtom(e->property.atom), 0);
		break;
	case GDK_SELECTION_CLEAR:
	case GDK_SELECTION_REQUEST:
	case GDK_SELECTION_NOTIFY:
		hv_store(h, "requestor", 9, newSViv(e->selection.requestor), 0);
		hv_store(h, "time", 4, newSViv(e->selection.time), 0);
		hv_store(h, "selection", 9, newSVGdkAtom(e->selection.selection), 0);
		hv_store(h, "property", 8, newSVGdkAtom(e->selection.property), 0);
		hv_store(h, "target", 6, newSVGdkAtom(e->selection.target), 0);
		break;
	case GDK_PROXIMITY_IN:
	case GDK_PROXIMITY_OUT:
		hv_store(h, "time", 4, newSViv(e->proximity.time), 0);
		hv_store(h, "source", 6, newSVGdkInputSource(e->proximity.source), 0);
		hv_store(h, "deviceid", 8, newSViv(e->proximity.deviceid), 0);
		break;
	case GDK_CLIENT_EVENT:
		hv_store(h, "message_type", 12, newSVGdkAtom(e->client.message_type), 0);
		hv_store(h, "data_format", 11, newSViv(e->client.data_format), 0);
		hv_store(h, "data", 4, newSVpvn(e->client.data.b, 20), 0);
		break;
	case GDK_DRAG_ENTER:
	case GDK_DRAG_LEAVE:
	case GDK_DRAG_MOTION:
	case GDK_DRAG_STATUS:
	case GDK_DROP_START:
	case GDK_DROP_FINISHED:
		hv_store(h, "time", 4, newSVnv(e->dnd.time), 0);
		hv_store(h, "x_root", 6, newSViv(e->dnd.x_root), 0);
		hv_store(h, "y_root", 6, newSViv(e->dnd.y_root), 0);
		hv_store(h, "context", 7, newSVGdkDragContext(e->dnd.context), 0);
		break;
	default:
		/*g_message("event type %d not handled", e->type);*/
		break;
	}
	
	return r;
}

GdkEvent * SvSetGdkEvent(SV * data, GdkEvent * e)
{
	HV * h;
	SV ** s;

      	if (!data || !SvOK(data) || !(h=(HV*)SvRV(data)) || (SvTYPE(h) != SVt_PVHV))
                return 0;
        
        if (!e)
        	e = pgtk_alloc_temp(sizeof(GdkEvent));
        
        s = hv_fetch(h, "_ptr", 4, 0);
        if (!s || !SvIV(*s))
                croak("event is damaged");
        
	e = (GdkEvent*)SvIV(*s);

        /*printf("Composing GdkEvent HV %d to pointer %d\n", h, e);*/
	
	if ((s=hv_fetch(h, "type", 4, 0)))
		e->type = SvGdkEventType(*s);
	else
		croak("event must contain type");
	if ((s=hv_fetch(h, "window", 6, 0)))
		e->any.window = SvGdkWindow(*s);
	else
		croak("event must contain window");
	if ((s=hv_fetch(h, "send_event", 10, 0)))
		e->any.send_event = SvIV(*s);
	
	switch (e->type) {
	case GDK_MAP:
	case GDK_UNMAP:
	case GDK_DELETE:
	case GDK_DESTROY:
	case GDK_NO_EXPOSE:
		break;
	case GDK_EXPOSE:
		if ((s=hv_fetch(h, "area", 4, 0)))
			SvGdkRectangle(*s, &e->expose.area);
		else
			croak("event must contain area");
		if ((s=hv_fetch(h, "count", 5, 0)))
			e->expose.count = SvIV(*s);
		else
			croak("event must contain count");
		break;
	case GDK_VISIBILITY_NOTIFY:
		if ((s=hv_fetch(h, "state", 5, 0)))
			e->visibility.state = SvGdkVisibilityState(*s);
		else
			croak("event must contain state");
		break;
	case GDK_MOTION_NOTIFY:
		if ((s=hv_fetch(h, "x", 1, 0)))
			e->motion.x = SvNV(*s);
		else
			croak("event must contain x ordinate");
		if ((s=hv_fetch(h, "y", 1, 0)))
			e->motion.y = SvNV(*s);
		else
			croak("event must contain y ordinate");
		if ((s=hv_fetch(h, "pressure", 8, 0)))
			e->motion.pressure = SvNV(*s);
		else
			e->motion.pressure = 0;
		if ((s=hv_fetch(h, "xtilt", 5, 0)))
			e->motion.xtilt = SvNV(*s);
		else
			e->motion.xtilt = 0;
		if ((s=hv_fetch(h, "ytilt", 5, 0)))
			e->motion.ytilt = SvNV(*s);
		else
			e->motion.ytilt = 0;
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->motion.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "state", 5, 0)))
			e->motion.state = SvIV(*s);
		else
			croak("event must contain state");
		if ((s=hv_fetch(h, "is_hint", 7, 0)))
			e->motion.is_hint = SvIV(*s);
		else
			croak("event must contain is_hint");
		if ((s=hv_fetch(h, "source", 6, 0)))
			e->motion.source = SvGdkInputSource(*s);
		else
			e->motion.source = 0;
		if ((s=hv_fetch(h, "deviceid", 8, 0)) && SvOK(*s))
			e->motion.deviceid = SvIV(*s);
		else
			e->motion.deviceid = GDK_CORE_POINTER;
		if ((s=hv_fetch(h, "x_root", 6, 0)))
			e->motion.x_root = SvIV(*s);
		else
			croak("event must contain x_root");
		if ((s=hv_fetch(h, "y_root", 6, 0)))
			e->motion.y_root = SvIV(*s);
		else
			croak("event must contain y_root");
		break;
	case GDK_BUTTON_PRESS:
	case GDK_2BUTTON_PRESS:
	case GDK_3BUTTON_PRESS:
	case GDK_BUTTON_RELEASE:
		if ((s=hv_fetch(h, "x", 1, 0)))
			e->button.x = SvNV(*s);
		else
			croak("event must contain x ordinate");
		if ((s=hv_fetch(h, "y", 1, 0)))
			e->button.y = SvNV(*s);
		else
			croak("event must contain y ordinate");
		if ((s=hv_fetch(h, "pressure", 8, 0)))
			e->button.button = SvNV(*s);
		else
			e->button.pressure = 0;
		if ((s=hv_fetch(h, "xtilt", 5, 0)))
			e->button.xtilt = SvNV(*s);
		else
			e->button.xtilt = 0;
		if ((s=hv_fetch(h, "ytilt", 5, 0)))
			e->button.ytilt = SvNV(*s);
		else
			e->button.ytilt = 0;
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->button.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "state", 5, 0)))
			e->button.state = SvIV(*s);
		else
			croak("event must contain state");
		if ((s=hv_fetch(h, "button", 6, 0)))
			e->button.button = SvIV(*s);
		else
			croak("event must contain state");
		if ((s=hv_fetch(h, "source", 6, 0)))
			e->button.source = SvGdkInputSource(*s);
		else
			e->button.source = 0;
		if ((s=hv_fetch(h, "deviceid", 8, 0)) && SvOK(*s))
			e->button.deviceid = SvIV(*s);
		else
			e->button.deviceid = GDK_CORE_POINTER;
		if ((s=hv_fetch(h, "x_root", 6, 0)))
			e->button.x_root = SvIV(*s);
		else
			croak("event must contain x_root");
		if ((s=hv_fetch(h, "y_root", 6, 0)))
			e->button.y_root = SvIV(*s);
		else
			croak("event must contain y_root");
		break;
	case GDK_KEY_PRESS:
	case GDK_KEY_RELEASE:
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->key.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "state", 5, 0)))
			e->key.state = SvIV(*s);
		else
			croak("event must contain state");
		if ((s=hv_fetch(h, "keyval", 6, 0)))
			e->key.keyval = SvIV(*s);
		else
			croak("event must contain keyval");
		if ((s=hv_fetch(h, "string", 6, 0))) {
			STRLEN len;
			/* FIXME: need to free e->key.string? */
			e->key.string = g_strdup(SvPV(*s, len));
			e->key.length = len;
		} else
			croak("event must contain string");
		break;
	case GDK_FOCUS_CHANGE:
		if ((s=hv_fetch(h, "in", 2, 0)))
			e->focus_change.in = SvIV(*s);
		else
			croak("event must contain in");
		break;
	case GDK_ENTER_NOTIFY:
	case GDK_LEAVE_NOTIFY:
		if ((s=hv_fetch(h, "subwindow", 9, 0)))
			e->crossing.subwindow = SvGdkWindow(*s);
		else
			croak("event must contain subwindow");
		if ((s=hv_fetch(h, "detail", 6, 0)))
			e->crossing.detail = SvGdkNotifyType(*s);
		else
			croak("event must contain detail");
		if ((s=hv_fetch(h, "x", 1, 0)))
			e->crossing.x = SvIV(*s);
		else
			croak("event must contain x ordinate");
		if ((s=hv_fetch(h, "y", 1, 0)))
			e->crossing.y = SvIV(*s);
		else
			croak("event must contain y ordinate");
		if ((s=hv_fetch(h, "x_root", 6, 0)))
			e->crossing.x_root = SvIV(*s);
		else
			croak("event must contain x_root ordinate");
		if ((s=hv_fetch(h, "y_root", 6, 0)))
			e->crossing.y_root = SvIV(*s);
		else
			croak("event must contain y_root ordinate");
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->crossing.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "state", 5, 0)))
			e->crossing.state = SvIV(*s);
		else
			croak("event must contain state");
		if ((s=hv_fetch(h, "mode", 4, 0)))
			e->crossing.time = SvGdkCrossingMode(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "focus", 5, 0)))
			e->crossing.focus = SvIV(*s);
		else
			croak("event must contain focus");
		break;
	case GDK_CONFIGURE:
		if ((s=hv_fetch(h, "x", 1, 0)))
			e->configure.x = SvIV(*s);
		else
			croak("event must contain x ordinate");
		if ((s=hv_fetch(h, "y", 1, 0)))
			e->configure.y = SvIV(*s);
		else
			croak("event must contain y ordinate");
		if ((s=hv_fetch(h, "width", 5, 0)))
			e->configure.width = SvIV(*s);
		else
			croak("event must contain width");
		if ((s=hv_fetch(h, "height", 6, 0)))
			e->configure.height = SvIV(*s);
		else
			croak("event must contain height");
		break;
	case GDK_PROPERTY_NOTIFY:
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->property.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "state", 5, 0)))
			e->property.state = SvIV(*s);
		else
			croak("event must contain state");
		if ((s=hv_fetch(h, "atom", 4, 0)))
			e->property.atom = SvGdkAtom(*s);
		else
			croak("event must contain atom");
		break;
	case GDK_SELECTION_CLEAR:
	case GDK_SELECTION_REQUEST:
	case GDK_SELECTION_NOTIFY:
		if ((s=hv_fetch(h, "requestor", 9, 0)))
			e->selection.requestor = SvIV(*s);
		else
			croak("event must contain requestor");
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->selection.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "selection", 9, 0)))
			e->selection.selection = SvGdkAtom(*s);
		else
			croak("event must contain selection");
		if ((s=hv_fetch(h, "property", 8, 0)))
			e->selection.property = SvGdkAtom(*s);
		else
			croak("event must contain property");
		if ((s=hv_fetch(h, "target", 6, 0)))
			e->selection.target = SvGdkAtom(*s);
		else
			croak("event must contain target");
		break;
	case GDK_PROXIMITY_IN:
	case GDK_PROXIMITY_OUT:
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->proximity.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "deviceid", 8, 0)))
			e->proximity.deviceid = SvIV(*s);
		else
			croak("event must contain deviceid");
		if ((s=hv_fetch(h, "source", 6, 0)))
			e->proximity.source = SvGdkInputSource(*s);
		else
			croak("event must contain source");
		break;
	case GDK_CLIENT_EVENT:
		if ((s=hv_fetch(h, "message_type", 12, 0)))
			e->client.message_type = SvGdkAtom(*s);
		else
			croak("event must contain message_type");
		if ((s=hv_fetch(h, "data_format", 11, 0)))
			e->client.data_format = SvIV(*s);
		else
			croak("event must contain data_format");
		if ((s=hv_fetch(h, "data", 4, 0))) {
			STRLEN len;
			char *p = SvPV(*s, len);
			memcpy(e->client.data.b, p, len>20?20:len);
		} else
			croak("event must contain data");
		break;
	case GDK_DRAG_ENTER:
	case GDK_DRAG_LEAVE:
	case GDK_DRAG_MOTION:
	case GDK_DRAG_STATUS:
	case GDK_DROP_START:
	case GDK_DROP_FINISHED:
		if ((s=hv_fetch(h, "time", 4, 0)))
			e->dnd.time = SvIV(*s);
		else
			croak("event must contain time");
		if ((s=hv_fetch(h, "x_root", 6, 0)))
			e->dnd.x_root = SvIV(*s);
		else
			croak("event must contain x_root");
		if ((s=hv_fetch(h, "y_root", 6, 0)))
			e->dnd.y_root = SvIV(*s);
		else
			croak("event must contain y_root");
		if ((s=hv_fetch(h, "context", 7, 0)))
			e->dnd.context = SvGdkDragContext(*s);
		else
			croak("event must contain context");
		break;
	}
	
	return e;
}

GdkWindowAttr * SvGdkWindowAttr(SV * data, GdkWindowAttr * attr, gint * mask)
{
	dTHR;	

	HV * h;
	SV ** s;

	if ((!data) || (!SvOK(data)) || (!SvRV(data)) || (SvTYPE(SvRV(data)) != SVt_PVHV))
		return 0;
	
	if (!attr)
		attr = pgtk_alloc_temp(sizeof(GdkWindowAttr));
	
	memset(attr, 0, sizeof(GdkWindowAttr));
	
	*mask = 0;

	h = (HV*)SvRV(data);
	
	if ((s=hv_fetch(h, "title", 5, 0))) {
		attr->title = SvPV(*s,PL_na);
		*mask |= GDK_WA_TITLE;
	}
	
	if ((s=hv_fetch(h, "x", 1, 0))) {
		attr->x = SvIV(*s);
		*mask |= GDK_WA_X;
	}
	
	if ((s=hv_fetch(h, "y", 1, 0))) {
		attr->y = SvIV(*s);
		*mask |= GDK_WA_Y;
	}
	
	if ((s=hv_fetch(h, "cursor", 6, 0))) {
		attr->cursor = SvGdkCursorRef(*s);
		*mask |= GDK_WA_CURSOR;
	}
	
	if ((s=hv_fetch(h, "colormap", 8, 0))) {
		attr->colormap = SvGdkColormap(*s);
		*mask |= GDK_WA_COLORMAP;
	}
	
	if ((s=hv_fetch(h, "visual", 6, 0))) {
		attr->visual = SvGdkVisual(*s);
		*mask |= GDK_WA_VISUAL;
	}

	if ((s=hv_fetch(h, "window_type",11, 0)))
		attr->window_type = SvGdkWindowType(*s);
	else
		croak("window attribute must have window_type");
	if ((s=hv_fetch(h, "event_mask",10, 0)))
		attr->event_mask = SvGdkEventMask(*s);
	else
		croak("window attribute must have event_mask");
	if ((s=hv_fetch(h, "width",5, 0)))
		attr->width = SvIV(*s);
	else
		croak("window attribute must have width");
	if ((s=hv_fetch(h, "height",6, 0)))
		attr->height = SvIV(*s);
	else
		croak("window attribute must have height");
	if ((s=hv_fetch(h, "wclass",6, 0)))
		attr->wclass = SvGdkWindowClass(*s);
	else
		attr->wclass = GDK_INPUT_OUTPUT;

	return attr;
}

#if GTK_HVER >= 0x010200

SV * newSVGdkDragContextRef(GdkDragContext* f) { return newSVMiscRef(f, "Gtk::Gdk::DragContext", 0); }
GdkDragContext* SvGdkDragContextRef(SV * data) { return SvMiscRef(data, "Gtk::Gdk::DragContext"); }

#endif