/* PyGTK - python bindings for GTK+
 * Copyright (C) 1997-1999 James Henstridge <james@daa.com.au>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <Python.h>
#include <sysmodule.h>
#include <gtk/gtk.h>

typedef struct {
  PyObject_HEAD
  GtkObject *obj;
} PyGtk_Object;

staticforward PyTypeObject PyGtk_Type;

#define PyGtk_Check(v) ((v)->ob_type == &PyGtk_Type)
#define PyGtk_Get(v) (((PyGtk_Object *)(v))->obj)

static PyObject *
PyGtk_New(GtkObject *go) {
  PyGtk_Object *self;

  self = (PyGtk_Object *)PyObject_NEW(PyGtk_Object, &PyGtk_Type);
  if (self == NULL)
    return NULL;
  self->obj = go;
  gtk_object_ref(self->obj);
  return (PyObject *)self;
}

static void 
PyGtk_dealloc(PyGtk_Object *self) {
  gtk_object_unref(self->obj);
  PyMem_DEL(self);
}

static int
PyGtk_compare(PyGtk_Object *self, PyGtk_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyObject *
PyGtk_repr(PyGtk_Object *self) {
  char buf[100];

  sprintf(buf, "<GtkObject of type %s at %lx>",
    gtk_type_name(PyGtk_Get(self)->klass->type), (long)PyGtk_Get(self));
  return PyString_FromString(buf);
}

static char PyGtk_Type__doc__[] = "This is the type of GTK Objects";

static PyTypeObject PyGtk_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,                              /*ob_size*/
  "GtkObject",                    /*tp_name*/
  sizeof(PyGtk_Object),           /*tp_basicsize*/
  0,                              /*tp_itemsize*/
  (destructor)PyGtk_dealloc,      /*tp_dealloc*/
  (printfunc)0,                   /*tp_print*/
  (getattrfunc)0,                 /*tp_getattr*/
  (setattrfunc)0,                 /*tp_setattr*/
  (cmpfunc)PyGtk_compare,         /*tp_compare*/
  (reprfunc)PyGtk_repr,           /*tp_repr*/
  0,                              /*tp_as_number*/
  0,                              /*tp_as_sequence*/
  0,                              /*tp_as_mapping*/
  (hashfunc)0,                    /*tp_hash*/
  (ternaryfunc)0,                 /*tp_call*/
  (reprfunc)0,                    /*tp_str*/
  0L,0L,0L,0L,
  PyGtk_Type__doc__
};

/* return 1 on failure */
gint PyGtkEnum_get_value(GtkType enum_type, PyObject *obj, int *val) {
  if (PyInt_Check(obj)) {
    *val = PyInt_AsLong(obj);
    return 0;
  } else if (PyString_Check(obj)) {
    GtkEnumValue *info = gtk_type_enum_find_value(enum_type,
						  PyString_AsString(obj));
    if (!info) {
      PyErr_SetString(PyExc_TypeError, "couldn't translate string");
      return 1;
    }
    *val = info->value;
    return 0;
  }
  PyErr_SetString(PyExc_TypeError, "enum values must be integers or strings");
  return 1;
}

gint PyGtkFlag_get_value(GtkType flag_type, PyObject *obj, int *val) {
  if (PyInt_Check(obj)) {
    *val = PyInt_AsLong(obj);
    return 0;
  } else if (PyString_Check(obj)) {
    GtkFlagValue *info = gtk_type_flags_find_value(flag_type,
						  PyString_AsString(obj));
    if (!info) {
      PyErr_SetString(PyExc_TypeError, "couldn't translate string");
      return 1;
    }
    *val = info->value;
    return 0;
  } else if (PyTuple_Check(obj)) {
    int i, len;
    PyObject *item;
    len = PyTuple_Size(obj);
    *val = 0;
    for (i = 0; i < len; i++) {
      item = PyTuple_GetItem(obj, i);
      if (PyInt_Check(item))
	*val |= PyInt_AsLong(item);
      else if (PyString_Check(item)) {
	GtkFlagValue *info = gtk_type_flags_find_value(flag_type,
						      PyString_AsString(item));
	if (!info) {
	  PyErr_SetString(PyExc_TypeError, "couldn't translate string");
	  return 1;
	}
	*val |= info->value;
      } else {
	PyErr_SetString(PyExc_TypeError,
			"tuple components must be ints or strings");
	return 1;
      }
    }
    return 0;
  }
  PyErr_SetString(PyExc_TypeError,
		  "flag values must be ints, strings or tuples");
  return 1;
}


typedef struct {
    PyObject_HEAD
    GtkAccelGroup *obj;
} PyGtkAccelGroup_Object;
staticforward PyTypeObject PyGtkAccelGroup_Type;

typedef struct {
    PyObject_HEAD
    GtkStyle *obj;
} PyGtkStyle_Object;
staticforward PyTypeObject PyGtkStyle_Type;

typedef struct {
    PyObject_HEAD
    GdkFont *obj;
} PyGdkFont_Object;
staticforward PyTypeObject PyGdkFont_Type;

typedef struct {
    PyObject_HEAD
    GdkColor obj;
} PyGdkColor_Object;
staticforward PyTypeObject PyGdkColor_Type;

typedef struct {
    PyObject_HEAD
    GdkEvent *obj;
    PyObject *attrs;
} PyGdkEvent_Object;
staticforward PyTypeObject PyGdkEvent_Type;

typedef struct {
    PyObject_HEAD
    GdkWindow *obj;
} PyGdkWindow_Object;
staticforward PyTypeObject PyGdkWindow_Type;

typedef struct {
    PyObject_HEAD
    GdkGC *obj;
} PyGdkGC_Object;
staticforward PyTypeObject PyGdkGC_Type;

typedef struct {
    PyObject_HEAD
    GdkColormap *obj;
} PyGdkColormap_Object;
staticforward PyTypeObject PyGdkColormap_Type;

typedef struct {
    PyObject_HEAD
    GdkDragContext *obj;
} PyGdkDragContext_Object;
staticforward PyTypeObject PyGdkDragContext_Type;

typedef struct {
    PyObject_HEAD
    GtkSelectionData *obj;
} PyGtkSelectionData_Object;
staticforward PyTypeObject PyGtkSelectionData_Type;

typedef struct {
    PyObject_HEAD
    gchar *name;
    GdkAtom atom;
} PyGdkAtom_Object;
staticforward PyTypeObject PyGdkAtom_Type;

typedef struct {
    PyObject_HEAD
    GdkCursor *obj;
} PyGdkCursor_Object;
staticforward PyTypeObject PyGdkCursor_Type;

typedef struct {
    PyObject_HEAD
    GtkCTreeNode *node;
} PyGtkCTreeNode_Object;
staticforward PyTypeObject PyGtkCTreeNode_Type;

#define PyGtkAccelGroup_Check(v) ((v)->ob_type == &PyGtkAccelGroup_Type)
#define PyGtkAccelGroup_Get(v) (((PyGtkAccelGroup_Object *)(v))->obj)
#define PyGtkStyle_Check(v) ((v)->ob_type == &PyGtkStyle_Type)
#define PyGtkStyle_Get(v) (((PyGtkStyle_Object *)(v))->obj)
#define PyGdkFont_Check(v) ((v)->ob_type == &PyGdkFont_Type)
#define PyGdkFont_Get(v) (((PyGdkFont_Object *)(v))->obj)
#define PyGdkColor_Check(v) ((v)->ob_type == &PyGdkColor_Type)
#define PyGdkColor_Get(v) (&((PyGdkColor_Object *)(v))->obj)
#define PyGdkEvent_Check(v) ((v)->ob_type == &PyGdkEvent_Type)
#define PyGdkEvent_Get(v) (((PyGdkEvent_Object *)(v))->obj)
#define PyGdkWindow_Check(v) ((v)->ob_type == &PyGdkWindow_Type)
#define PyGdkWindow_Get(v) (((PyGdkWindow_Object *)(v))->obj)
#define PyGdkGC_Check(v) ((v)->ob_type == &PyGdkGC_Type)
#define PyGdkGC_Get(v) (((PyGdkGC_Object *)(v))->obj)
#define PyGdkColormap_Check(v) ((v)->ob_type == &PyGdkColormap_Type)
#define PyGdkColormap_Get(v) (((PyGdkColormap_Object *)(v))->obj)
#define PyGdkDragContext_Check(v) ((v)->ob_type == &PyGdkDragContext_Type)
#define PyGdkDragContext_Get(v) (((PyGdkDragContext_Object *)(v))->obj)
#define PyGtkSelectionData_Check(v) ((v)->ob_type == &PyGtkSelectionData_Type)
#define PyGtkSelectionData_Get(v) (((PyGtkSelectionData_Object *)(v))->obj)
#define PyGdkAtom_Check(v) ((v)->ob_type == &PyGdkAtom_Type)
#define PyGdkAtom_Get(v) (((PyGdkAtom_Object *)(v))->atom)
#define PyGdkCursor_Check(v) ((v)->ob_type == &PyGdkCursor_Type)
#define PyGdkCursor_Get(v) (((PyGdkCursor_Object *)(v))->obj)
#define PyGtkCTreeNode_Check(v) ((v)->ob_type == &PyGtkCTreeNode_Type)
#define PyGtkCTreeNode_Get(v) (((PyGtkCTreeNode_Object *)(v))->node)

static PyObject *
PyGtkAccelGroup_New(GtkAccelGroup *obj) {
  PyGtkAccelGroup_Object  *self;

  self = (PyGtkAccelGroup_Object *)PyObject_NEW(PyGtkAccelGroup_Object ,
              &PyGtkAccelGroup_Type);
  if (self == NULL)
    return NULL;
  self->obj = obj;
  gtk_accel_group_ref(self->obj);
  return (PyObject *)self;
}

static PyObject *
PyGtkStyle_New(GtkStyle *obj) {
  PyGtkStyle_Object *self;

  self = (PyGtkStyle_Object *)PyObject_NEW(PyGtkStyle_Object,
                                           &PyGtkStyle_Type);
  if (self == NULL)
    return NULL;
  self->obj = obj;
  gtk_style_ref(self->obj);
  return (PyObject *)self;
}

static PyObject *
PyGdkFont_New(GdkFont *obj) {
  PyGdkFont_Object *self;

  self = (PyGdkFont_Object *)PyObject_NEW(PyGdkFont_Object, &PyGdkFont_Type);
  if (self == NULL)
    return NULL;
  self->obj = obj;
  gdk_font_ref(self->obj);
  return (PyObject *)self;
}

static PyObject *
PyGdkColor_New(GdkColor *obj) {
  PyGdkColor_Object *self;

  self = (PyGdkColor_Object *)PyObject_NEW(PyGdkColor_Object,&PyGdkColor_Type);
  if (self == NULL)
    return NULL;
  self->obj.pixel = obj->pixel;
  self->obj.red   = obj->red;
  self->obj.green = obj->green;
  self->obj.blue  = obj->blue;
  return (PyObject *)self;
}

static PyObject *
PyGdkWindow_New(GdkWindow *win) {
  PyGdkWindow_Object *self;

  self = (PyGdkWindow_Object *)PyObject_NEW(PyGdkWindow_Object,
					    &PyGdkWindow_Type);
  if (self == NULL)
    return NULL;
  self->obj = win;
  gdk_window_ref(self->obj);
  return (PyObject *)self;
}

static PyObject *
PyGdkGC_New(GdkGC *gc) {
  PyGdkGC_Object *self;

  self = (PyGdkGC_Object *)PyObject_NEW(PyGdkGC_Object, &PyGdkGC_Type);
  if (self == NULL)
    return NULL;
  self->obj = gc;
  gdk_gc_ref(self->obj);
  return (PyObject *)self;
}

static PyObject *
PyGdkColormap_New(GdkColormap *cmap) {
  PyGdkColormap_Object *self;

  self = (PyGdkColormap_Object *)PyObject_NEW(PyGdkColormap_Object,
					      &PyGdkColormap_Type);
  if (self == NULL)
    return NULL;
  self->obj = cmap;
  gdk_colormap_ref(self->obj);
  return (PyObject *)self;
}

static PyObject *
PyGdkDragContext_New(GdkDragContext *ctx) {
  PyGdkDragContext_Object *self;

  self = (PyGdkDragContext_Object *)PyObject_NEW(PyGdkDragContext_Object,
						 &PyGdkDragContext_Type);
  if (!self)
    return NULL;
  self->obj = ctx;
  gdk_drag_context_ref(self->obj);
  return (PyObject *)self;
}

static PyObject *
PyGtkSelectionData_New(GtkSelectionData *data) {
  PyGtkSelectionData_Object *self;

  self = (PyGtkSelectionData_Object *)PyObject_NEW(PyGtkSelectionData_Object,
						   &PyGtkSelectionData_Type);
  if (!self)
    return NULL;
  self->obj = data;
  return (PyObject *)self;
}

static PyObject *
PyGdkAtom_New(GdkAtom atom) {
  PyGdkAtom_Object *self;

  self = (PyGdkAtom_Object *)PyObject_NEW(PyGdkAtom_Object, &PyGdkAtom_Type);
  if (!self)
    return NULL;
  self->atom = atom;
  self->name = NULL;
  return (PyObject *)self;
}

static PyObject *
PyGdkCursor_New(GdkCursor *obj) {
  PyGdkCursor_Object *self;

  self = (PyGdkCursor_Object *)PyObject_NEW(PyGdkCursor_Object,
					    &PyGdkCursor_Type);
  if (!self)
    return NULL;
  self->obj = obj;
  return (PyObject *)self;
}

static PyObject *
PyGtkCTreeNode_New(GtkCTreeNode *node) {
  PyGtkCTreeNode_Object *self;

  self = (PyGtkCTreeNode_Object *)PyObject_NEW(PyGtkCTreeNode_Object,
					       &PyGtkCTreeNode_Type);
  if (!self)
    return NULL;
  self->node = node;
  return (PyObject *)self;
}

static void
PyGtkAccelGroup_Dealloc(PyGtkAccelGroup_Object *self) {
  gtk_accel_group_unref(self->obj); 
  PyMem_DEL(self);
}

static int
PyGtkAccelGroup_Compare(PyGtkAccelGroup_Object *self,
                            PyGtkAccelGroup_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyTypeObject PyGtkAccelGroup_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GtkAccelGroup",
  sizeof(PyGtkAccelGroup_Object),
  0,
  (destructor)PyGtkAccelGroup_Dealloc,
  (printfunc)0,
  (getattrfunc)0,
  (setattrfunc)0,
  (cmpfunc)PyGtkAccelGroup_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGtkStyle_Dealloc(PyGtkStyle_Object *self) {
  gtk_style_unref(self->obj);
  PyMem_DEL(self);
}

static int
PyGtkStyle_Compare(PyGtkStyle_Object *self, PyGtkStyle_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyObject *PyGtkStyle_GetAttr(PyGtkStyle_Object *self, char *attr) {
  GtkStyle *style = self->obj;
  PyObject *ret;
  int i;

  if (!strcmp(attr, "__members__"))
    return Py_BuildValue("[sssssssssssssssssssss]", "base", "base_gc", "bg",
			 "bg_gc", "bg_pixmap", "black", "black_gc", "colormap",
			 "dark", "dark_gc", "fg", "fg_gc", "font", "light",
			 "light_gc", "mid", "mid_gc", "text", "text_gc",
			 "white", "white_gc");
  if (!strcmp(attr, "fg")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkColor_New(&style->fg[i]));
    return ret;
  }
  if (!strcmp(attr, "bg")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkColor_New(&style->bg[i]));
    return ret;
  }
  if (!strcmp(attr, "light")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkColor_New(&style->light[i]));
    return ret;
  }
  if (!strcmp(attr, "dark")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkColor_New(&style->dark[i]));
    return ret;
  }
  if (!strcmp(attr, "mid")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkColor_New(&style->mid[i]));
    return ret;
  }
  if (!strcmp(attr, "text")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkColor_New(&style->text[i]));
    return ret;
  }
  if (!strcmp(attr, "base")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkColor_New(&style->base[i]));
    return ret;
  }
  if (!strcmp(attr, "black"))
    return PyGdkColor_New(&style->black);
  if (!strcmp(attr, "white"))
    return PyGdkColor_New(&style->white);
  if (!strcmp(attr, "font"))
    return PyGdkFont_New(style->font);
  if (!strcmp(attr, "fg_gc")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkGC_New(style->fg_gc[i]));
    return ret;
  }
  if (!strcmp(attr, "bg_gc")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkGC_New(style->bg_gc[i]));
    return ret;
  }
  if (!strcmp(attr, "light_gc")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkGC_New(style->light_gc[i]));
    return ret;
  }
  if (!strcmp(attr, "dark_gc")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkGC_New(style->dark_gc[i]));
    return ret;
  }
  if (!strcmp(attr, "mid_gc")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkGC_New(style->mid_gc[i]));
    return ret;
  }
  if (!strcmp(attr, "text_gc")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkGC_New(style->text_gc[i]));
    return ret;
  }
  if (!strcmp(attr, "base_gc")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i, PyGdkGC_New(style->base_gc[i]));
    return ret;
  }
  if (!strcmp(attr, "black_gc"))
    return PyGdkGC_New(style->black_gc);
  if (!strcmp(attr, "white_gc"))
    return PyGdkGC_New(style->white_gc);
  if (!strcmp(attr, "bg_pixmap")) {
    ret = PyTuple_New(5);
    for (i = 0; i < 5; i++)
      PyTuple_SetItem(ret, i,PyGdkWindow_New(style->bg_pixmap[i]));
    return ret;
  }
  if (!strcmp(attr, "colormap")) {
    if (style->colormap)
      return PyGdkColormap_New(style->colormap);
    Py_INCREF(Py_None);
    return Py_None;
  }

  PyErr_SetString(PyExc_AttributeError, attr);
  return NULL;
}

static PyTypeObject PyGtkStyle_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GtkStyle",
  sizeof(PyGtkStyle_Object),
  0,
  (destructor)PyGtkStyle_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGtkStyle_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGtkStyle_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkFont_Dealloc(PyGdkFont_Object *self) {
  gdk_font_unref(self->obj);
  PyMem_DEL(self);
}

static PyObject *
PyGdkFont_Width(PyGdkFont_Object *self, PyObject *args) {
  char *text;
  int length;

  if (!PyArg_ParseTuple(args, "s#:GdkFont.width", &text, &length))
    return NULL;
  return PyInt_FromLong(gdk_text_width(self->obj, text, length));
}

static PyObject *
PyGdkFont_Measure(PyGdkFont_Object *self, PyObject *args) {
  char *text;
  int length;

  if (!PyArg_ParseTuple(args, "s#:GdkFont.measure", &text, &length))
    return NULL;
  return PyInt_FromLong(gdk_text_measure(self->obj, text, length));
}

static PyObject *
PyGdkFont_Height(PyGdkFont_Object *self, PyObject *args) {
  char *text;
  int length;

  if (!PyArg_ParseTuple(args, "s#:GdkFont.height", &text, &length))
    return NULL;
  return PyInt_FromLong(gdk_text_height(self->obj, text, length));
}

static PyObject *
PyGdkFont_Extents(PyGdkFont_Object *self, PyObject *args) {
  char *text;
  int length, lbearing, rbearing, width, ascent, descent;
  if (!PyArg_ParseTuple(args, "s#:GdkFont.extents", &text, &length))
    return NULL;
  gdk_text_extents(self->obj, text, length, &lbearing, &rbearing,
		   &width, &ascent, &descent);
  return Py_BuildValue("(iiiii)", lbearing, rbearing, width, ascent, descent);
}

static PyMethodDef PyGdkFont_methods[] = {
  {"width",   (PyCFunction)PyGdkFont_Width,   METH_VARARGS, NULL},
  {"measure", (PyCFunction)PyGdkFont_Measure, METH_VARARGS, NULL},
  {"height",  (PyCFunction)PyGdkFont_Height,  METH_VARARGS, NULL},
  {"extents", (PyCFunction)PyGdkFont_Extents, METH_VARARGS, NULL},
  {NULL, 0, 0, NULL}
};

static PyObject *
PyGdkFont_GetAttr(PyGdkFont_Object *self, char *key) {
  if (!strcmp(key, "__members__"))
    return Py_BuildValue("[sss]", "ascent", "descent", "type");
  if (!strcmp(key, "ascent"))
    return PyInt_FromLong(self->obj->ascent);
  if (!strcmp(key, "descent"))
    return PyInt_FromLong(self->obj->descent);
  if (!strcmp(key, "type"))
    return PyInt_FromLong(self->obj->type);
  return Py_FindMethod(PyGdkFont_methods, (PyObject *)self, key);
}

static int
PyGdkFont_Compare(PyGdkFont_Object *self, PyGdkFont_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyTypeObject PyGdkFont_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkFont",
  sizeof(PyGdkFont_Object),
  0,
  (destructor)PyGdkFont_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGdkFont_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGdkFont_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkColor_Dealloc(PyGdkColor_Object *self) {
  PyMem_DEL(self);
}

static PyObject *
PyGdkColor_GetAttr(PyGdkColor_Object *self, char *key) {
  if (!strcmp(key, "red"))
    return PyInt_FromLong(self->obj.red);
  if (!strcmp(key, "green"))
    return PyInt_FromLong(self->obj.green);
  if (!strcmp(key, "blue"))
    return PyInt_FromLong(self->obj.blue);
  if (!strcmp(key, "pixel"))
    return PyInt_FromLong(self->obj.pixel);
  PyErr_SetString(PyExc_AttributeError, key);
  return NULL;
}

static int
PyGdkColor_Compare(PyGdkColor_Object *self, PyGdkColor_Object *v) {
  if (self->obj.pixel == v->obj.pixel) return 0;
  if (self->obj.pixel > v->obj.pixel) return -1;
  return 1;
}

static PyObject *
PyGdkColor_Repr(PyGdkColor_Object *self) {
  char buf[80];

  g_snprintf(buf, 79, "<GdkColor (%hu, %hu, %hu)>", self->obj.red,
	     self->obj.green, self->obj.blue);
  return PyString_FromString(buf);
}

static PyTypeObject PyGdkColor_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkColor",
  sizeof(PyGdkColor_Object),
  0,
  (destructor)PyGdkColor_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGdkColor_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGdkColor_Compare,
  (reprfunc)PyGdkColor_Repr,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static PyObject *
PyGdkEvent_New(GdkEvent *obj) {
  PyGdkEvent_Object *self;
  PyObject *v;

  if (obj == NULL) {
    Py_INCREF(Py_None);
    return Py_None;
  }
  self = (PyGdkEvent_Object *)PyObject_NEW(PyGdkEvent_Object,&PyGdkEvent_Type);
  if (self == NULL)
    return NULL;
  self->obj = obj;
  self->attrs = PyDict_New();
  PyDict_SetItemString(self->attrs, "type", v=PyInt_FromLong(obj->type));
  Py_DECREF(v);
  if (obj->any.window) {
    PyDict_SetItemString(self->attrs, "window", v=PyGdkWindow_New(
						  obj->any.window));
    Py_DECREF(v);
  } else
    PyDict_SetItemString(self->attrs, "window", Py_None);
  PyDict_SetItemString(self->attrs, "send_event", v=PyInt_FromLong(
    obj->any.send_event));
  Py_DECREF(v);
  /* XXX Does anyone need the window attribute?? */
  switch(obj->type) {
  case GDK_NOTHING: break;
  case GDK_DELETE: break;
  case GDK_DESTROY: break;
  case GDK_EXPOSE:            /*GdkEventExpose            expose*/
    PyDict_SetItemString(self->attrs, "area", v=Py_BuildValue("(iiii)",
		obj->expose.area.x, obj->expose.area.y, obj->expose.area.width,
		obj->expose.area.height));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "count", v=PyInt_FromLong(
        obj->expose.count));
    Py_DECREF(v);
    break;
  case GDK_MOTION_NOTIFY:     /*GdkEventMotion            motion*/
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(
		obj->motion.time));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs,"x",v=PyFloat_FromDouble(obj->motion.x));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs,"y",v=PyFloat_FromDouble(obj->motion.y));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "pressure", v=PyFloat_FromDouble(
        obj->motion.pressure));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "xtilt", v=PyFloat_FromDouble(
        obj->motion.xtilt));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "ytilt", v=PyFloat_FromDouble(
        obj->motion.ytilt));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "state", v=PyInt_FromLong(
        obj->motion.state));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "is_hint", v=PyInt_FromLong(
        obj->motion.is_hint));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "source", v=PyInt_FromLong(
        obj->motion.source));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "deviceid", v=PyInt_FromLong(
        obj->motion.deviceid));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "x_root", v=PyFloat_FromDouble(
        obj->motion.x_root));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "y_root", v=PyFloat_FromDouble(
        obj->motion.y_root));
    Py_DECREF(v);
    break;
  case GDK_BUTTON_PRESS:      /*GdkEventButton            button*/
  case GDK_2BUTTON_PRESS:     /*GdkEventButton            button*/
  case GDK_3BUTTON_PRESS:     /*GdkEventButton            button*/
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(
        obj->button.time));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs,"x",v=PyFloat_FromDouble(obj->button.x));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs,"y",v=PyFloat_FromDouble(obj->button.y));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "pressure", v=PyFloat_FromDouble(
        obj->button.pressure));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "xtilt", v=PyFloat_FromDouble(
        obj->button.xtilt));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "ytilt", v=PyFloat_FromDouble(
        obj->button.ytilt));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "state", v=PyInt_FromLong(
        obj->button.state));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "button", v=PyInt_FromLong(
        obj->button.button));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "source", v=PyInt_FromLong(
        obj->button.source));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "deviceid", v=PyInt_FromLong(
        obj->button.deviceid));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "x_root", v=PyFloat_FromDouble(
        obj->button.x_root));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "y_root", v=PyFloat_FromDouble(
        obj->button.y_root));
    Py_DECREF(v);
    break;
  case GDK_KEY_PRESS:         /*GdkEventKey               key*/
  case GDK_KEY_RELEASE:       /*GdkEventKey               key*/
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(
							obj->key.time));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "state", v=PyInt_FromLong(
        obj->key.state));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "keyval", v=PyInt_FromLong(
        obj->key.keyval));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "string", v=PyString_FromStringAndSize(
        obj->key.string, obj->key.length));
    Py_DECREF(v);
    break;
  case GDK_ENTER_NOTIFY:      /*GdkEventCrossing          crossing*/
  case GDK_LEAVE_NOTIFY:      /*GdkEventCrossing          crossing*/
    if (obj->crossing.subwindow) {
      PyDict_SetItemString(self->attrs, "subwindow", v=PyGdkWindow_New(
						obj->crossing.subwindow));
      Py_DECREF(v);
    } else
      PyDict_SetItemString(self->attrs, "subwindow", Py_None);
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(
						obj->crossing.time));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "x", v=PyFloat_FromDouble(
						obj->crossing.x));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "y", v=PyFloat_FromDouble(
						obj->crossing.y));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "x_root", v=PyFloat_FromDouble(
						obj->crossing.x_root));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "y_root", v=PyFloat_FromDouble(
						obj->crossing.y_root));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "mode", v=PyInt_FromLong(
						obj->crossing.mode));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "detail", v=PyInt_FromLong(
        obj->crossing.detail));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "focus", v=PyInt_FromLong(
						obj->crossing.focus));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "state", v=PyInt_FromLong(
						obj->crossing.state));
    Py_DECREF(v);
    break;
  case GDK_FOCUS_CHANGE:      /*GdkEventFocus             focus_change*/
    PyDict_SetItemString(self->attrs, "_in", v=PyInt_FromLong(
        obj->focus_change.in));
    Py_DECREF(v);
    break;
  case GDK_CONFIGURE:         /*GdkEventConfigure         configure*/
    PyDict_SetItemString(self->attrs, "x", v=PyInt_FromLong(obj->configure.x));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "y", v=PyInt_FromLong(obj->configure.y));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "width", v=PyInt_FromLong(
        obj->configure.width));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "height", v=PyInt_FromLong(
        obj->configure.height));
    Py_DECREF(v);
    break;
  case GDK_MAP: break;
  case GDK_UNMAP: break;
  case GDK_PROPERTY_NOTIFY:   /*GdkEventProperty          property*/
    PyDict_SetItemString(self->attrs, "atom", v=PyGdkAtom_New(
        obj->property.atom));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(
        obj->property.time));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "state", v=PyInt_FromLong(
        obj->property.state));
    Py_DECREF(v);
    break;
  case GDK_SELECTION_CLEAR:   /*GdkEventSelection         selection*/
  case GDK_SELECTION_REQUEST: /*GdkEventSelection         selection*/
  case GDK_SELECTION_NOTIFY:  /*GdkEventSelection         selection*/
    PyDict_SetItemString(self->attrs, "selection", v=PyGdkAtom_New(
        obj->selection.selection));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "target", v=PyGdkAtom_New(
        obj->selection.target));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "property", v=PyGdkAtom_New(
        obj->selection.property));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "requestor", v=PyInt_FromLong(
        obj->selection.requestor));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(
        obj->selection.time));
    Py_DECREF(v);
    break;
  case GDK_PROXIMITY_IN:      /*GdkEventProximity         proximity*/
  case GDK_PROXIMITY_OUT:     /*GdkEventProximity         proximity*/
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(
        obj->proximity.time));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "source", v=PyInt_FromLong(
        obj->proximity.source));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "deviceid", v=PyInt_FromLong(
        obj->proximity.deviceid));
    Py_DECREF(v);
    break;
  case GDK_DRAG_ENTER:        /*GdkEventDND               dnd*/
  case GDK_DRAG_LEAVE:        /*GdkEventDND               dnd*/
  case GDK_DRAG_MOTION:       /*GdkEventDND               dnd*/
  case GDK_DRAG_STATUS:       /*GdkEventDND               dnd*/
  case GDK_DROP_START:        /*GdkEventDND               dnd*/
  case GDK_DROP_FINISHED:     /*GdkEventDND               dnd*/
    PyDict_SetItemString(self->attrs, "context", v=PyGdkDragContext_New(
	obj->dnd.context));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "time", v=PyInt_FromLong(obj->dnd.time));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "x_root", v=PyInt_FromLong(
	obj->dnd.x_root));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "y_root", v=PyInt_FromLong(
	obj->dnd.y_root));
    Py_DECREF(v);
    break;
  case GDK_CLIENT_EVENT:      /*GdkEventClient            client*/
    PyDict_SetItemString(self->attrs, "message_type", v=PyGdkAtom_New(
        obj->client.message_type));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "data_format", v=PyInt_FromLong(
        obj->client.data_format));
    Py_DECREF(v);
    PyDict_SetItemString(self->attrs, "data", v=PyString_FromStringAndSize(
        obj->client.data.b, 20));
    Py_DECREF(v);
    break;
  case GDK_VISIBILITY_NOTIFY: /*GdkEventVisibility        visibility*/
    PyDict_SetItemString(self->attrs, "state", v=PyInt_FromLong(
        obj->visibility.state));
    Py_DECREF(v);
    break;
  case GDK_NO_EXPOSE:         /*GdkEventNoExpose          no_expose*/
    break;
  default:
    break;
  }
  return (PyObject *)self;
}

static void
PyGdkEvent_Dealloc(PyGdkEvent_Object *self) {
  Py_XDECREF(self->attrs);
  PyMem_DEL(self);
}

static PyObject *
PyGdkEvent_GetAttr(PyGdkEvent_Object *self, char *attr) {
  PyObject *ret;
  ret = PyDict_GetItemString(self->attrs, attr);
  if (ret != NULL) {
    Py_INCREF(ret);
    return ret;
  }
  PyErr_SetString(PyExc_AttributeError, attr);
  return NULL;
}

static int
PyGdkEvent_Compare(PyGdkEvent_Object *self, PyGdkEvent_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyTypeObject PyGdkEvent_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkEvent",
  sizeof(PyGdkEvent_Object),
  0,
  (destructor)PyGdkEvent_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGdkEvent_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGdkEvent_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkWindow_Dealloc(PyGdkWindow_Object *self) {
  if (gdk_window_get_type(self->obj) == GDK_WINDOW_PIXMAP)
    gdk_pixmap_unref(self->obj);
  else
    gdk_window_unref(self->obj);
  PyMem_DEL(self);
}

static int
PyGdkWindow_Compare(PyGdkWindow_Object *self, PyGdkWindow_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyObject *
PyGdkWindow_Repr(PyGdkWindow_Object *self) {
  char buf[100];
  if (gdk_window_get_type(self->obj) == GDK_WINDOW_PIXMAP)
    sprintf(buf, "<GdkPixmap at %lx>", (long)PyGdkWindow_Get(self));
  else
    sprintf(buf, "<GdkWindow at %lx>", (long)PyGdkWindow_Get(self));
  return PyString_FromString(buf);
}

static PyObject *
PyGdkWindow_NewGC(PyGdkWindow_Object *self, PyObject *args, PyObject *kws) {
  int i = 0;
  PyObject *key, *value;
  char *strkey;
  GdkGCValues values;
  GdkGCValuesMask mask = 0;
  GdkGC *gc;

  if (kws != NULL)
    while (PyDict_Next(kws, &i, &key, &value)) {
      strkey = PyString_AsString(key);
      if (!strcmp(strkey, "foreground")) {
	if (!PyGdkColor_Check(value)) {
	  PyErr_SetString(PyExc_TypeError, "foreground argument takes a GdkColor");
	  return NULL;
	}
	mask |= GDK_GC_FOREGROUND;
	values.foreground.red = PyGdkColor_Get(value)->red;
	values.foreground.green = PyGdkColor_Get(value)->green;
	values.foreground.blue = PyGdkColor_Get(value)->blue;
	values.foreground.pixel = PyGdkColor_Get(value)->pixel;
      } else if (!strcmp(strkey, "background")) {
	if (!PyGdkColor_Check(value)) {
	  PyErr_SetString(PyExc_TypeError, "background argument takes a GdkColor");
	  return NULL;
	}
	mask |= GDK_GC_BACKGROUND;
	values.background.red = PyGdkColor_Get(value)->red;
	values.background.green = PyGdkColor_Get(value)->green;
	values.background.blue = PyGdkColor_Get(value)->blue;
	values.background.pixel = PyGdkColor_Get(value)->pixel;
      } else if (!strcmp(strkey, "font")) {
	if (!PyGdkFont_Check(value)) {
	  PyErr_SetString(PyExc_TypeError, "font argument takes a GdkFont");
	  return NULL;
	}
	mask |= GDK_GC_FONT;
	values.font = PyGdkFont_Get(value);
      } else if (!strcmp(strkey, "tile")) {
	if (!PyGdkWindow_Check(value)) {
	  PyErr_SetString(PyExc_TypeError, "tile argument takes a GdkPixmap");
	  return NULL;
	}
	mask |= GDK_GC_TILE;
	values.tile = PyGdkWindow_Get(value);
      } else if (!strcmp(strkey, "stipple")) {
	if (!PyGdkWindow_Check(value)) {
	  PyErr_SetString(PyExc_TypeError, "stipple argument takes a GdkPixmap");
	  return NULL;
	}
	mask |= GDK_GC_STIPPLE;
	values.stipple = PyGdkWindow_Get(value);
      } else if (!strcmp(strkey, "clip_mask")) {
	if (!PyGdkWindow_Check(value)) {
	  PyErr_SetString(PyExc_TypeError, "clip_mask argument takes a GdkPixmap");
	  return NULL;
	}
	mask |= GDK_GC_CLIP_MASK;
	values.clip_mask = PyGdkWindow_Get(value);
      } else {
	int i = 0;
#ifndef offsetof
#define offsetof(type, member) ( (int) &((type*)0)->member)
#endif
#define OFF(x) offsetof(GdkGCValues, x)
	static struct {char *name;GdkGCValuesMask mask;int offs; } others[] = {
	  {"function", GDK_GC_FUNCTION, OFF(function)},
	  {"fill",     GDK_GC_FILL,     OFF(fill)},
	  {"subwindow_mode", GDK_GC_SUBWINDOW, OFF(subwindow_mode)},
	  {"ts_x_origin", GDK_GC_TS_X_ORIGIN, OFF(ts_x_origin)},
	  {"ts_y_origin", GDK_GC_TS_Y_ORIGIN, OFF(ts_y_origin)},
	  {"clip_x_origin", GDK_GC_CLIP_X_ORIGIN, OFF(clip_x_origin)},
	  {"clip_y_origin", GDK_GC_CLIP_Y_ORIGIN, OFF(clip_y_origin)},
	  {"graphics_exposures", GDK_GC_EXPOSURES, OFF(graphics_exposures)},
	  {"line_width", GDK_GC_LINE_WIDTH, OFF(line_width)},
	  {"line_style", GDK_GC_LINE_STYLE, OFF(line_style)},
	  {"cap_style", GDK_GC_CAP_STYLE, OFF(cap_style)},
	  {"join_style", GDK_GC_JOIN_STYLE, OFF(join_style)},
	  {NULL, 0, 0}
	};
#undef OFF
	while (others[i].name != NULL) {
	  if (!strcmp(strkey, others[i].name)) {
	    if (!PyInt_Check(value)) {
	      char buf[80];
	      g_snprintf(buf, 79, "%s argument expects an integer",
			 others[i].name);
	      PyErr_SetString(PyExc_TypeError, buf);
	      return NULL;
	    }
	    mask |= others[i].mask;
	    *((int *)((char *)&values + others[i].offs)) = PyInt_AsLong(value);
	    break;
	  }
	  i++;
	}
	if (others[i].name == NULL) {
	  PyErr_SetString(PyExc_TypeError, "unknown argument");
	  return NULL;
	}
      }
    }
  if (!PyArg_ParseTuple(args, ":GdkWindow.new_gc"))
    return NULL;
  gc = gdk_gc_new_with_values(PyGdkWindow_Get(self), &values, mask);
  value = PyGdkGC_New(gc);
  gdk_gc_unref(gc);
  return value;
}

static PyObject *PyGdkWindow_SetCursor(PyGdkWindow_Object *self,
				       PyObject *args) {
  PyObject *cursor;

  if (!PyArg_ParseTuple(args, "O!:GdkWindow.set_cursor", &PyGdkCursor_Type,
			&cursor))
    return NULL;
  gdk_window_set_cursor(self->obj, PyGdkCursor_Get(cursor));
  Py_INCREF(Py_None);
  return Py_None;
}

static PyMethodDef PyGdkWindow_methods[] = {
  {"new_gc", (PyCFunction)PyGdkWindow_NewGC, METH_VARARGS|METH_KEYWORDS, NULL},
  {"set_cursor", (PyCFunction)PyGdkWindow_SetCursor, METH_VARARGS, NULL},
  {NULL, 0, 0, NULL}
};

static PyObject *
PyGdkWindow_GetAttr(PyGdkWindow_Object *self, char *key) {
  GdkWindow *win = PyGdkWindow_Get(self);
  gint x, y;
  GdkModifierType p_mask;

  if (!strcmp(key, "__members__"))
    return Py_BuildValue("[sssssssssss]", "children", "colormap", "height",
			 "parent", "pointer", "pointer_state", "toplevel",
			 "type", "width", "x", "y");
  if (!strcmp(key, "width")) {
    gdk_window_get_size(win, &x, NULL);
    return PyInt_FromLong(x);
  }
  if (!strcmp(key, "height")) {
    gdk_window_get_size(win, NULL, &y);
    return PyInt_FromLong(y);
  }
  if (!strcmp(key, "x")) {
    gdk_window_get_position(win, &x, NULL);
    return PyInt_FromLong(x);
  }
  if (!strcmp(key, "y")) {
    gdk_window_get_position(win, NULL, &y);
    return PyInt_FromLong(y);
  }
  if (!strcmp(key, "colormap"))
    return PyGdkColormap_New(gdk_window_get_colormap(win));
  if (!strcmp(key, "pointer")) {
    gdk_window_get_pointer(win, &x, &y, NULL);
    return Py_BuildValue("(ii)", x, y);
  }
  if (!strcmp(key, "pointer_state")) {
    gdk_window_get_pointer(win, NULL, NULL, &p_mask);
    return PyInt_FromLong(p_mask);
  }
  if (!strcmp(key, "parent"))
    return PyGdkWindow_New(gdk_window_get_parent(win));
  if (!strcmp(key, "toplevel"))
    return PyGdkWindow_New(gdk_window_get_toplevel(win));
  if (!strcmp(key, "children")) {
    GList *children, *tmp;
    PyObject *ret;
    children = gdk_window_get_children(win);
    ret = PyList_New(0);
    for (tmp = children; tmp != NULL; tmp = tmp->next)
      PyList_Append(ret, PyGdkWindow_New(tmp->data));
    g_list_free(children);
    return ret;
  }
  if (!strcmp(key, "type"))
    return PyInt_FromLong(gdk_window_get_type(win));
  return Py_FindMethod(PyGdkWindow_methods, (PyObject *)self, key);
}

static PyTypeObject PyGdkWindow_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkWindow",
  sizeof(PyGdkWindow_Object),
  0,
  (destructor)PyGdkWindow_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGdkWindow_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGdkWindow_Compare,
  (reprfunc)PyGdkWindow_Repr,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkGC_Dealloc(PyGdkGC_Object *self) {
  gdk_gc_unref(self->obj);
  PyMem_DEL(self);
}

static PyObject *
PyGdkGC_GetAttr(PyGdkGC_Object *self, char *key) {
  GdkGCValues gc;

  if (!strcmp(key, "__members__"))
    return Py_BuildValue("[ssssssssssssssssss]", "background", "cap_style",
			 "clip_mask", "clip_x_origin", "clip_y_origin",
			 "fill", "font", "foreground", "function",
			 "graphics_exposures", "join_style", "line_style",
			 "line_width", "stipple", "sub_window", "tile",
			 "ts_x_origin", "ts_y_origin");
  gdk_gc_get_values(self->obj, &gc);
  if (!strcmp(key, "foreground")) return PyGdkColor_New(&(gc.foreground));
  if (!strcmp(key, "background")) return PyGdkColor_New(&(gc.background));
  if (!strcmp(key, "font")) return PyGdkFont_New(gc.font);
  if (!strcmp(key, "function")) return PyInt_FromLong(gc.function);
  if (!strcmp(key, "fill")) return PyInt_FromLong(gc.fill);
  if (!strcmp(key, "tile")) {
    if (gc.tile != NULL) return PyGdkWindow_New(gc.tile);
    Py_INCREF(Py_None); return Py_None;
  }
  if (!strcmp(key, "stipple")) {
    if (gc.stipple != NULL) return PyGdkWindow_New(gc.stipple);
    Py_INCREF(Py_None); return Py_None;
  }
  if (!strcmp(key, "clip_mask")) {
    if (gc.clip_mask!=NULL) return PyGdkWindow_New(gc.clip_mask);
    Py_INCREF(Py_None); return Py_None;
  }
  if (!strcmp(key, "subwindow_mode"))
    return PyInt_FromLong(gc.subwindow_mode);
  if (!strcmp(key, "ts_x_origin")) return PyInt_FromLong(gc.ts_x_origin);
  if (!strcmp(key, "ts_y_origin")) return PyInt_FromLong(gc.ts_y_origin);
  if (!strcmp(key, "clip_x_origin")) return PyInt_FromLong(gc.clip_x_origin);
  if (!strcmp(key, "clip_y_origin")) return PyInt_FromLong(gc.clip_y_origin);
  if (!strcmp(key, "graphics_exposures"))
    return PyInt_FromLong(gc.graphics_exposures);
  if (!strcmp(key, "line_width")) return PyInt_FromLong(gc.line_width);
  if (!strcmp(key, "line_style")) return PyInt_FromLong(gc.line_style);
  if (!strcmp(key, "cap_style")) return PyInt_FromLong(gc.cap_style);
  if (!strcmp(key, "join_style")) return PyInt_FromLong(gc.join_style);
  PyErr_SetString(PyExc_AttributeError, key);
  return NULL;
}

static int
PyGdkGC_SetAttr(PyGdkGC_Object *self, char *key, PyObject *value) {
  GdkGC *gc = self->obj;

  if (value == NULL) {
    PyErr_SetString(PyExc_TypeError, "can't delete attributes");
    return -1;
  }
  if (PyInt_Check(value)) {
    int i = PyInt_AsLong(value);
    GdkGCValues v;
    gdk_gc_get_values(gc, &v);
    if (!strcmp(key, "function")) gdk_gc_set_function(gc, i);
    else if (!strcmp(key, "fill")) gdk_gc_set_fill(gc, i);
    else if (!strcmp(key, "subwindow_mode")) gdk_gc_set_subwindow(gc, i);
    else if (!strcmp(key, "ts_x_origin"))
      gdk_gc_set_ts_origin(gc, i, v.ts_y_origin);
    else if (!strcmp(key, "ts_y_origin"))
      gdk_gc_set_ts_origin(gc, v.ts_x_origin, i);
    else if (!strcmp(key, "clip_x_origin"))
      gdk_gc_set_clip_origin(gc, i, v.clip_y_origin);
    else if (!strcmp(key, "clip_y_origin"))
      gdk_gc_set_clip_origin(gc, v.clip_x_origin, i);
    else if (!strcmp(key, "graphics_exposures")) gdk_gc_set_exposures(gc, i);
    else if (!strcmp(key, "line_width"))
      gdk_gc_set_line_attributes(gc, i,v.line_style,v.cap_style,v.join_style);
    else if (!strcmp(key, "line_style"))
      gdk_gc_set_line_attributes(gc, v.line_width,i,v.cap_style,v.join_style);
    else if (!strcmp(key, "cap_style"))
      gdk_gc_set_line_attributes(gc, v.line_width,v.line_style,i,v.join_style);
    else if (!strcmp(key, "join_style"))
      gdk_gc_set_line_attributes(gc, v.line_width,v.line_style,v.cap_style,i);
    else {
      PyErr_SetString(PyExc_TypeError,"type mismatch");
      return -1;
    }
  } else if (PyGdkColor_Check(value)) {
    GdkColor *c = PyGdkColor_Get(value);
    if (!strcmp(key, "foreground")) gdk_gc_set_foreground(gc, c);
    else if (!strcmp(key, "background")) gdk_gc_set_background(gc, c);
    else {
      PyErr_SetString(PyExc_TypeError,"type mismatch");
      return -1;
    }
  } else if (PyGdkFont_Check(value)) {
    if (!strcmp(key, "font")) gdk_gc_set_font(gc, PyGdkFont_Get(value));
    else{
      PyErr_SetString(PyExc_TypeError,"type mismatch");
      return -1;
    }
  } else if (PyGdkWindow_Check(value) || value == Py_None) {
    GdkWindow *w = (value==Py_None)?NULL:PyGdkWindow_Get(value);
    if (!strcmp(key, "tile")) gdk_gc_set_tile(gc, w);
    else if (!strcmp(key, "stipple")) gdk_gc_set_stipple(gc, w);
    else if (!strcmp(key, "clip_mask")) gdk_gc_set_clip_mask(gc, w);
    else {
      PyErr_SetString(PyExc_TypeError,"type mismatch");
      return -1;
    }
  } else {
    PyErr_SetString(PyExc_TypeError,"type mismatch");
      return -1;
  }
  return 0;
}

static int
PyGdkGC_Compare(PyGdkGC_Object *self, PyGdkGC_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyTypeObject PyGdkGC_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkGC",
  sizeof(PyGdkGC_Object),
  0,
  (destructor)PyGdkGC_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGdkGC_GetAttr,
  (setattrfunc)PyGdkGC_SetAttr,
  (cmpfunc)PyGdkGC_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkColormap_Dealloc(PyGdkColormap_Object *self) {
  gdk_colormap_unref(self->obj);
  PyMem_DEL(self);
}

static PyObject *
PyGdkColor_Alloc(PyGdkColormap_Object *self, PyObject *args) {
  GdkColor color = {0, 0, 0, 0};
  gchar *color_name;
  if (!PyArg_ParseTuple(args, "iii:GdkColormap.alloc",
			&(color.red), &(color.green), &(color.blue))) {
    PyErr_Clear();
    if (!PyArg_ParseTuple(args, "s:GdkColormap.alloc", &color_name))
      return NULL;
    if (!gdk_color_parse(color_name, &color)) {
      PyErr_SetString(PyExc_TypeError, "unable to parse color specification");
      return NULL;
    }
  }
  if (!gdk_color_alloc(self->obj, &color)) {
    PyErr_SetString(PyExc_RuntimeError, "couldn't allocate color");
    return NULL;
  }
  return PyGdkColor_New(&color);
}

static PyMethodDef PyGdkColormap_methods[] = {
  {"alloc", (PyCFunction)PyGdkColor_Alloc, METH_VARARGS, NULL},
  {NULL, 0, 0, NULL}
};

static PyObject *
PyGdkColormap_GetAttr(PyObject *self, char *key) {
  return Py_FindMethod(PyGdkColormap_methods, self, key);
}

static int
PyGdkColormap_Compare(PyGdkColormap_Object *self, PyGdkColormap_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static int
PyGdkColormap_Length(PyGdkColormap_Object *self) {
  return self->obj->size;
}

static PyObject *
PyGdkColormap_GetItem(PyGdkColormap_Object *self, int pos) {
  if (pos < 0 || pos >= self->obj->size) {
    PyErr_SetString(PyExc_IndexError, "index out of range");
    return NULL;
  }
  return PyGdkColor_New(&(self->obj->colors[pos]));
}

static PyObject *
PyGdkColormap_GetSlice(PyGdkColormap_Object *self, int lo, int up) {
  PyObject *ret;
  int i;

  if (lo < 0) lo = 0;
  if (up > self->obj->size) up = self->obj->size;
  if (up < lo) up = lo;

  ret = PyTuple_New(up - lo);
  if (ret == NULL) return NULL;
  for (i = lo; i < up; i++)
    PyTuple_SetItem(ret, i - lo, PyGdkColor_New(&(self->obj->colors[i])));
  return ret;
}

static PySequenceMethods PyGdkColormap_Sequence = {
  (inquiry)PyGdkColormap_Length,
  (binaryfunc)0,
  (intargfunc)0,
  (intargfunc)PyGdkColormap_GetItem,
  (intintargfunc)PyGdkColormap_GetSlice,
  (intobjargproc)0,
  (intintobjargproc)0
};

static PyTypeObject PyGdkColormap_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkColormap",
  sizeof(PyGdkColormap_Object),
  0,
  (destructor)PyGdkColormap_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGdkColormap_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGdkColormap_Compare,
  (reprfunc)0,
  0,
  &PyGdkColormap_Sequence,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkDragContext_Dealloc(PyGdkDragContext_Object *self) {
  gdk_drag_context_unref(self->obj);
  PyMem_DEL(self);
}

static int
PyGdkDragContext_Compare(PyGdkDragContext_Object *self,
			 PyGdkDragContext_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyObject *
PyGdkDragContext_GetAttr(PyGdkDragContext_Object *self, char *key) {
  if (!strcmp(key, "__members__"))
    return Py_BuildValue("[sssssssss]", "action", "actions", "dest_window",
			 "is_source", "protocol", "source_window",
			 "start_window", "suggested_action", "targets");
  else if (!strcmp(key, "protocol"))
    return PyInt_FromLong(self->obj->protocol);
  else if (!strcmp(key, "is_source"))
    return PyInt_FromLong(self->obj->is_source);
  else if (!strcmp(key, "source_window"))
    if (self->obj->source_window)
      return PyGdkWindow_New(self->obj->source_window);
    else {
      Py_INCREF(Py_None);
      return Py_None;
    }
  else if (!strcmp(key, "dest_window"))
    if (self->obj->dest_window)
      return PyGdkWindow_New(self->obj->dest_window);
    else {
      Py_INCREF(Py_None);
      return Py_None;
    }
  else if (!strcmp(key, "targets")) {
    PyObject *ret = PyList_New(0);
    GList *tmp;
    for (tmp = self->obj->targets; tmp != NULL; tmp = tmp->next)
      PyList_Append(ret, PyGdkAtom_New(GPOINTER_TO_INT(tmp->data)));
    return ret;
  } else if (!strcmp(key, "actions"))
    return PyInt_FromLong(self->obj->actions);
  else if (!strcmp(key, "suggested_action"))
    return PyInt_FromLong(self->obj->suggested_action);
  else if (!strcmp(key, "action"))
    return PyInt_FromLong(self->obj->action);
  else if (!strcmp(key, "start_time"))
    return PyInt_FromLong(self->obj->start_time);
  PyErr_SetString(PyExc_AttributeError, key);
  return NULL;
}

static PyTypeObject PyGdkDragContext_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkDragContext",
  sizeof(PyGdkDragContext_Object),
  0,
  (destructor)PyGdkDragContext_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGdkDragContext_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGdkDragContext_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGtkSelectionData_Dealloc(PyGtkSelectionData_Object *self) {
  PyMem_DEL(self);
}

static int
PyGtkSelectionData_Compare(PyGtkSelectionData_Object *self,
			   PyGtkSelectionData_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyObject *
PyGtkSelectionData_Set(PyGtkSelectionData_Object *self, PyObject *args) {
  GdkAtom type;
  int format, length;
  guchar *data;

  if (!PyArg_ParseTuple(args, "iis#:GtkSelectionData.set", &type, &format,
			&data, &length))
    return NULL;
  gtk_selection_data_set(self->obj, type, format, data, length);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyMethodDef PyGtkSelectionData_methods[] = {
  {"set", (PyCFunction)PyGtkSelectionData_Set, METH_VARARGS, NULL},
  {NULL, 0, 0, NULL}
};

static PyObject *
PyGtkSelectionData_GetAttr(PyGtkSelectionData_Object *self, char *key) {
  if (!strcmp(key, "__members__"))
    return Py_BuildValue("[sssss]", "data", "format", "selection", "target",
			 "type");
  else if (!strcmp(key, "selection"))
    return PyGdkAtom_New(self->obj->selection);
  else if (!strcmp(key, "target"))
    return PyGdkAtom_New(self->obj->target);
  else if (!strcmp(key, "type"))
    return PyGdkAtom_New(self->obj->type);
  else if (!strcmp(key, "format"))
    return PyInt_FromLong(self->obj->format);
  else if (!strcmp(key, "data"))
    return PyString_FromStringAndSize(self->obj->data, self->obj->length);
  return Py_FindMethod(PyGtkSelectionData_methods, (PyObject *)self, key);
}

static PyTypeObject PyGtkSelectionData_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GtkSelectionData",
  sizeof(PyGtkSelectionData_Object),
  0,
  (destructor)PyGtkSelectionData_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGtkSelectionData_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGtkSelectionData_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkAtom_Dealloc(PyGdkAtom_Object *self) {
  if (self->name) g_free(self->name);
  PyMem_DEL(self);
}

static int
PyGdkAtom_Compare(PyGdkAtom_Object *self, PyGdkAtom_Object *v) {
  if (self->atom == v->atom) return 0;
  if (self->atom > v->atom) return -1;
  return 1;
}

static PyObject *
PyGdkAtom_Repr(PyGdkAtom_Object *self) {
  char buf[256];
  if (!self->name) self->name = gdk_atom_name(self->atom);
  g_snprintf(buf, 256, "<GdkAtom 0x%lx = '%s'>", (unsigned long)self->atom,
	     self->name);
  return PyString_FromString(buf);
}

static int
PyGdkAtom_Coerce(PyObject **self, PyObject **other) {
  PyGdkAtom_Object *old = (PyGdkAtom_Object *)*self;
  if (PyInt_Check(*other)) {
    *self = PyInt_FromLong(old->atom);
    Py_INCREF(*other);
    return 0;
  } else if (PyFloat_Check(*other)) {
    *self = PyFloat_FromDouble((double)old->atom);
    Py_INCREF(*other);
    return 0;
  } else if (PyLong_Check(*other)) {
    *self = PyLong_FromUnsignedLong(old->atom);
    Py_INCREF(*other);
    return 0;
  } else if (PyString_Check(*other)) {
    if (!old->name)
      old->name = gdk_atom_name(old->atom);
    *self = PyString_FromString(old->name);
    Py_INCREF(*other);
    return 0;
  }
  return 1;  /* don't know how to convert */
}

static PyObject *
PyGdkAtom_Int(PyGdkAtom_Object *self) {
  return PyInt_FromLong(self->atom);
}

static PyObject *
PyGdkAtom_Long(PyGdkAtom_Object *self) {
  return PyLong_FromUnsignedLong(self->atom);
}

static PyObject *
PyGdkAtom_Float(PyGdkAtom_Object *self) {
  return PyFloat_FromDouble(self->atom);
}

static PyObject *
PyGdkAtom_Oct(PyGdkAtom_Object *self) {
  char buf[100];
  if (self->atom == 0) return PyString_FromString("0");
  g_snprintf(buf, 100, "0%lo", self->atom);
  return PyString_FromString(buf);
}

static PyObject *
PyGdkAtom_Hex(PyGdkAtom_Object *self) {
  char buf[100];
  g_snprintf(buf, 100, "0x%lx", self->atom);
  return PyString_FromString(buf);
}

static PyObject *
PyGdkAtom_Str(PyGdkAtom_Object *self) {
  if (!self->name) self->name = gdk_atom_name(self->atom);
  return PyString_FromString(self->name);
}

static PyNumberMethods PyGdkAtom_Number = {
  (binaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (ternaryfunc)0,
  (unaryfunc)0,
  (unaryfunc)0,
  (unaryfunc)0,
  (inquiry)0,
  (unaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (binaryfunc)0,
  (coercion)PyGdkAtom_Coerce,
  (unaryfunc)PyGdkAtom_Int,
  (unaryfunc)PyGdkAtom_Long,
  (unaryfunc)PyGdkAtom_Float,
  (unaryfunc)PyGdkAtom_Oct,
  (unaryfunc)PyGdkAtom_Hex
};

static PyTypeObject PyGdkAtom_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkAtom",
  sizeof(PyGdkAtom_Object),
  0,
  (destructor)PyGdkAtom_Dealloc,
  (printfunc)0,
  (getattrfunc)0,
  (setattrfunc)0,
  (cmpfunc)PyGdkAtom_Compare,
  (reprfunc)PyGdkAtom_Repr,
  &PyGdkAtom_Number,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)PyGdkAtom_Str,
  0L,0L,0L,0L,
  NULL
};

static void
PyGdkCursor_Dealloc(PyGdkCursor_Object *self) {
  gdk_cursor_destroy(self->obj);
  PyMem_DEL(self);
}

static int
PyGdkCursor_Compare(PyGdkCursor_Object *self, PyGdkCursor_Object *v) {
  if (self->obj == v->obj) return 0;
  if (self->obj > v->obj) return -1;
  return 1;
}

static PyObject *
PyGdkCursor_Repr(PyGdkCursor_Object *self) {
  char buf[256], *cname = NULL;

  if (self->obj->type == GDK_CURSOR_IS_PIXMAP)
    cname = "*pixmap*";
  else {
    GtkEnumValue *vals = gtk_type_enum_get_values(GTK_TYPE_GDK_CURSOR_TYPE);
    while (vals->value_name != NULL && vals->value != self->obj->type)
      vals++;
    if (vals->value_nick) cname = vals->value_nick;
    else cname = "*unknown";
  }

  g_snprintf(buf, 256, "<GdkCursor '%s'>", cname);
  return PyString_FromString(buf);
}

static PyTypeObject PyGdkCursor_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GdkCursor",
  sizeof(PyGdkCursor_Object),
  0,
  (destructor)PyGdkCursor_Dealloc,
  (printfunc)0,
  (getattrfunc)0,
  (setattrfunc)0,
  (cmpfunc)PyGdkCursor_Compare,
  (reprfunc)PyGdkCursor_Repr,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

static void PyGtkCTreeNode_Dealloc(PyGtkCTreeNode_Object *self) {
  PyMem_DEL(self);
}

static int PyGtkCTreeNode_Compare(PyGtkCTreeNode_Object *self,
				  PyGtkCTreeNode_Object *v) {
  if (self->node == v->node) return 0;
  if (self->node > v->node) return -1;
  return 1;
}

static PyObject *PyGtkCTreeNode_GetAttr(PyGtkCTreeNode_Object *self,
					char *key) {
  if (!strcmp(key, "__members__"))
    return Py_BuildValue("[ssssss]", "children", "expanded", "is_leaf",
			 "level", "parent", "sibling");
  if (!strcmp(key, "parent")) {
    GtkCTreeNode *node = GTK_CTREE_ROW(self->node)->parent;
    if (node)
      return PyGtkCTreeNode_New(node);
    Py_INCREF(Py_None);
    return Py_None;
  } else if (!strcmp(key, "sibling")) {
    GtkCTreeNode *node = GTK_CTREE_ROW(self->node)->sibling;
    if (node)
      return PyGtkCTreeNode_New(node);
    Py_INCREF(Py_None);
    return Py_None;
  } else if (!strcmp(key, "children")) {
    GtkCTreeNode *node = GTK_CTREE_ROW(self->node)->children;
    PyObject *ret = PyList_New(0);
    while (node) {
      PyList_Append(ret, PyGtkCTreeNode_New(node));
      node = GTK_CTREE_ROW(node)->sibling;
    }
    return ret;
  } else if (!strcmp(key, "level"))
    return PyInt_FromLong(GTK_CTREE_ROW(self->node)->level);
  else if (!strcmp(key, "is_leaf"))
    return PyInt_FromLong(GTK_CTREE_ROW(self->node)->is_leaf);
  else if (!strcmp(key, "expanded"))
    return PyInt_FromLong(GTK_CTREE_ROW(self->node)->expanded);
  PyErr_SetString(PyExc_AttributeError, key);
  return NULL;
}

static PyTypeObject PyGtkCTreeNode_Type = {
  PyObject_HEAD_INIT(&PyType_Type)
  0,
  "GtkCTreeNode",
  sizeof(PyGtkCTreeNode_Object),
  0,
  (destructor)PyGtkCTreeNode_Dealloc,
  (printfunc)0,
  (getattrfunc)PyGtkCTreeNode_GetAttr,
  (setattrfunc)0,
  (cmpfunc)PyGtkCTreeNode_Compare,
  (reprfunc)0,
  0,
  0,
  0,
  (hashfunc)0,
  (ternaryfunc)0,
  (reprfunc)0,
  0L,0L,0L,0L,
  NULL
};

/* This file contains routines used to convert GtkArg structures and arrays
 * to and from Python objects.  This code is used for the callback marshalling
 * code, signal handling, and GtkObject properties (gtk_object_[gs]et).
 *
 * It is collected here, so I don't accidentally reproduce it elsewhere in
 * pygtk. */

/* destroy notify for PyObject */
static void PyGtk_DestroyNotify(gpointer data) {
  Py_DECREF((PyObject *)data);
}
static void PyGtk_CallbackMarshal(GtkObject *o, gpointer d, guint nargs,
				  GtkArg *args);
static PyObject *GtkArgs_AsTuple(int nparams, GtkArg *args);
static int GtkArgs_FromSequence(GtkArg *args, int nparams, PyObject *seq);

/* this hash table is used to let these functions know about new boxed
 * types (eg. maybe some from GNOME). The functions return TRUE on error */
typedef PyObject *(*fromargfunc)(gpointer boxed);
typedef int (*toargfunc)(gpointer *boxed, PyObject *obj);
typedef struct {
  fromargfunc fromarg;
  toargfunc toarg;
} PyGtk_BoxFuncs;
/* keys are GUINT_TO_POINTER(GtkType) */
static GHashTable *boxed_funcs;

static void PyGtk_RegisterBoxed(GtkType boxed_type,
				 fromargfunc fromarg, toargfunc toarg) {
  PyGtk_BoxFuncs *fs = g_new(PyGtk_BoxFuncs, 1);

  fs->fromarg = fromarg;
  fs->toarg = toarg;
  g_hash_table_insert(boxed_funcs, GUINT_TO_POINTER(boxed_type), fs);
}

#define PyGtk_get_boxed(type) (PyGtk_BoxFuncs *)g_hash_table_lookup( \
  boxed_funcs, GUINT_TO_POINTER(type))

/* create a GtkArg from a PyObject, using the GTK_VALUE_* routines.
 * returns -1 if it couldn't set the argument. */
static int GtkArg_FromPyObject(GtkArg *arg, PyObject *obj) {
  PyObject *tmp;
  switch (GTK_FUNDAMENTAL_TYPE(arg->type)) {
  case GTK_TYPE_NONE:
  case GTK_TYPE_INVALID:
    GTK_VALUE_INT(*arg) = 0;
    break;
  case GTK_TYPE_BOOL:
    if (tmp = PyNumber_Int(obj))
      GTK_VALUE_BOOL(*arg) = (PyInt_AsLong(tmp) != 0);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_CHAR:
    if (tmp = PyObject_Str(obj))
      GTK_VALUE_CHAR(*arg) = PyString_AsString(tmp)[0];
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_ENUM:
    if (PyGtkEnum_get_value(arg->type, obj, &(GTK_VALUE_ENUM(*arg))))
      return -1;
    break;
  case GTK_TYPE_FLAGS:
    if (PyGtkFlag_get_value(arg->type, obj, &(GTK_VALUE_FLAGS(*arg))))
      return -1;
    break;
  case GTK_TYPE_INT:
    if (tmp = PyNumber_Int(obj))
      GTK_VALUE_INT(*arg) = PyInt_AsLong(tmp);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_UINT:
    if (tmp = PyNumber_Int(obj))
      GTK_VALUE_UINT(*arg) = PyInt_AsLong(tmp);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_LONG:
    if (tmp = PyNumber_Int(obj))
      GTK_VALUE_LONG(*arg) = PyInt_AsLong(tmp);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_ULONG:
    if (tmp = PyNumber_Int(obj))
      GTK_VALUE_ULONG(*arg) = PyInt_AsLong(tmp);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_FLOAT:
    if (tmp = PyNumber_Float(obj))
      GTK_VALUE_FLOAT(*arg) = PyFloat_AsDouble(tmp);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_DOUBLE:
    if (tmp = PyNumber_Float(obj))
      GTK_VALUE_DOUBLE(*arg) = PyFloat_AsDouble(tmp);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_STRING:
    if (tmp = PyObject_Str(obj))
      GTK_VALUE_STRING(*arg) = PyString_AsString(tmp);
    else {
      PyErr_Clear();
      return -1;
    }
    Py_DECREF(tmp);
    break;
  case GTK_TYPE_OBJECT:
    if (PyGtk_Check(obj))
      GTK_VALUE_OBJECT(*arg) = PyGtk_Get(obj);
    else
      return -1;
    break;
  case GTK_TYPE_BOXED:
    if (arg->type == GTK_TYPE_ACCEL_GROUP) {
      if (PyGtkAccelGroup_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGtkAccelGroup_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_STYLE) {
      if (PyGtkStyle_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGtkStyle_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_GDK_EVENT) {
      if (PyGdkEvent_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGdkEvent_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_GDK_FONT) {
      if (PyGdkFont_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGdkFont_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_GDK_COLOR) {
      if (PyGdkColor_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGdkColor_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_GDK_WINDOW) {
      if (PyGdkWindow_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGdkWindow_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_GDK_COLORMAP) {
      if (PyGdkColormap_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGdkColormap_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_GDK_DRAG_CONTEXT) {
      if (PyGdkDragContext_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGdkDragContext_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_SELECTION_DATA) {
      if (PyGtkSelectionData_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGtkSelectionData_Get(obj);
      else
	return -1;
    } else if (arg->type == GTK_TYPE_CTREE_NODE) {
      if (obj == Py_None)
	GTK_VALUE_BOXED(*arg) = NULL;
      else if (PyGtkSelectionData_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyGtkSelectionData_Get(obj);
      else
	return -1;
    } else {
      PyGtk_BoxFuncs *fs= PyGtk_get_boxed(arg->type);
      if (fs && fs->toarg) {
	if (fs->toarg(&(GTK_VALUE_BOXED(*arg)), obj))
	  return -1;
      } else if (PyCObject_Check(obj))
	GTK_VALUE_BOXED(*arg) = PyCObject_AsVoidPtr(obj);
      else
	return -1;
    }
    break;
  case GTK_TYPE_POINTER:
    if (PyCObject_Check(obj))
      GTK_VALUE_BOXED(*arg) = PyCObject_AsVoidPtr(obj);
    else
      return -1;
    break;
  case GTK_TYPE_FOREIGN:
    Py_INCREF(obj);
    GTK_VALUE_FOREIGN(*arg).data = obj;
    GTK_VALUE_FOREIGN(*arg).notify = PyGtk_DestroyNotify;
    break;
  case GTK_TYPE_SIGNAL:
    if (PyCallable_Check(obj)) {
      Py_INCREF(obj);
      GTK_VALUE_SIGNAL(*arg).f = NULL;
      GTK_VALUE_SIGNAL(*arg).d = obj;
    } else
      return -1;
    break;
  case GTK_TYPE_CALLBACK:
    if (PyCallable_Check(obj)) {
      Py_INCREF(obj);
      GTK_VALUE_CALLBACK(*arg).marshal =
	(GtkCallbackMarshal)PyGtk_CallbackMarshal;
      GTK_VALUE_CALLBACK(*arg).data = obj;
      GTK_VALUE_CALLBACK(*arg).notify = PyGtk_DestroyNotify;
    } else
      return -1;
    break;
  case GTK_TYPE_ARGS:
  case GTK_TYPE_C_CALLBACK:
    fprintf(stderr, "unsupported type");
    g_assert_not_reached();
    return -1;
  }
  return 0;
}

/* convert a GtkArg structure to a PyObject, using the GTK_VALUE_* routines.
 * conversion is always possible. */
static PyObject *GtkArg_AsPyObject(GtkArg *arg) {
  switch (GTK_FUNDAMENTAL_TYPE(arg->type)) {
  case GTK_TYPE_INVALID:
  case GTK_TYPE_NONE:
    Py_INCREF(Py_None);
    return Py_None;
  case GTK_TYPE_CHAR:
    return PyString_FromStringAndSize(&GTK_VALUE_CHAR(*arg), 1);
  case GTK_TYPE_BOOL:
    return PyInt_FromLong(GTK_VALUE_BOOL(*arg));
  case GTK_TYPE_ENUM:
  case GTK_TYPE_FLAGS:
  case GTK_TYPE_INT:
    return PyInt_FromLong(GTK_VALUE_INT(*arg));
  case GTK_TYPE_UINT:
    return PyInt_FromLong(GTK_VALUE_UINT(*arg));
  case GTK_TYPE_LONG:
    return PyInt_FromLong(GTK_VALUE_LONG(*arg));
  case GTK_TYPE_ULONG:
    return PyInt_FromLong(GTK_VALUE_ULONG(*arg));
  case GTK_TYPE_FLOAT:
    return PyFloat_FromDouble(GTK_VALUE_FLOAT(*arg));
  case GTK_TYPE_DOUBLE:
    return PyFloat_FromDouble(GTK_VALUE_DOUBLE(*arg));
  case GTK_TYPE_STRING:
    if (GTK_VALUE_STRING(*arg) != NULL)
      return PyString_FromString(GTK_VALUE_STRING(*arg));
    else {
      Py_INCREF(Py_None);
      return Py_None;
    }
  case GTK_TYPE_ARGS:
    return GtkArgs_AsTuple(GTK_VALUE_ARGS(*arg).n_args,
			   GTK_VALUE_ARGS(*arg).args);
  case GTK_TYPE_OBJECT:
    return PyGtk_New(GTK_VALUE_OBJECT(*arg));
  case GTK_TYPE_POINTER:
    return PyCObject_FromVoidPtr(GTK_VALUE_POINTER(*arg), NULL);
  case GTK_TYPE_BOXED:
    if (arg->type == GTK_TYPE_ACCEL_GROUP)
      return PyGtkAccelGroup_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_STYLE)
      return PyGtkStyle_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_EVENT)
      return PyGdkEvent_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_FONT)
      return PyGdkFont_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_COLOR)
      return PyGdkColor_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_WINDOW)
      return PyGdkWindow_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_COLORMAP)
      return PyGdkColormap_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_DRAG_CONTEXT)
      return PyGdkDragContext_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_SELECTION_DATA)
      return PyGtkSelectionData_New(GTK_VALUE_BOXED(*arg));
    else if (arg->type == GTK_TYPE_CTREE_NODE) {
      if (GTK_VALUE_BOXED(*arg))
	return PyGtkCTreeNode_New(GTK_VALUE_BOXED(*arg));
      Py_INCREF(Py_None);
      return Py_None;
    } else {
      PyGtk_BoxFuncs *fs = PyGtk_get_boxed(arg->type);
      if (fs && fs->fromarg)
	return fs->fromarg(GTK_VALUE_BOXED(*arg));
      return PyCObject_FromVoidPtr(GTK_VALUE_BOXED(*arg), NULL);
    }
  case GTK_TYPE_FOREIGN:
    Py_INCREF((PyObject *)GTK_VALUE_FOREIGN(*arg).data);
    return (PyObject *)GTK_VALUE_FOREIGN(*arg).data;
  case GTK_TYPE_CALLBACK:
    Py_INCREF((PyObject *)GTK_VALUE_CALLBACK(*arg).data);
    return (PyObject *)GTK_VALUE_CALLBACK(*arg).data;
  case GTK_TYPE_SIGNAL:
    Py_INCREF((PyObject *)GTK_VALUE_SIGNAL(*arg).d);
    return (PyObject *)GTK_VALUE_SIGNAL(*arg).d;
  default:
    g_assert_not_reached();
    break;
  }
  return NULL;
}

/* set a GtkArg structure's data from a PyObject, using the GTK_RETLOC_*
 * routines.  If it can't make the conversion, set the return to a zero
 * equivalent. */
static void GtkRet_FromPyObject(GtkArg *ret, PyObject *py_ret) {
  PyObject *tmp;
  switch (GTK_FUNDAMENTAL_TYPE(ret->type)) {
  case GTK_TYPE_NONE:
  case GTK_TYPE_INVALID:
    break;
  case GTK_TYPE_BOOL:
    if (tmp = PyNumber_Int(py_ret)) {
      *GTK_RETLOC_BOOL(*ret) = (PyInt_AsLong(tmp) != 0);
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_BOOL(*ret) = FALSE;
    }
    break;
  case GTK_TYPE_CHAR:
    if (tmp = PyObject_Str(py_ret)) {
      *GTK_RETLOC_CHAR(*ret) = PyString_AsString(tmp)[0];
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_CHAR(*ret) = '\0';
    }
    break;
  case GTK_TYPE_ENUM:
    if (PyGtkEnum_get_value(ret->type, py_ret, GTK_RETLOC_ENUM(*ret))) {
      PyErr_Clear();
      *GTK_RETLOC_ENUM(*ret) = 0;
    }
    break;
  case GTK_TYPE_FLAGS:
    if (PyGtkFlag_get_value(ret->type, py_ret, GTK_RETLOC_FLAGS(*ret))) {
      PyErr_Clear();
      *GTK_RETLOC_FLAGS(*ret) = 0;
    }
    break;
  case GTK_TYPE_INT:
    if (tmp = PyNumber_Int(py_ret)) {
      *GTK_RETLOC_INT(*ret) = PyInt_AsLong(tmp);
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_INT(*ret) = 0;
    }
    break;
  case GTK_TYPE_UINT:
    if (tmp = PyNumber_Int(py_ret)) {
      *GTK_RETLOC_UINT(*ret) = PyInt_AsLong(tmp);
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_UINT(*ret) = 0;
    }
    break;
  case GTK_TYPE_LONG:
    if (tmp = PyNumber_Int(py_ret)) {
      *GTK_RETLOC_LONG(*ret) = PyInt_AsLong(tmp);
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_LONG(*ret) = 0;
    }
    break;
  case GTK_TYPE_ULONG:
    if (tmp = PyNumber_Int(py_ret)) {
      *GTK_RETLOC_ULONG(*ret) = PyInt_AsLong(tmp);
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_ULONG(*ret) = 0;
    }
    break;
  case GTK_TYPE_FLOAT:
    if (tmp = PyNumber_Float(py_ret)) {
      *GTK_RETLOC_FLOAT(*ret) = PyFloat_AsDouble(tmp);
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_FLOAT(*ret) = 0;
    }
    break;
  case GTK_TYPE_DOUBLE:
    if (tmp = PyNumber_Float(py_ret)) {
      *GTK_RETLOC_DOUBLE(*ret) = PyFloat_AsDouble(tmp);
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_DOUBLE(*ret) = 0;
    }
    break;
  case GTK_TYPE_STRING:
    if (tmp = PyObject_Str(py_ret)) {
      *GTK_RETLOC_STRING(*ret) = g_strdup(PyString_AsString(py_ret));
      Py_DECREF(tmp);
    } else {
      PyErr_Clear();
      *GTK_RETLOC_STRING(*ret) = NULL;
    }
    break;
  case GTK_TYPE_OBJECT:
    if (PyGtk_Check(py_ret))
      *GTK_RETLOC_OBJECT(*ret) = PyGtk_Get(py_ret);
    else
      *GTK_RETLOC_OBJECT(*ret) = NULL;
    break;
  case GTK_TYPE_BOXED:
    if (ret->type == GTK_TYPE_ACCEL_GROUP) {
      if (PyGtkAccelGroup_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGtkAccelGroup_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_STYLE) {
      if (PyGtkStyle_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGtkStyle_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_GDK_EVENT) {
      if (PyGdkEvent_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGdkEvent_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_GDK_FONT) {
      if (PyGdkFont_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGdkFont_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_GDK_COLOR) {
      if (PyGdkColor_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGdkColor_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_GDK_WINDOW) {
      if (PyGdkWindow_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGdkWindow_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_GDK_COLORMAP) {
      if (PyGdkColormap_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGdkColormap_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_GDK_DRAG_CONTEXT) {
      if (PyGdkDragContext_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGdkDragContext_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_SELECTION_DATA) {
      if (PyGtkSelectionData_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGtkSelectionData_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else if (ret->type == GTK_TYPE_CTREE_NODE) {
      if (PyGtkSelectionData_Check(py_ret))
	*GTK_RETLOC_BOXED(*ret) = PyGtkCTreeNode_Get(py_ret);
      else
	*GTK_RETLOC_BOXED(*ret) = NULL;
    } else {
      PyGtk_BoxFuncs *fs = PyGtk_get_boxed(ret->type);
      if (fs && fs->toarg) {
	if (fs->toarg(GTK_RETLOC_BOXED(*ret), py_ret))
	  *GTK_RETLOC_BOXED(*ret) = NULL;
      } else
	if (PyCObject_Check(py_ret))
	  *GTK_RETLOC_BOXED(*ret) = PyCObject_AsVoidPtr(py_ret);
	else
	  *GTK_RETLOC_BOXED(*ret) = NULL;
    }
    break;
  case GTK_TYPE_POINTER:
    if (PyCObject_Check(py_ret))
      *GTK_RETLOC_POINTER(*ret) = PyCObject_AsVoidPtr(py_ret);
    else
      *GTK_RETLOC_POINTER(*ret) = NULL;
  default:
    g_assert_not_reached();
    break;
  }
}

/* convert a GtkArg structure to a PyObject, using the GTK_RETLOC_* routines.
 * conversion is always possible. */
static PyObject *GtkRet_AsPyObject(GtkArg *arg) {
  switch (GTK_FUNDAMENTAL_TYPE(arg->type)) {
  case GTK_TYPE_INVALID:
  case GTK_TYPE_NONE:
    Py_INCREF(Py_None);
    return Py_None;
  case GTK_TYPE_CHAR:
    return PyString_FromStringAndSize(GTK_RETLOC_CHAR(*arg), 1);
  case GTK_TYPE_BOOL:
    return PyInt_FromLong(*GTK_RETLOC_BOOL(*arg));
  case GTK_TYPE_ENUM:
  case GTK_TYPE_FLAGS:
  case GTK_TYPE_INT:
    return PyInt_FromLong(*GTK_RETLOC_INT(*arg));
  case GTK_TYPE_UINT:
    return PyInt_FromLong(*GTK_RETLOC_UINT(*arg));
  case GTK_TYPE_LONG:
    return PyInt_FromLong(*GTK_RETLOC_LONG(*arg));
  case GTK_TYPE_ULONG:
    return PyInt_FromLong(*GTK_RETLOC_ULONG(*arg));
  case GTK_TYPE_FLOAT:
    return PyFloat_FromDouble(*GTK_RETLOC_FLOAT(*arg));
  case GTK_TYPE_DOUBLE:
    return PyFloat_FromDouble(*GTK_RETLOC_DOUBLE(*arg));
  case GTK_TYPE_STRING:
    if (*GTK_RETLOC_STRING(*arg) != NULL)
      return PyString_FromString(*GTK_RETLOC_STRING(*arg));
    else {
      Py_INCREF(Py_None);
      return Py_None;
    }
  case GTK_TYPE_ARGS:
    break;
  case GTK_TYPE_OBJECT:
    return PyGtk_New(*GTK_RETLOC_OBJECT(*arg));
  case GTK_TYPE_POINTER:
    return PyCObject_FromVoidPtr(*GTK_RETLOC_POINTER(*arg), NULL);
  case GTK_TYPE_BOXED:
    if (arg->type == GTK_TYPE_ACCEL_GROUP)
      return PyGtkAccelGroup_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_STYLE)
      return PyGtkStyle_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_EVENT)
      return PyGdkEvent_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_FONT)
      return PyGdkFont_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_COLOR)
      return PyGdkColor_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_WINDOW)
      return PyGdkWindow_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_COLORMAP)
      return PyGdkColormap_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_GDK_DRAG_CONTEXT)
      return PyGdkDragContext_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_SELECTION_DATA)
      return PyGtkSelectionData_New(*GTK_RETLOC_BOXED(*arg));
    else if (arg->type == GTK_TYPE_CTREE_NODE) {
      if (*GTK_RETLOC_BOXED(*arg))
	return PyGtkCTreeNode_New(*GTK_RETLOC_BOXED(*arg));
      Py_INCREF(Py_None);
      return Py_None;
    } else {
      PyGtk_BoxFuncs *fs = PyGtk_get_boxed(arg->type);
      if (fs && fs->fromarg)
	return fs->fromarg(*GTK_RETLOC_BOXED(*arg));
      return PyCObject_FromVoidPtr(*GTK_RETLOC_BOXED(*arg), NULL);
    }
  default:
    g_assert_not_reached();
    break;
  }
  return NULL;
}

/* convert the GtkArg array ARGS to a python tuple */
static PyObject *GtkArgs_AsTuple(int nparams, GtkArg *args) {
  PyObject *tuple, *item;
  int i;

  tuple = PyTuple_New(nparams);
  for (i = 0; i < nparams; i++) {
    item = GtkArg_AsPyObject(&args[i]);
    if (item == NULL) {
      Py_INCREF(Py_None);
      item = Py_None;
    }
    PyTuple_SetItem(tuple, i, item);
  }
  return tuple;
}

/* converts a Python sequence to a GtkArg array.  Returns -1 if the sequence
 * doesn't match the specification in ARGS */
static int GtkArgs_FromSequence(GtkArg *args, int nparams, PyObject *seq) {
  PyObject *item;
  int i;
  if (!PySequence_Check(seq))
    return -1;
  for (i = 0; i < nparams; i++) {
    item = PySequence_GetItem(seq, i);
    if (GtkArg_FromPyObject(&args[i], item)) {
      gchar buf[512];
      if (args[i].name == NULL)
	g_snprintf(buf, 511, "argument %d: expected %s, %s found", i+1,
		   gtk_type_name(args[i].type), item->ob_type->tp_name);
      else
	g_snprintf(buf, 511, "argument %s: expected %s, %s found",
		   args[i].name, gtk_type_name(args[i].type),
		   item->ob_type->tp_name);
      PyErr_SetString(PyExc_TypeError, buf);
      return -1;
    }
  }
  return 0;
}

/* generic callback marshal */
static void PyGtk_CallbackMarshal(GtkObject *o, gpointer data, guint nargs,
				  GtkArg *args) {
  PyObject *func = data, *ret, *a, *params;

  a = GtkArgs_AsTuple(nargs, args);
  if (a == NULL) {
    PyErr_Clear();
    fprintf(stderr, "can't decode params -- callback not run\n");
    return;
  }
  if (o == NULL)
    params = a;
  else {
    /* prepend object to argument list */
    ret = PyTuple_New(1);
    PyTuple_SetItem(ret, 0, PyGtk_New(o));
    params = PySequence_Concat(ret, a);
    Py_DECREF(ret); Py_DECREF(a);
  }
  if (PyTuple_Check(func)) {
    a = PyTuple_GetItem(func, 1);
    func = PyTuple_GetItem(func, 0);
    if (PyTuple_Check(a)) {
      ret = params;
      params = PySequence_Concat(ret, a);
      Py_DECREF(ret);
    }
  }
  ret = PyObject_CallObject(func, params);
  Py_DECREF(params);
  if (ret == NULL) {
    PyErr_Print();
    PyErr_Clear();
    return;
  }
  GtkRet_FromPyObject(&args[nargs], ret);
  Py_DECREF(ret);
}



static
void PyGtk_SignalMarshal(GtkObject *object, /*gpointer*/ PyObject *func,
                       int nparams, GtkArg *args, GtkType *arg_types,
                                                 GtkType return_type) {
    PyObject *arg_list, *params, *ret;

    ret = PyTuple_New(1);
    PyTuple_SetItem(ret, 0, PyGtk_New(object));
    arg_list = GtkArgs_AsTuple(nparams, args);
    params = PySequence_Concat(ret, arg_list);
    Py_DECREF(ret);
    Py_DECREF(arg_list);
    if (PyTuple_Check(func)) { /* extra arguments given with func */
      arg_list = PyTuple_GetItem(func, 1);
      func = PyTuple_GetItem(func, 0);
      if (PyTuple_Check(arg_list)) {
	ret = params;
	params = PySequence_Concat(ret, arg_list);
	Py_DECREF(ret);
      }
    }
    ret = PyObject_CallObject(func, params);
    Py_DECREF(params);

    if (ret == NULL) {
        PyErr_Print();
	PyErr_Clear();
	return;
    }
    GtkRet_FromPyObject(&args[nparams], ret);
    Py_DECREF(ret);
}

static
void PyGtk_SignalDestroy(/*gpointer*/ PyObject *func) {
    Py_DECREF(func);
}

/* simple callback handler -- this one actually looks at the return type */
/* used for timeout and idle functions */
static void PyGtk_HandlerMarshal(gpointer a, PyObject *func, int nargs,
                                                          GtkArg *args) {
  PyObject *ret;

  ret = PyObject_CallObject(func, NULL);
  if (ret == NULL) {
    PyErr_Print();
    PyErr_Clear();
    *GTK_RETLOC_BOOL(args[0]) = FALSE;
    return;
  }
  if (ret == Py_None || (PyInt_Check(ret) && PyInt_AsLong(ret) == 0))
    *GTK_RETLOC_BOOL(args[0]) = FALSE;
  else
    *GTK_RETLOC_BOOL(args[0]) = TRUE;
  Py_DECREF(ret);
}

/* callback for input handlers */
static void PyGtk_InputMarshal(gpointer a, PyObject *func, int nargs,
			                                GtkArg *args) {
  PyObject *tuple, *ret;

  tuple = Py_BuildValue("(ii)", GTK_VALUE_INT(args[0]),
			GTK_VALUE_FLAGS(args[1]));
  ret = PyObject_CallObject(func, tuple);
  Py_DECREF(tuple);
  if (ret == NULL) {
    PyErr_Print();
    PyErr_Clear();
  } else
    Py_DECREF(ret);
}

static GtkArg *PyDict_AsGtkArgs(PyObject *dict, GtkType type, gint *nargs) {
    PyObject *key, *item;
    gint i = 0, pos;
    GtkArg *arg;
    GtkArgInfo *info;
    gchar *err, buf[128];

    gtk_type_class(type); /* initialise the class structure (and setup args) */
    *nargs = PyDict_Size(dict);
    arg = g_new(GtkArg, *nargs);
    pos = 0;
    while (PyDict_Next(dict, &i, &key, &item)) {
        if (!PyString_Check(key)) {
	    PyErr_SetString(PyExc_TypeError,"dictionary keys must be strings");
	    g_free(arg);
	    return NULL;
        }
	arg[pos].name = PyString_AsString(key);
	err = gtk_object_arg_get_info(type, arg[pos].name, &info);
	if (info == NULL) {
	    PyErr_SetString(PyExc_TypeError, err);
	    g_free(err);
	    g_free(arg);
	    return NULL;
	}
	arg[pos].type = info->type;
	arg[pos].name = info->name;
	if (GtkArg_FromPyObject(&(arg[pos]), item)) {
	    g_snprintf(buf, 255, "arg %s: expected type %s, found %s",
		       arg[pos].name, gtk_type_name(arg[pos].type),
		       item->ob_type->tp_name);
	    PyErr_SetString(PyExc_TypeError, buf);
	    g_free(arg);
	    return NULL;
	}
	pos++;
    }
    return arg;
}

static void PyGtk_object_set(GtkObject *o, PyObject *dict) {
    int i = 0;
    PyObject *key, *item;
    char *name, *err;
    GtkType obtype;
    GtkArg arg;
    GtkArgInfo *info;
 
    obtype = GTK_OBJECT_TYPE(o);

    while (PyDict_Next(dict, &i, &key, &item)) {
        if (!PyString_Check(key)) {
            fprintf(stderr, "Key not a string\n");
            continue;
        }
        name = PyString_AsString(key);
	err = gtk_object_arg_get_info(obtype, name, &info);
        if (info == NULL) {
            fprintf(stderr, err);
	    g_free(err);
            continue;
        }

        arg.type = info->type;
        arg.name = info->name;
	if (GtkArg_FromPyObject(&arg, item)) {
	  fprintf(stderr, "%s: expected %s, %s found\n", name,
		  gtk_type_name(arg.type), item->ob_type->tp_name);
	  continue;
	}
        gtk_object_setv(o, 1, &arg);
    }
}

static GtkArg *PyDict_AsContainerArgs(PyObject *dict,GtkType type,gint *nargs){
    PyObject *key, *item;
    gint i = 0, pos;
    GtkArg *arg;
    GtkArgInfo *info;
    gchar *err, buf[128];

    *nargs = PyDict_Size(dict);
    arg = g_new(GtkArg, *nargs);
    pos = 0;
    while (PyDict_Next(dict, &i, &key, &item)) {
        if (!PyString_Check(key)) {
	    PyErr_SetString(PyExc_TypeError,"dictionary keys must be strings");
	    g_free(arg);
	    return NULL;
        }
	arg[pos].name = PyString_AsString(key);
	err = gtk_container_child_arg_get_info(type, arg[pos].name, &info);
	if (info == NULL) {
	    PyErr_SetString(PyExc_TypeError, err);
	    g_free(err);
	    g_free(arg);
	    return NULL;
	}
	arg[pos].type = info->type;
	arg[pos].name = info->name;
	if (GtkArg_FromPyObject(&(arg[pos]), item)) {
	    g_snprintf(buf, 255, "arg %s: expected type %s, found %s",
		       arg[pos].name, gtk_type_name(arg[pos].type),
		       item->ob_type->tp_name);
	    PyErr_SetString(PyExc_TypeError, buf);
	    g_free(arg);
	    return NULL;
	}
	pos++;
    }
    return arg;
}

static PyObject *_wrap_gtk_signal_connect(PyObject *self, PyObject *args) {
    PyGtk_Object *obj;
    char *name;
    PyObject *func, *extra = NULL;
    int signum;

    if (!PyArg_ParseTuple(args, "O!sO|O!:gtk_signal_connect", &PyGtk_Type,
			  &obj, &name, &func, &PyTuple_Type, &extra))
        return NULL;
    if (!PyCallable_Check(func)) {
        PyErr_SetString(PyExc_TypeError, "third argument must be callable");
        return NULL;
    }
    Py_INCREF(func);
    if (extra) {
      PyObject *tmp;
      tmp = PyTuple_New(2);
      PyTuple_SetItem(tmp, 0, func);
      Py_INCREF(extra);
      PyTuple_SetItem(tmp, 1, extra);
      func = tmp;
    }
    signum = gtk_signal_connect_full(PyGtk_Get(obj), name, NULL,
				     (GtkCallbackMarshal)PyGtk_CallbackMarshal,
				     func, PyGtk_DestroyNotify, FALSE, FALSE);
    return PyInt_FromLong(signum);
}

static PyObject *_wrap_gtk_signal_connect_after(PyObject *self, PyObject *args) {
    PyGtk_Object *obj;
    char *name;
    PyObject *func, *extra = NULL;
    int signum;

    if (!PyArg_ParseTuple(args, "O!sO|O!:gtk_signal_connect_after",
                    &PyGtk_Type, &obj, &name, &func, &PyTuple_Type, &extra))
        return NULL;
    if (!PyCallable_Check(func)) {
        PyErr_SetString(PyExc_TypeError, "third argument must be callable");
        return NULL;
    }
    Py_INCREF(func);
    if (extra) {
      PyObject *tmp;
      tmp = PyTuple_New(2);
      PyTuple_SetItem(tmp, 0, func);
      Py_INCREF(extra);
      PyTuple_SetItem(tmp, 1, extra);
      func = tmp;
    }
    signum = gtk_signal_connect_full(PyGtk_Get(obj), name, NULL,
				     (GtkCallbackMarshal)PyGtk_CallbackMarshal,
				     func, PyGtk_DestroyNotify, FALSE, TRUE);
    return PyInt_FromLong(signum);
}

static PyObject *_wrap_gtk_signal_disconnect_by_data(PyObject *self, PyObject *args) {
  PyObject *obj;
  PyObject *data;
  
  self = self;
  if(!PyArg_ParseTuple(args,"O!O:gtk_signal_disconnect_by_data",
		       &PyGtk_Type, &obj, &data)) 
    return NULL;
  gtk_signal_disconnect_by_data(PyGtk_Get(obj), data);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_signal_handler_block_by_data(PyObject *self, PyObject *args) {
    PyObject *obj;
    PyObject *data;

    if(!PyArg_ParseTuple(args,"O!O:gtk_signal_handler_block_by_data",
			 &PyGtk_Type, &obj, &data)) 
        return NULL;
    gtk_signal_handler_block_by_data(PyGtk_Get(obj), data);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_signal_handler_unblock_by_data(PyObject *self, PyObject *args) {
    PyObject *obj;
    PyObject *data;

    if(!PyArg_ParseTuple(args,"O!O:gtk_signal_handler_unblock_by_data",
			 &PyGtk_Type, &obj, &data)) 
        return NULL;
    gtk_signal_handler_unblock_by_data(PyGtk_Get(obj), data);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_signal_emitv_by_name(PyObject *self, PyObject *args) {
  guint signal_id, i, nparams;
  GtkSignalQuery *query;
  GtkArg *params;
  PyObject *obj, *py_params;
  gchar *name, buf[sizeof(GtkArg)]; /* large enough to hold any return value */

  if (!PyArg_ParseTuple(args, "O!sO:gtk_signal_emitv_by_name", &PyGtk_Type,
			&obj, &name, &py_params))
    return NULL;
  if (!PySequence_Check(py_params)) {
    PyErr_SetString(PyExc_TypeError, "third argument not a sequence");
    return NULL;
  }

  signal_id = gtk_signal_lookup(name, GTK_OBJECT_TYPE(PyGtk_Get(obj)));
  if (signal_id <= 0) {
    PyErr_SetString(PyExc_KeyError, "can't find signal in classes ancestry");
    return NULL;
  }
  query = gtk_signal_query(signal_id);
  params = g_new(GtkArg, query->nparams + 1);
  nparams = query->nparams;
  for (i = 0; i < nparams; i++) {
    params[i].type = query->params[i];
    params[i].name = NULL;
  }
  params[i].type = query->return_val;
  params[i].name = NULL;
  params[i].d.pointer_data = buf; /* buffer to hold return value */
  g_free(query);
  if (GtkArgs_FromSequence(params, query->nparams, py_params)) {
    g_free(params);
    return NULL;
  }
  gtk_signal_emitv(PyGtk_Get(obj), signal_id, params);
  obj = GtkRet_AsPyObject(&params[nparams]);
  g_free(params);
  if (obj == NULL) { Py_INCREF(Py_None); obj = Py_None; }
  return obj;
}

static PyObject * _wrap_gtk_init(PyObject *self, PyObject *args) {
    PyObject *av;
    int argc, i;
    char **argv;

    /* ensure that this procedure only gets run once */
    static int run_already = 0;
    if (run_already) {
        Py_INCREF(Py_None);
        return Py_None;
    }
    run_already = 1;

    if (!PyArg_ParseTuple(args, ":gtk_init"))
        return NULL;

    av = PySys_GetObject("argv");
    argc = PyList_Size(av);
    argv = malloc(argc * sizeof(char *));
    for (i = 0; i < argc; i++)
        argv[i] = strdup(PyString_AsString(PyList_GetItem(av, i)));

    gtk_init(&argc, &argv);
    PySys_SetArgv(argc, argv);

    if (argv != NULL) {
        for (i = 0; i < argc; i++)
            if (argv[i] != NULL)
                free(argv[i]);
        free(argv);
    }
    gtk_signal_set_funcs((GtkSignalMarshal)PyGtk_SignalMarshal,
                         (GtkSignalDestroy)PyGtk_SignalDestroy);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_main_iteration(PyObject *self, PyObject *args) {
    int block = 1;

    if(!PyArg_ParseTuple(args,"|i:gtk_main_iteration", &block)) 
        return NULL;
    return PyInt_FromLong(gtk_main_iteration_do(block));
}

static PyObject *
_wrap_gtk_timeout_add(PyObject *self, PyObject *args) {
    guint32 interval;
    PyObject *callback;
    if (!PyArg_ParseTuple(args, "iO:gtk_timeout_add", &interval, &callback))
        return NULL;
    if (!PyCallable_Check(callback)) {
        PyErr_SetString(PyExc_TypeError, "second arg not callable");
        return NULL;
    }
    Py_INCREF(callback);
    return PyInt_FromLong(gtk_timeout_add_full(interval, NULL,
        (GtkCallbackMarshal)PyGtk_HandlerMarshal, callback,
        (GtkDestroyNotify)PyGtk_DestroyNotify));
}

static PyObject *
_wrap_gtk_idle_add(PyObject *self, PyObject *args) {
    PyObject *callback;
    if (!PyArg_ParseTuple(args, "O:gtk_idle_add", &callback))
        return NULL;
    if (!PyCallable_Check(callback)) {
        PyErr_SetString(PyExc_TypeError, "arg not callable");
        return NULL;
    }
    Py_INCREF(callback);
    return PyInt_FromLong(gtk_idle_add_full(GTK_PRIORITY_DEFAULT, NULL,
        (GtkCallbackMarshal)PyGtk_HandlerMarshal, callback, 
        (GtkDestroyNotify)PyGtk_DestroyNotify));
}

static PyObject *
_wrap_gtk_idle_add_priority(PyObject *self, PyObject *args) {
    int p;
    PyObject *callback;
    if (!PyArg_ParseTuple(args, "iO:gtk_idle_add_priority", &p, &callback))
        return NULL;
    if (!PyCallable_Check(callback)) {
        PyErr_SetString(PyExc_TypeError, "2nd arg not callable");
        return NULL;
    }
    Py_INCREF(callback);
    return PyInt_FromLong(gtk_idle_add_full(p, NULL,
        (GtkCallbackMarshal)PyGtk_HandlerMarshal, callback, 
        (GtkDestroyNotify)PyGtk_DestroyNotify));
}

static PyObject *_wrap_gtk_idle_remove_function(PyObject *self, PyObject *args) {
    PyObject *data;

    if(!PyArg_ParseTuple(args,"O:gtk_idle_remove_function", &data)) 
        return NULL;
    gtk_idle_remove_by_data(data);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_gtk_quit_add(PyObject *self, PyObject *args) {
    int main_level;
    PyObject *callback;
    if (!PyArg_ParseTuple(args, "iO:gtk_quit_add", &main_level, &callback))
        return NULL;
    if (!PyCallable_Check(callback)) {
        PyErr_SetString(PyExc_TypeError, "2nd arg not callable");
        return NULL;
    }
    Py_INCREF(callback);
    return PyInt_FromLong(gtk_quit_add_full(main_level, NULL,
        (GtkCallbackMarshal)PyGtk_HandlerMarshal, callback, 
        (GtkDestroyNotify)PyGtk_DestroyNotify));
}

static PyObject *_wrap_gtk_quit_remove_function(PyObject *self, PyObject *args) {
    PyObject *data;

    if(!PyArg_ParseTuple(args,"O:gtk_quit_remove_function",&data)) 
        return NULL;
    gtk_quit_remove_by_data(data);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_gtk_input_add(PyObject *self, PyObject *args) {
    int source;
    GdkInputCondition condition;
    PyObject *callback;
    if (!PyArg_ParseTuple(args, "iiO:gtk_input_add", &source, &condition,
			  &callback))
        return NULL;
    if (!PyCallable_Check(callback)) {
        PyErr_SetString(PyExc_TypeError, "3rd arg not callable.");
	return NULL;
    }
    Py_INCREF(callback);
    return PyInt_FromLong(gtk_input_add_full(source, condition, NULL,
			(GtkCallbackMarshal)PyGtk_InputMarshal, callback,
			(GtkDestroyNotify)PyGtk_DestroyNotify));
}

static PyObject *_wrap_gtk_object_set(PyObject *self, PyObject *args) {
    PyObject *obj, *dict;
    GtkArg *arg;
    gint nargs;

    if (!PyArg_ParseTuple(args, "O!O!:gtk_object_set", &PyGtk_Type, &obj,
                  &PyDict_Type, &dict))
        return NULL;
    arg = PyDict_AsGtkArgs(dict, GTK_OBJECT_TYPE(PyGtk_Get(obj)), &nargs);
    if (arg == NULL && nargs != 0)
      return NULL;
    gtk_object_setv(PyGtk_Get(obj), nargs, arg);
    g_free(arg);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_object_new(PyObject *self, PyObject *args) {
    GtkType type;
    gint nargs, i;
    GtkArg *arg;
    PyObject *dict;
    GtkObject *obj;

    if (!PyArg_ParseTuple(args, "iO!:gtk_object_new", &type, &PyDict_Type,
			  &dict))
        return NULL;
    arg = PyDict_AsGtkArgs(dict, type, &nargs);
    if (arg == NULL && nargs != 0)
        return NULL;
    obj = gtk_object_newv(type, nargs, arg);
    g_free(arg);
    return PyGtk_New(obj);
}

static PyObject *_wrap_gtk_object_get(PyObject *self, PyObject *args) {
    PyGtk_Object *o;
    char *name;
    GtkArg garg;
    PyObject *ret;

    if (!PyArg_ParseTuple(args, "O!s:gtk_object_get", &PyGtk_Type, &o, &name))
        return NULL;
    garg.name = name;
    gtk_object_getv(PyGtk_Get(o), 1, &garg);

    if (garg.type == GTK_TYPE_INVALID) {
        PyErr_SetString(PyExc_AttributeError, "invalid property");
        return NULL;
    }
    ret = GtkArg_AsPyObject(&garg);
    if (ret == NULL) {
      PyErr_SetString(PyExc_TypeError, "couldn't translate type");
      return NULL;
    }
    return ret;
}

static PyObject *_wrap_gtk_object_set_data(PyObject *self, PyObject *args) {
	PyGtk_Object *obj;
	char *key;
	PyObject *data;
	if (!PyArg_ParseTuple(args, "O!sO:gtk_object_set_data", &PyGtk_Type,
			&obj, &key, &data))
		return NULL;
	Py_INCREF(data);
	gtk_object_set_data_full(PyGtk_Get(obj), key, data,
		(GtkDestroyNotify)PyGtk_DestroyNotify);
	Py_INCREF(Py_None);
	return Py_None;
}

static PyObject *_wrap_gtk_object_get_data(PyObject *self, PyObject *args) {
	PyGtk_Object *obj;
	char *key;
	PyObject *data;
	if (!PyArg_ParseTuple(args, "O!s:gtk_object_get_data", &PyGtk_Type,
			&obj, &key))
		return NULL;
	data = gtk_object_get_data(PyGtk_Get(obj), key);
	if (data != NULL) {
		Py_INCREF(data);
		return data;
	} else {
		Py_INCREF(Py_None);
		return Py_None;
	}
}

static PyObject *_wrap_gtk_object_remove_data(PyObject *self, PyObject *args) {
    char *key;
    PyObject *obj;

    if(!PyArg_ParseTuple(args,"O!s:gtk_object_remove_data", &PyGtk_Type,
			 &obj, &key)) 
        return NULL;
    gtk_object_remove_data(PyGtk_Get(obj), key);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_widget_get_window(PyObject *self, PyObject *args) {
    GdkWindow *win;
    PyObject *obj;

    if(!PyArg_ParseTuple(args,"O!:gtk_widget_get_window", &PyGtk_Type, &obj)) 
        return NULL;
    win = GTK_WIDGET(PyGtk_Get(obj))->window;
    if (win == NULL) {
        Py_INCREF(Py_None);
        return Py_None;
    } else
        return PyGdkWindow_New(win);
}

static PyObject *_wrap_gtk_widget_draw(PyObject *self, PyObject *args) {
    GdkRectangle rect;
    PyObject *obj;

    if (!PyArg_ParseTuple(args,"O!(iiii):gtk_widget_draw", &PyGtk_Type, &obj,
			 &(rect.x), &(rect.y), &(rect.width), &(rect.height)))
        return NULL;
    gtk_widget_draw(GTK_WIDGET(PyGtk_Get(obj)), &rect);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_widget_size_request(PyObject *self, PyObject *args) {
    GtkRequisition requisition;
    PyObject *obj;

    if(!PyArg_ParseTuple(args,"O!:gtk_widget_size_request", &PyGtk_Type, &obj))
        return NULL;
    gtk_widget_size_request(GTK_WIDGET(PyGtk_Get(obj)), &requisition);
    return Py_BuildValue("(ii)", requisition.width, requisition.height);
}

static PyObject *_wrap_gtk_widget_size_allocate(PyObject *self, PyObject *args) {
    GtkAllocation allocation;
    PyObject *obj;

    if(!PyArg_ParseTuple(args,"O!(ii):gtk_widget_size_allocate", &PyGtk_Type,
			 &obj, &(allocation.x), &(allocation.y)))
        return NULL;
    gtk_widget_size_allocate(GTK_WIDGET(PyGtk_Get(obj)), &allocation);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_widget_intersect(PyObject *self, PyObject *args) {
    PyObject *obj;
    GdkRectangle area;
    GdkRectangle intersect;

    if(!PyArg_ParseTuple(args,"O!(iiii):gtk_widget_intersect", &PyGtk_Type,
			 &obj, &(area.x), &(area.y), &(area.width),
			 &(area.height))) 
        return NULL;
    if (gtk_widget_intersect(GTK_WIDGET(PyGtk_Get(obj)), &area, &intersect))
        return Py_BuildValue("(iiii)", intersect.x, intersect.y,
			     intersect.width, intersect.height);
    else {
        Py_INCREF(Py_None);
        return Py_None;
    }
}

static PyObject *_wrap_gtk_widget_get_pointer(PyObject *self, PyObject *args) {
  int x, y;
  PyObject *w;
  if (!PyArg_ParseTuple(args, "O!:gtk_widget_get_pointer", &PyGtk_Type, &w))
    return NULL;
  gtk_widget_get_pointer(GTK_WIDGET(PyGtk_Get(w)), &x, &y);
  return Py_BuildValue("(ii)", x, y);
}

static PyObject *_wrap_gtk_container_add(PyObject *self, PyObject *args) {
    PyObject *obj, *child, *dict = NULL;

    if(!PyArg_ParseTuple(args,"O!O!|O!:gtk_container_add", &PyGtk_Type, &obj,
			 &PyGtk_Type, &child, &PyDict_Type, &dict)) 
        return NULL;
    if (dict == NULL)
      gtk_container_add(GTK_CONTAINER(PyGtk_Get(obj)),
			GTK_WIDGET(PyGtk_Get(child)));
    else {
      gint nargs;
      GtkArg *arg = PyDict_AsContainerArgs(dict,
					   GTK_OBJECT_TYPE(PyGtk_Get(obj)),
					   &nargs);
      if (arg == NULL && nargs != 0)
	return NULL;
      gtk_container_addv(GTK_CONTAINER(PyGtk_Get(obj)),
			 GTK_WIDGET(PyGtk_Get(child)), nargs, arg);
      g_free(arg);
    }
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_container_child_set(PyObject *self, PyObject *args){
    PyObject *obj, *child, *dict;
    gint nargs;
    GtkArg *arg;

    if (!PyArg_ParseTuple(args, "O!O!O!:gtk_container_child_set", &PyGtk_Type,
                          &obj, &PyGtk_Type, &child, &PyDict_Type, &dict))
        return NULL;
    arg = PyDict_AsContainerArgs(dict, GTK_OBJECT_TYPE(PyGtk_Get(obj)),&nargs);
    if (arg == NULL && nargs != 0)
        return NULL;
    gtk_container_child_setv(GTK_CONTAINER(PyGtk_Get(obj)),
                             GTK_WIDGET(PyGtk_Get(child)), nargs, arg);
    g_free(arg);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_container_child_get(PyObject *self, PyObject *args){
    PyObject *obj, *child, *ret;
    GtkArg arg;

    if (!PyArg_ParseTuple(args, "O!O!s:gtk_container_child_get", &PyGtk_Type,
			  &obj, &PyGtk_Type, &child, &(arg.name)))
        return NULL;
    gtk_container_child_getv(GTK_CONTAINER(PyGtk_Get(obj)),
			     GTK_WIDGET(PyGtk_Get(child)), 1, &arg);
    if (arg.type == GTK_TYPE_INVALID) {
        PyErr_SetString(PyExc_AttributeError, "invalid property");
	return NULL;
    }
    ret = GtkArg_AsPyObject(&arg);
    if (ret == NULL) {
        PyErr_SetString(PyExc_TypeError, "couldn't translate type");
	return NULL;
    }
    return ret;
}

static PyObject *_wrap_gtk_container_children(PyObject *self, PyObject *args) {
    PyObject *obj;
    GList *list, *tmp;
    PyObject *py_list;

    if(!PyArg_ParseTuple(args,"O!:gtk_container_children", &PyGtk_Type, &obj))
        return NULL;
    list = gtk_container_children(GTK_CONTAINER(PyGtk_Get(obj)));
    py_list = PyList_New(0);
    for (tmp = list; tmp != NULL; tmp = tmp->next)
      PyList_Append(py_list, PyGtk_New(GTK_OBJECT(tmp->data)));
    g_list_free(list);
    return py_list;
}

static PyObject *_wrap_gtk_window_set_icon(PyObject *self, PyObject *args) {
	PyGtk_Object *o, *pix, *mask;
        GtkWidget *win;
	if (!PyArg_ParseTuple(args, "O!O!O!:gtk_window_set_icon", &PyGtk_Type,
			&o, &PyGdkWindow_Type, &pix, &PyGdkWindow_Type, &mask))
		return NULL;
	win = GTK_WIDGET(PyGtk_Get(o));
	gtk_widget_realize(win);
	gdk_window_set_icon(win->window, NULL, PyGdkWindow_Get(pix),
			    PyGdkWindow_Get(mask));
	Py_INCREF(Py_None);
	return Py_None;
}
static PyObject *_wrap_gtk_window_set_icon_name(PyObject *self, PyObject *args) {
	PyGtk_Object *o;
	char *name;
	if (!PyArg_ParseTuple(args, "O!s:gtk_window_set_icon_name",
			&PyGtk_Type, &o, &name))
		return NULL;
	gdk_window_set_icon_name(GTK_WIDGET(PyGtk_Get(o))->window, name);
	Py_INCREF(Py_None);
	return Py_None;
}
/* --- */
static PyObject *
_wrap_gtk_box_query_child_packing(PyObject *self, PyObject *args) {
  PyObject *box, *child;
  gboolean expand, fill;
  guint padding;
  GtkPackType pack_type;
  if (!PyArg_ParseTuple(args, "O!O!:gtk_box_query_child_packing", &PyGtk_Type,
			&box, &PyGtk_Type, &child))
    return NULL;
  gtk_box_query_child_packing(GTK_BOX(PyGtk_Get(box)),
			      GTK_WIDGET(PyGtk_Get(child)), &expand, &fill,
			      &padding, &pack_type);
  return Py_BuildValue("(iiii)", (int)expand, (int)fill, padding, pack_type);
}

static PyObject *
_wrap_gtk_button_box_get_child_size_default(PyObject *self, PyObject *args) {
    int mw, mh;
    if (!PyArg_ParseTuple(args, ":gtk_button_box_get_child_size_default"))
        return NULL;
    gtk_button_box_get_child_size_default(&mw, &mh);
    return Py_BuildValue("(ii)", mw, mh);
}
static PyObject *
_wrap_gtk_button_box_get_child_ipadding_default(PyObject *self, PyObject *args) {
    int ipx, ipy;
    if (!PyArg_ParseTuple(args, ":gtk_button_box_get_child_ipadding_default"))
        return NULL;
    gtk_button_box_get_child_ipadding_default(&ipx, &ipy);
    return Py_BuildValue("(ii)", ipx, ipy);
}
static PyObject *
_wrap_gtk_button_box_get_child_size(PyObject *self, PyObject *args) {
    int mw, mh;
    PyGtk_Object *o;
    if (!PyArg_ParseTuple(args, "O!:gtk_button_box_get_child_size",
            &PyGtk_Type, &o))
        return NULL;
    gtk_button_box_get_child_size(GTK_BUTTON_BOX(PyGtk_Get(o)), &mw, &mh);
    return Py_BuildValue("(ii)", mw, mh);
}
static PyObject *
_wrap_gtk_button_box_get_child_ipadding(PyObject *self, PyObject *args) {
    int ipx, ipy;
    PyGtk_Object *o;
    if (!PyArg_ParseTuple(args, "O!:gtk_button_box_get_child_ipadding",
            &PyGtk_Type, &o))
        return NULL;
    gtk_button_box_get_child_ipadding(GTK_BUTTON_BOX(PyGtk_Get(o)),&ipx,&ipy);
    return Py_BuildValue("(ii)", ipx, ipy);
}

static PyObject *_wrap_gtk_clist_get_selection(PyObject *self, PyObject *args) {
  GList *selection;
  guint row;
  PyObject *clist, *ret;
  if (!PyArg_ParseTuple(args, "O!:gtk_clist_get_selection", &PyGtk_Type,
			&clist))
    return NULL;
  ret = PyList_New(0);
  for (selection = GTK_CLIST(PyGtk_Get(clist))->selection; selection != NULL;
       selection = selection->next) {
    row = (guint)selection->data;
    PyList_Append(ret, PyInt_FromLong(row));
  }
  return ret;
}
static PyObject *_wrap_gtk_clist_new_with_titles(PyObject *self, PyObject *args) {
	int c, i;
	PyObject *l, *item;
	char **list;
	if (!PyArg_ParseTuple(args, "iO:gtk_clist_new_with_titles",
			&c, &l))
		return NULL;
	if (!PySequence_Check(l)) {
		PyErr_SetString(PyExc_TypeError,"3rd argument not a sequence");
		return NULL;
	}
	if (PySequence_Length(l) < c) {
		PyErr_SetString(PyExc_TypeError, "sequence not long enough");
		return NULL;
	}
	list = malloc(sizeof(char *)*c);
	for (i = 0; i < c; i++) {
		item = PySequence_GetItem(l, i);
		if (!PyString_Check(item)) {
			PyErr_SetString(PyExc_TypeError,
				 "sequence item not a string");
			free(list);
			return NULL;
		}
		list[i] = PyString_AsString(item);
	}
	item = (PyObject *) PyGtk_New((GtkObject *)gtk_clist_new_with_titles
		(c, list));
	free(list);
	return item;
}

static PyObject *_wrap_gtk_clist_get_text(PyObject *self, PyObject *args) {
  PyObject *w;
  int r, c;
  char *text;

  if (!PyArg_ParseTuple(args, "O!ii:gtk_clist_get_text", &PyGtk_Type,
			&w, &r, &c))
    return NULL;
  if (!gtk_clist_get_text(GTK_CLIST(PyGtk_Get(w)), r, c, &text)) {
    PyErr_SetString(PyExc_ValueError, "can't get text value");
    return NULL;
  }
  return PyString_FromString(text);
}

static PyObject *_wrap_gtk_clist_get_pixmap(PyObject *self, PyObject *args) {
  PyObject *o, *mask;
  int r, c;
  GdkPixmap *p;
  GdkBitmap *m;

  if (!PyArg_ParseTuple(args, "O!iiO!:gtk_clist_get_pixmap", &PyGtk_Type,
			&o, &r, &c))
    return NULL;
  if (!gtk_clist_get_pixmap(GTK_CLIST(PyGtk_Get(o)), r, c, &p, &m)) {
    PyErr_SetString(PyExc_ValueError, "can't get pixmap value");
    return NULL;
  }
  if (m)
    mask = PyGdkWindow_New(m);
  else {
    Py_INCREF(Py_None);
    mask = Py_None;
  }
  return Py_BuildValue("(OO)", PyGdkWindow_New(p), PyGdkWindow_New(m));
}

static PyObject *_wrap_gtk_clist_get_pixtext(PyObject *self, PyObject *args) {
  PyObject *o, *mask;
  int r, c;
  guint8 spacing;
  char *text;
  GdkPixmap *p;
  GdkBitmap *m;

  if (!PyArg_ParseTuple(args, "O!ii:gtk_clist_get_pixtext",
			&PyGtk_Type, &o, &r, &c))
    return NULL;
  if (!gtk_clist_get_pixtext(GTK_CLIST(PyGtk_Get(o)), r, c,
			     &text, &spacing, &p, &m)) {
    PyErr_SetString(PyExc_ValueError, "can't get pixtext value");
    return NULL;
  }
  if (m)
    mask = PyGdkWindow_New(m);
  else {
    Py_INCREF(Py_None);
    mask = Py_None;
  }
  return Py_BuildValue("(siOO)", text, (int)spacing,
		       PyGdkWindow_New(p), mask);
}

static PyObject *_wrap_gtk_clist_prepend(PyObject *self, PyObject *args) {
	PyGtk_Object *cl;
	int col, i;
	PyObject *l, *item;
	char **list;
	if (!PyArg_ParseTuple(args, "O!O:gtk_clist_prepend", &PyGtk_Type, &cl,
			&l))
		return NULL;
	if (!PySequence_Check(l)) {
		PyErr_SetString(PyExc_TypeError, "argument not a sequence");
		return NULL;
	}
	col = GTK_CLIST(PyGtk_Get(cl))->columns;
	if (PySequence_Length(l) < col) {
		PyErr_SetString(PyExc_TypeError, "sequnce too short");
		return NULL;
	}
	list = g_new(gchar *, col);
	for (i = 0; i < col; i++) {
		item = PySequence_GetItem(l, i);
		if (!PyString_Check(item)) {
			PyErr_SetString(PyExc_TypeError,
				"sequence item not a string");
			g_free(list);
			return NULL;
		}
		list[i] = PyString_AsString(item);
	}
	i = gtk_clist_prepend(GTK_CLIST(PyGtk_Get(cl)), list);
	g_free(list);
	return PyInt_FromLong(i);
}

static PyObject *_wrap_gtk_clist_append(PyObject *self, PyObject *args) {
	PyGtk_Object *cl;
	int col, i;
	PyObject *l, *item;
	char **list;
	if (!PyArg_ParseTuple(args, "O!O:gtk_clist_append", &PyGtk_Type, &cl,
			&l))
		return NULL;
	if (!PySequence_Check(l)) {
		PyErr_SetString(PyExc_TypeError, "argument not a sequence");
		return NULL;
	}
	col = GTK_CLIST(PyGtk_Get(cl))->columns;
	if (PySequence_Length(l) < col) {
		PyErr_SetString(PyExc_TypeError, "sequnce too short");
		return NULL;
	}
	list = g_new(gchar *, col);
	for (i = 0; i < col; i++) {
		item = PySequence_GetItem(l, i);
		if (!PyString_Check(item)) {
			PyErr_SetString(PyExc_TypeError,
				"sequence item not a string");
			g_free(list);
			return NULL;
		}
		list[i] = PyString_AsString(item);
	}
	i = gtk_clist_append(GTK_CLIST(PyGtk_Get(cl)), list);
	g_free(list);
	return PyInt_FromLong(i);
}

static PyObject *_wrap_gtk_clist_insert(PyObject *self, PyObject *args) {
	PyGtk_Object *cl;
	int col, r, i;
	PyObject *l, *item;
	char **list;
	if (!PyArg_ParseTuple(args, "O!iO:gtk_clist_insert", &PyGtk_Type, &cl,
			&r, &l))
		return NULL;
	if (!PySequence_Check(l)) {
		PyErr_SetString(PyExc_TypeError, "argument not a sequence");
		return NULL;
	}
	col = GTK_CLIST(PyGtk_Get(cl))->columns;
	if (PySequence_Length(l) < col) {
		PyErr_SetString(PyExc_TypeError, "sequnce too short");
		return NULL;
	}
	list = g_new(gchar *, col);
	for (i = 0; i < col; i++) {
		item = PySequence_GetItem(l, i);
		if (!PyString_Check(item)) {
			PyErr_SetString(PyExc_TypeError,
				"sequence item not a string");
			g_free(list);
			return NULL;
		}
		list[i] = PyString_AsString(item);
	}
	i = gtk_clist_insert(GTK_CLIST(PyGtk_Get(cl)), r, list);
	g_free(list);
	return PyInt_FromLong(i);
}
static PyObject *_wrap_gtk_clist_set_row_data(PyObject *self, PyObject *args) {
        PyGtk_Object *obj;
	int row;
	PyObject *data;
	if (!PyArg_ParseTuple(args, "O!iO:gtk_clist_set_row_data", &PyGtk_Type,
			      &obj, &row, &data))
	    return NULL;
	Py_INCREF(data);
	gtk_clist_set_row_data_full(GTK_CLIST(PyGtk_Get(obj)), row, data,
				    (GtkDestroyNotify)PyGtk_DestroyNotify);
	Py_INCREF(Py_None);
	return Py_None;
}
static PyObject *_wrap_gtk_clist_get_row_data(PyObject *s, PyObject *args) {
    PyObject *clist, *ret;
    int row;

    if (!PyArg_ParseTuple(args, "O!i:gtk_clist_get_row_data", &PyGtk_Type,
			  &clist, &row))
        return NULL;
    ret = gtk_clist_get_row_data(GTK_CLIST(PyGtk_Get(clist)), row);
    if (!ret) ret = Py_None;
    Py_INCREF(ret);
    return ret;
}
static PyObject *_wrap_gtk_clist_find_row_from_data(PyObject *s, PyObject *args) {
    PyObject *clist, *data;

    if (!PyArg_ParseTuple(args, "O!O:gtk_clist_find_row_from_data",
			  &PyGtk_Type, &clist, &data))
        return NULL;
    return PyInt_FromLong(gtk_clist_find_row_from_data(
				GTK_CLIST(PyGtk_Get(clist)), data));
}
static PyObject *_wrap_gtk_clist_get_selection_info(PyObject *s, PyObject *args) {
  PyObject *clist;
  gint x, y, row, column;
  if (!PyArg_ParseTuple(args, "O!ii:gtk_clist_get_selection_info", &PyGtk_Type,
			&clist, &x, &y))
    return NULL;
  if (gtk_clist_get_selection_info(GTK_CLIST(PyGtk_Get(clist)), x, y,
				   &row, &column))
    return Py_BuildValue("(ii)", row, column);
  else {
    Py_INCREF(Py_None);
    return Py_None;
  }
}   

static PyObject *
_wrap_gtk_combo_set_popdown_strings(PyObject *self, PyObject *args) {
  PyObject *obj, *list, *item;
  GList *glist = NULL;
  int len, i;
  if (!PyArg_ParseTuple(args, "O!O!:gtk_combo_set_popdown_strings",
			&PyGtk_Type, &obj, &PyList_Type, &list))
    return NULL;
  len = PyList_Size(list);
  for (i = 0; i < len; i++) {
    item = PyList_GetItem(list, i);
    if (!PyString_Check(item)) {
      PyErr_SetString(PyExc_TypeError, "list item not a string");
      g_list_free(glist);
      return NULL;
    }
    glist = g_list_append(glist, PyString_AsString(item));
  }
  gtk_combo_set_popdown_strings(GTK_COMBO(PyGtk_Get(obj)), glist);
  g_list_free(glist);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_curve_get_vector(PyObject *self, PyObject *args) {
  PyGtk_Object *obj;
  int size=-1, i;
  gfloat *vector;
  PyObject *ret;

  if (!PyArg_ParseTuple(args, "O!|i:gtk_curve_get_vector", &PyGtk_Type, &obj,
			&size))
    return NULL;
  if (size < 0) size = GTK_CURVE(PyGtk_Get(obj))->num_points;
  vector = g_new(gfloat, size);
  gtk_curve_get_vector(GTK_CURVE(PyGtk_Get(obj)), size, vector);
  ret = PyTuple_New(size);
  for (i = 0; i < size; i++)
    PyTuple_SetItem(ret, i, PyFloat_FromDouble(vector[i]));
  g_free(vector);
  return ret;
}
static PyObject *_wrap_gtk_curve_set_vector(PyObject *self, PyObject *args) {
  PyGtk_Object *obj;
  PyObject *seq, *item;
  int size, i;
  gfloat *vector;

  if (!PyArg_ParseTuple(args, "O!O:gtk_curve_set_vector", &PyGtk_Type, &obj,
			&seq))
    return NULL;
  if (!PySequence_Check(seq)) {
    PyErr_SetString(PyExc_TypeError, "2nd argument is not a sequence");
    return NULL;
  }
  size = PySequence_Length(seq);
  vector = g_new(gfloat, size);
  for (i = 0; i < size; i++) {
    item = PyNumber_Float(PySequence_GetItem(seq, i));
    if (item == NULL) {
      g_free(vector);
      return NULL;
    }
    vector[i] = PyFloat_AsDouble(item);
    Py_DECREF(item);
  }
  gtk_curve_set_vector(GTK_CURVE(PyGtk_Get(obj)), size, vector);
  g_free(vector);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_editable_insert_text(PyObject *self, PyObject *args) {
    PyGtk_Object *o;
    char *text;
    int len, pos;
    if (!PyArg_ParseTuple(args, "O!s#:gtk_editable_insert_text",
			  &PyGtk_Type, &o, &text, &len))
        return NULL;
    gtk_editable_insert_text(GTK_EDITABLE(PyGtk_Get(o)), text, len, &pos);
    return PyInt_FromLong(pos);
}

static PyObject *_wrap_gtk_frame_new(PyObject *self, PyObject *args) {
    char *label;

    if (!PyArg_ParseTuple(args, "z:gtk_frame_new", &label))
        return NULL;
    return PyGtk_New((GtkObject *)gtk_frame_new(label));
}

static void PyGtk_item_factory_cb(PyObject *callback, guint action,
				  GtkWidget *widget) {
  PyObject *ret;
  ret = PyObject_CallFunction(callback, "iO", action,
			      PyGtk_New((GtkObject *)widget));
  if (ret == NULL) {
    PyErr_Print();
    PyErr_Clear();
  } else
    Py_DECREF(ret);
}
static PyObject *_wrap_gtk_item_factory_create_items(PyObject *self,PyObject *args){
  PyObject *obj, *list, *item, *cb;
  GtkItemFactoryEntry ent;
  GtkItemFactory *ifact;
  int i, len;
  if (!PyArg_ParseTuple(args, "O!O!:gtk_item_factory_create_items",
			&PyGtk_Type, &obj, &PyList_Type, &list))
    return NULL;
  ifact = GTK_ITEM_FACTORY(PyGtk_Get(obj));
  len = PyList_Size(list);
  for (i = 0; i < len; i++) {
    item = PyList_GetItem(list, i);
    if (!PyArg_ParseTuple(item, "zzOiz", &(ent.path), &(ent.accelerator),
			  &cb, &(ent.callback_action), &(ent.item_type)))
      return NULL;
    if (cb == Py_None)
      ent.callback = NULL;
    else {
      Py_INCREF(cb);
      ent.callback = (GtkItemFactoryCallback)PyGtk_item_factory_cb;
    }
    gtk_item_factory_create_item(ifact, &ent, cb, 1);
  }
  Py_INCREF(Py_None);
  return Py_None;
}

static void PyGtk_MenuPosition(GtkMenu *menu, int *x, int *y, PyObject *func) {
    PyObject *ret;
    ret = PyObject_CallFunction(func, "(O)", PyGtk_New(GTK_OBJECT(menu)));
    if (ret == NULL || !PyArg_ParseTuple(ret, "ii", x, y)) {
        PyErr_Print();
        PyErr_Clear();
        *x = 0;
        *y = 0;
    } else
        Py_DECREF(ret);
}
static PyObject *_wrap_gtk_menu_popup(PyObject *self, PyObject *args) {
    PyGtk_Object *m, *pms, *pmi;
    PyObject *func;
    int button, time;
    if (!PyArg_ParseTuple(args, "O!O!O!Oii:gtk_menu_item", &PyGtk_Type, &m,
            &PyGtk_Type, &pms, &PyGtk_Type, &pmi, &func, &button, &time))
        return NULL;
    if (!PyCallable_Check(func)) {
        PyErr_SetString(PyExc_TypeError, "forth argument not callable");
        return NULL;
    }
    Py_INCREF(func);
    gtk_menu_popup(GTK_MENU(PyGtk_Get(m)), GTK_WIDGET(PyGtk_Get(pms)),
        GTK_WIDGET(PyGtk_Get(pmi)), (GtkMenuPositionFunc)PyGtk_MenuPosition,
        func, button, time);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_pixmap_new_from_xpm(PyObject *self, PyObject *args) {
    PyGtk_Object *win;
    PyGdkColor_Object *tc = NULL;
    char *name;
    GdkColor *bg;
    GdkPixmap *pm;
    GdkBitmap *bm;
    PyObject *ret;

    if (!PyArg_ParseTuple(args, "O!s|O!:gtk_pixmap_new_from_xpm", &PyGtk_Type,
            &win, &name, &PyGdkColor_Type, &tc))
        return  NULL;
    if (tc == NULL)
        bg = NULL;
    else
        bg = PyGdkColor_Get(tc);
    pm = gdk_pixmap_create_from_xpm(GTK_WIDGET(PyGtk_Get(win))->window, &bm,
        bg, name);
    if (pm == NULL) {
      PyErr_SetString(PyExc_IOError, "can't load pixmap");
      return NULL;
    }
    ret = PyGtk_New(GTK_OBJECT(gtk_pixmap_new(pm, bm)));
    /* gtk_pixmap_new ref's the pixmap and mask, so we can unref out vars */
    gdk_pixmap_unref(pm);
    gdk_bitmap_unref(bm);
    return ret;
}
static PyObject *_wrap_gtk_pixmap_get(PyObject *self, PyObject *args) {
  PyObject *pix;
  GdkPixmap *pixmap;
  GdkBitmap *mask;
  if (!PyArg_ParseTuple(args, "O!:gtk_pixmap_get", &PyGtk_Type, &pix))
    return NULL;
  gtk_pixmap_get(GTK_PIXMAP(PyGtk_Get(pix)), &pixmap, &mask);
  if (!mask) Py_INCREF(Py_None);
  return Py_BuildValue("(OO)", PyGdkWindow_New(pixmap),
		       mask ? PyGdkWindow_New(mask) : Py_None);
}

static PyObject *_wrap_gtk_preview_draw_row(PyObject *self, PyObject *args) {
  PyObject *preview;
  char *data;
  int dummy_len, x, y, width;

  if (!PyArg_ParseTuple(args, "O!s#iii:gtk_preview_draw_row", &PyGtk_Type,
			&preview, &data, &dummy_len, &x, &y, &width))
    return NULL;
  gtk_preview_draw_row(GTK_PREVIEW(PyGtk_Get(preview)), data, x, y, width);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_radio_menu_item_new(PyObject *self, PyObject *args) {
    PyGtk_Object *g = NULL;
    GSList *l = NULL;
    if (!PyArg_ParseTuple(args, "|O!:gtk_radio_menu_item_new",&PyGtk_Type, &g))
        return NULL;
    if (g)
        l = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(PyGtk_Get(g)));
    return PyGtk_New(GTK_OBJECT(gtk_radio_menu_item_new(l)));
}
static PyObject *_wrap_gtk_radio_menu_item_new_with_label(PyObject *s,PyObject *a) {
    PyGtk_Object *g = NULL;
    char *label = "";
    GSList *l = NULL;
    if (!PyArg_ParseTuple(a, "|Os:gtk_radio_menu_item_new_with_label",
            &g, &label))
        return NULL;
    if (g != NULL)
        if (!PyGtk_Check(g) && (PyObject *)g != Py_None) {
            PyErr_SetString(PyExc_TypeError,
                "first argument not a GtkObject or None");
            return NULL;
        }
    if ((PyObject *)g == Py_None) g = NULL;
    if (g)
        l = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(PyGtk_Get(g)));
    return PyGtk_New(GTK_OBJECT(gtk_radio_menu_item_new_with_label(l, label)));
}

static PyObject *_wrap_gtk_radio_button_new(PyObject *self, PyObject *args) {
    if (!PyArg_ParseTuple(args, ":gtk_radio_button_new"))
        return NULL;
    return PyGtk_New((GtkObject *)gtk_radio_button_new(NULL));
}

static PyObject *_wrap_gtk_radio_button_new_with_label(PyObject *self, PyObject *args) {
    PyObject *nothing;
    char *label;

    if (!PyArg_ParseTuple(args, "Os:gtk_radio_button_new_with_label",
			  &nothing, &label))
        return NULL;
    return PyGtk_New((GtkObject *)gtk_radio_button_new_with_label(NULL,label));
}

static PyObject *_wrap_gtk_text_insert_defaults(PyObject *self, PyObject *args) {
    PyGtk_Object *txt;
    char *chars;
    int l;
    GtkStyle *style;
    if (!PyArg_ParseTuple(args, "O!s#:gtk_text_insert_defaults", &PyGtk_Type,
                                     &txt, &chars, &l))
        return NULL;
    style = gtk_widget_get_style(GTK_WIDGET(PyGtk_Get(txt)));
    gtk_text_insert(GTK_TEXT(PyGtk_Get(txt)), NULL,
        &style->fg[GTK_STATE_NORMAL], NULL, chars, l);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_toolbar_append_item(PyObject *self, PyObject *args) {
  PyGtk_Object *t, *icon;
  char *text, *tooltip, *tip_private;
  GtkWidget *ret;
  PyObject *callback;
  GList *tmp_list;
  if (!PyArg_ParseTuple(args, "O!zzzO!O|gtk_toolbar_append_item",
			&PyGtk_Type, &t, &text, &tooltip, &tip_private,
		       &PyGtk_Type, &icon, &callback))
    return NULL;
  if (!PyCallable_Check(callback) && callback != Py_None) {
    PyErr_SetString(PyExc_TypeError,"sixth argument not callable");
    return NULL;
  }
  Py_INCREF(callback);
  /* if you set sigfunc to NULL, no signal is connected, rather than
     the default signal handler being used */
  ret = gtk_toolbar_append_item(GTK_TOOLBAR(PyGtk_Get(t)), text, tooltip,
				tip_private, GTK_WIDGET(PyGtk_Get(icon)),
				NULL,NULL);
  if (callback != Py_None) {
    gtk_signal_connect_full(GTK_OBJECT(ret), "clicked", NULL,
			    PyGtk_CallbackMarshal, callback,
			    PyGtk_DestroyNotify, FALSE, FALSE);
  }
  return PyGtk_New((GtkObject *)ret);
}
static PyObject *_wrap_gtk_toolbar_prepend_item(PyObject *self, PyObject *args) {
  PyGtk_Object *t, *icon;
  char *text, *tooltip, *tip_private;
  GtkWidget *ret;
  PyObject *callback;
  if (!PyArg_ParseTuple(args, "O!zzzO!O|gtk_toolbar_prepend_item",
			&PyGtk_Type, &t, &text, &tooltip, &tip_private,
			&PyGtk_Type, &icon, &callback))
    return NULL;
  if (!PyCallable_Check(callback) && callback != Py_None) {
    PyErr_SetString(PyExc_TypeError,"sixth argument not callable");
    return NULL;
  }
  Py_INCREF(callback);
  ret = gtk_toolbar_prepend_item(GTK_TOOLBAR(PyGtk_Get(t)), text,
				 tooltip, tip_private,
				 GTK_WIDGET(PyGtk_Get(icon)),
				 NULL, NULL);
  if (callback != Py_None)
    gtk_signal_connect_full(GTK_OBJECT(ret), "clicked", NULL,
			    PyGtk_CallbackMarshal, callback,
			    PyGtk_DestroyNotify, FALSE, FALSE);
  return PyGtk_New((GtkObject *)ret);
}
static PyObject *_wrap_gtk_toolbar_insert_item(PyObject *self, PyObject *args) {
  PyGtk_Object *t, *icon;
  char *text, *tooltip, *tip_private;
  GtkWidget *ret;
  PyObject *callback;
  int pos;
  if (!PyArg_ParseTuple(args, "O!zzzO!Oi|gtk_toolbar_insert_item",
			&PyGtk_Type, &t, &text, &tooltip, &tip_private,
			&PyGtk_Type, &icon, &callback, &pos))
    return NULL;
  if (!PyCallable_Check(callback) && callback != Py_None) {
    PyErr_SetString(PyExc_TypeError,"sixth argument not callable");
    return NULL;
  }
  Py_INCREF(callback);
  ret = gtk_toolbar_insert_item(GTK_TOOLBAR(PyGtk_Get(t)), text, tooltip,
				tip_private, GTK_WIDGET(PyGtk_Get(icon)),
				NULL, NULL, pos);
  if (callback != Py_None) {
    gtk_signal_connect_full(GTK_OBJECT(ret), "clicked", NULL,
			    PyGtk_CallbackMarshal, callback,
			    PyGtk_DestroyNotify, FALSE, FALSE);
  }
  return PyGtk_New((GtkObject *)ret);
}

static PyObject *_wrap_gtk_drag_dest_set(PyObject *self, PyObject *args) {
  PyObject *widget, *py_flags, *py_actions, *py_list;
  GtkDestDefaults flags;
  GdkDragAction actions;
  GtkTargetEntry *targets;
  gint n_targets, i;

  if (!PyArg_ParseTuple(args, "O!OO!O:gtk_drag_dest_set", &PyGtk_Type, &widget,
			&py_flags, &PyList_Type, &py_list, &py_actions))
    return NULL;
  if (PyGtkFlag_get_value(GTK_TYPE_DEST_DEFAULTS, py_flags, (gint *)&flags))
    return NULL;
  if (PyGtkFlag_get_value(GTK_TYPE_GDK_DRAG_ACTION,py_actions,(gint*)&actions))
    return NULL;
  n_targets = PyList_Size(py_list);
  targets = g_new(GtkTargetEntry, n_targets);
  for (i = 0; i < n_targets; i++) {
    PyObject *item = PyList_GetItem(py_list, i);
    if (!PyArg_ParseTuple(item, "zii", &(targets[i].target),
			  &(targets[i].flags), &(targets[i].info))) {
      PyErr_Clear();
      PyErr_SetString(PyExc_TypeError,"list items should be (string,int,int)");
      g_free(targets);
      return NULL;
    }
  }
  gtk_drag_dest_set(GTK_WIDGET(PyGtk_Get(widget)), flags, targets, n_targets,
		    actions);
  g_free(targets);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_drag_source_set(PyObject *self, PyObject *args) {
  PyObject *widget, *py_bmask, *py_list, *py_actions;
  GdkModifierType bmask;
  GtkTargetEntry *targets;
  gint n_targets, i;
  GdkDragAction actions;

  if (!PyArg_ParseTuple(args, "O!OO!O:gtk_drag_source_set", &PyGtk_Type,
			&widget, &py_bmask, &PyList_Type,&py_list,&py_actions))
    return NULL;
  if (PyGtkFlag_get_value(GTK_TYPE_GDK_MODIFIER_TYPE, py_bmask, (gint*)&bmask))
    return NULL;
  if (PyGtkFlag_get_value(GTK_TYPE_GDK_DRAG_ACTION,py_actions,(gint*)&actions))
    return NULL;
  n_targets = PyList_Size(py_list);
  targets = g_new(GtkTargetEntry, n_targets);
  for (i = 0; i < n_targets; i++) {
    PyObject *item = PyList_GetItem(py_list, i);
    if (!PyArg_ParseTuple(item, "zii", &(targets[i].target),
			  &(targets[i].flags), &(targets[i].info))) {
      PyErr_Clear();
      PyErr_SetString(PyExc_TypeError,"list items should be (string,int,int)");
      g_free(targets);
      return NULL;
    }
  }
  gtk_drag_source_set(GTK_WIDGET(PyGtk_Get(widget)), bmask, targets, n_targets,
		      actions);
  g_free(targets);
  Py_INCREF(Py_None);
  return Py_None;
}

PyObject *_wrap_gtk_drag_begin(PyObject *self, PyObject *args) {
  PyObject *widget, *py_list, *py_actions, *event;
  GdkDragAction actions;
  gint button, n_targets, i;
  GtkTargetEntry *targets;
  GtkTargetList *list;
  GdkDragContext *context;

  if (!PyArg_ParseTuple(args, "O!O!OiO!:gtk_drag_begin", &PyGtk_Type, &widget,
			&PyList_Type, &py_list, &py_actions, &button,
			&PyGdkEvent_Type, &event))
    return NULL;
  if (PyGtkFlag_get_value(GTK_TYPE_GDK_DRAG_ACTION,py_actions,(gint*)&actions))
    return NULL;
  n_targets = PyList_Size(py_list);
  targets = g_new(GtkTargetEntry, n_targets);
  for (i = 0; i < n_targets; i++) {
    PyObject *item = PyList_GetItem(py_list, i);
    if (!PyArg_ParseTuple(item, "zii", &(targets[i].target),
			  &(targets[i].flags), &(targets[i].info))) {
      PyErr_Clear();
      PyErr_SetString(PyExc_TypeError,"list items should be (string,int,int)");
      g_free(targets);
      return NULL;
    }
  }
  list = gtk_target_list_new(targets, n_targets);
  g_free(targets);
  context = gtk_drag_begin(GTK_WIDGET(PyGtk_Get(widget)), list, actions,
			   button, PyGdkEvent_Get(event));
  gtk_target_list_unref(list);
  return PyGdkDragContext_New(context);
}

#include "gtkmodule_impl.c"

static PyObject *_wrap_gdk_pixmap_new(PyObject *self, PyObject *args) {
  GdkPixmap *pix;
  PyObject *win, *ret;
  int w, h, d;
  if (!PyArg_ParseTuple(args, "O!iii:gdk_pixmap_new", &PyGdkWindow_Type, &win,
		       &w, &h, &d))
    return NULL;
  pix = gdk_pixmap_new(PyGdkWindow_Get(win), w, h, d);
  ret = PyGdkWindow_New(pix);
  gdk_pixmap_unref(pix);
  return ret;
}
static PyObject *_wrap_gdk_pixmap_create_from_xpm(PyObject *self, PyObject *args) {
  GdkPixmap *pix;
  GdkBitmap *mask;
  PyObject *parent_win, *colour, *ret;
  GdkColor *col;
  gchar *fname;

  if (!PyArg_ParseTuple(args, "O!Os:gdk_pixmap_create_from_xpm",
			&PyGdkWindow_Type, &parent_win, &colour, &fname))
    return NULL;
  if (colour == Py_None)             col = NULL;
  else if (PyGdkColor_Check(colour)) col = PyGdkColor_Get(colour);
  else {
    PyErr_SetString(PyExc_TypeError,
		    "second argument must be a colour or None");
    return NULL;
  }
  pix = gdk_pixmap_create_from_xpm(PyGdkWindow_Get(parent_win), &mask, col,
				   fname);
  if (pix == NULL) {
    PyErr_SetString(PyExc_IOError, "can't load pixmap");
    return NULL;
  }
  ret =  Py_BuildValue("(OO)", PyGdkWindow_New(pix), PyGdkWindow_New(mask));
  gdk_pixmap_unref(pix);
  gdk_bitmap_unref(mask);
  return ret;
}

static PyObject *_wrap_gdk_pixmap_create_from_xpm_d(PyObject *self, PyObject *args) {
  GdkPixmap *pix;
  GdkBitmap *mask;
  PyObject *parent_win, *colour, *ret, *py_lines;
  GdkColor *col;
  int len, i;
  char **data;

  if (!PyArg_ParseTuple(args, "O!OO!:gdk_pixmap_create_from_xpm_d",
			&PyGdkWindow_Type, &parent_win, &colour,
			&PyList_Type, &py_lines))
    return NULL;
  if (colour == Py_None)             col = NULL;
  else if (PyGdkColor_Check(colour)) col = PyGdkColor_Get(colour);
  else {
    PyErr_SetString(PyExc_TypeError,
		    "second argument must be a colour or None");
    return NULL;
  }
  len = PyList_Size(py_lines);
  data = g_new(char *, len);
  for (i = 0; i < len; i++) {
    PyObject *item = PyList_GetItem(py_lines, i);
    if (!PyString_Check(item)) {
      PyErr_SetString(PyExc_TypeError, "list items must be strings");
      g_free(data);
      return NULL;
    }
    data[i] = PyString_AsString(item);
  }
  pix = gdk_pixmap_create_from_xpm_d(PyGdkWindow_Get(parent_win), &mask, col,
				     data);
  g_free(data);
  if (pix == NULL) {
    PyErr_SetString(PyExc_IOError, "can't load pixmap");
    return NULL;
  }
  ret =  Py_BuildValue("(OO)", PyGdkWindow_New(pix), PyGdkWindow_New(mask));
  gdk_pixmap_unref(pix);
  gdk_bitmap_unref(mask);
  return ret;
}

static PyObject *_wrap_gdk_draw_polygon(PyObject *self, PyObject *args) {
  PyObject *win, *gc, *seq, *item;
  gint filled, npoints, i;
  GdkPoint *points;

  if (!PyArg_ParseTuple(args, "O!O!iO:gdk_draw_polygon", &PyGdkWindow_Type,
			&win, &PyGdkGC_Type, &gc, &filled, &seq))
    return NULL;
  if (!PySequence_Check(seq)) {
    PyErr_SetString(PyExc_TypeError, "forth argument not a sequence");
    return NULL;
  }
  npoints = PySequence_Length(seq);
  points = g_new(GdkPoint, npoints);
  for (i = 0; i < npoints; i++) {
    item = PySequence_GetItem(seq, i);
    if (!PyArg_ParseTuple(item, "hh", &(points[i].x), &(points[i].y))) {
      PyErr_Clear();
      PyErr_SetString(PyExc_TypeError, "sequence member not a 2-tuple");
      g_free(points);
      return NULL;
    }
  }
  gdk_draw_polygon(PyGdkWindow_Get(win),PyGdkGC_Get(gc),filled,points,npoints);
  g_free(points);
  Py_INCREF(Py_None);
  return Py_None;
}
static PyObject *_wrap_gdk_draw_text(PyObject *self, PyObject *args) {
  PyObject *win, *font, *gc;
  int x, y, len;
  char *str;
  if (!PyArg_ParseTuple(args, "O!O!O!iis#:gdk_draw_text", &PyGdkWindow_Type,
			&win, &PyGdkFont_Type, &font, &PyGdkGC_Type, &gc,
			&x, &y, &str, &len))
    return NULL;
  gdk_draw_text(PyGdkWindow_Get(win), PyGdkFont_Get(font), PyGdkGC_Get(gc),
		x, y, str, len);
  Py_INCREF(Py_None);
  return Py_None;
}
static PyObject *_wrap_gdk_draw_points(PyObject *self, PyObject *args) {
  PyObject *win, *gc, *seq, *item;
  gint npoints, i;
  GdkPoint *points;

  if (!PyArg_ParseTuple(args, "O!O!O:gdk_draw_points", &PyGdkWindow_Type,
			&win, &PyGdkGC_Type, &gc, &seq))
    return NULL;
  if (!PySequence_Check(seq)) {
    PyErr_SetString(PyExc_TypeError, "third argument not a sequence");
    return NULL;
  }
  npoints = PySequence_Length(seq);
  points = g_new(GdkPoint, npoints);
  for (i = 0; i < npoints; i++) {
    item = PySequence_GetItem(seq, i);
    if (!PyArg_ParseTuple(item, "hh", &(points[i].x), &(points[i].y))) {
      PyErr_Clear();
      PyErr_SetString(PyExc_TypeError, "sequence member not a 2-tuple");
      g_free(points);
      return NULL;
    }
  }
  gdk_draw_points(PyGdkWindow_Get(win), PyGdkGC_Get(gc), points, npoints);
  g_free(points);
  Py_INCREF(Py_None);
  return Py_None;
}
static PyObject *_wrap_gdk_draw_segments(PyObject *self, PyObject *args) {
  PyObject *win, *gc, *seq, *item;
  gint nsegs, i;
  GdkSegment *segs;

  if (!PyArg_ParseTuple(args, "O!O!O:gdk_draw_segments", &PyGdkWindow_Type,
			&win, &PyGdkGC_Type, &gc, &seq))
    return NULL;
  if (!PySequence_Check(seq)) {
    PyErr_SetString(PyExc_TypeError, "third argument not a sequence");
    return NULL;
  }
  nsegs = PySequence_Length(seq);
  segs = g_new(GdkSegment, nsegs);
  for (i = 0; i < nsegs; i++) {
    item = PySequence_GetItem(seq, i);
    if (!PyArg_ParseTuple(item, "hhhh", &(segs[i].x1), &(segs[i].y1),
			  &(segs[i].x2), &(segs[i].y2))) {
      PyErr_Clear();
      PyErr_SetString(PyExc_TypeError, "sequence member not a 4-tuple");
      g_free(segs);
      return NULL;
    }
  }
  gdk_draw_segments(PyGdkWindow_Get(win), PyGdkGC_Get(gc), segs, nsegs);
  g_free(segs);
  Py_INCREF(Py_None);
  return Py_None;
}
static PyObject *_wrap_gdk_draw_lines(PyObject *self, PyObject *args) {
  PyObject *win, *gc, *seq, *item;
  gint npoints, i;
  GdkPoint *points;

  if (!PyArg_ParseTuple(args, "O!O!O:gdk_draw_lines", &PyGdkWindow_Type,
			&win, &PyGdkGC_Type, &gc, &seq))
    return NULL;
  if (!PySequence_Check(seq)) {
    PyErr_SetString(PyExc_TypeError, "third argument not a sequence");
    return NULL;
  }
  npoints = PySequence_Length(seq);
  points = g_new(GdkPoint, npoints);
  for (i = 0; i < npoints; i++) {
    item = PySequence_GetItem(seq, i);
    if (!PyArg_ParseTuple(item, "hh", &(points[i].x), &(points[i].y))) {
      PyErr_Clear();
      PyErr_SetString(PyExc_TypeError, "sequence member not a 2-tuple");
      g_free(points);
      return NULL;
    }
  }
  gdk_draw_lines(PyGdkWindow_Get(win), PyGdkGC_Get(gc), points, npoints);
  g_free(points);
  Py_INCREF(Py_None);
  return Py_None;
}
/* gdk_color_alloc analog */
static PyObject *_wrap_gdk_color_alloc(PyObject *self, PyObject *args) {
    GdkColor gdk_color;
    GdkColormap *colormap;
    PyGtkStyle_Object *style;
    PyGtk_Object *obj;
    if (PyArg_ParseTuple(args, "O!iii:gdk_color_alloc", &PyGtkStyle_Type,
			 &style, &(gdk_color.red), &(gdk_color.green),
			 &(gdk_color.blue)))
        colormap = PyGtkStyle_Get(style)->colormap;
    else {
        PyErr_Clear();
	if (!PyArg_ParseTuple(args, "O!iii:gdk_color_alloc", &PyGtk_Type,
			      &obj, &(gdk_color.red), &(gdk_color.green),
			      &(gdk_color.blue)))
	    return NULL;
	if (GTK_WIDGET_NO_WINDOW(PyGtk_Get(obj))) {
	    PyErr_SetString(PyExc_TypeError, "widget has no window");
	    return NULL;
	}
	colormap = gdk_window_get_colormap(GTK_WIDGET(PyGtk_Get(obj))->window);
    }
    gdk_color_alloc(colormap, &gdk_color);
    return PyGdkColor_New(&gdk_color);
}

static PyObject *_wrap_gtk_label_get(PyObject *self, PyObject *args) {
    PyObject *label;
    char *text;

    if (!PyArg_ParseTuple(args, "O!:gtk_label_get", &PyGtk_Type, &label))
        return NULL;
    gtk_label_get(GTK_LABEL(PyGtk_Get(label)), &text);
    return PyString_FromString(text);
}

static PyObject *_wrap_gtk_color_selection_get_color(PyObject *self, PyObject *args) {
    PyObject *colorsel;
    double value[4];

    if (!PyArg_ParseTuple(args, "O!:gtk_color_selection_get_color", &PyGtk_Type, &colorsel))
        return NULL;
    gtk_color_selection_get_color(GTK_COLOR_SELECTION(PyGtk_Get(colorsel)),
				  value);
    if (GTK_COLOR_SELECTION(PyGtk_Get(colorsel))->use_opacity)
        return Py_BuildValue("(dddd)", value[0],value[1],value[2],value[3]);
    else
        return Py_BuildValue("(dddd)", value[0], value[1], value[2]);
}
    
static PyObject *_wrap_gtk_color_selection_set_color(PyObject *self, PyObject *args) {
    PyObject *colorsel;
    double value[4];

    value[3] = 1.0;
    if (!PyArg_ParseTuple(args, "O!(ddd):gtk_color_selection_set_color",
			  &PyGtk_Type, &colorsel, &value[0], &value[1],
			  &value[2])) {
        PyErr_Clear();
        if (!PyArg_ParseTuple(args, "O!(dddd):gtk_color_selection_set_color",
			      &PyGtk_Type, &colorsel, &value[0], &value[1],
			      &value[2], &value[3]))
	    return NULL;
    }
    gtk_color_selection_set_color(GTK_COLOR_SELECTION(PyGtk_Get(colorsel)),
				  value);
    Py_INCREF(Py_None);
    return Py_None;
}
    
static GList *GList_FromPyList(PyObject *list) {
    GList *ret = NULL;
    PyObject *item;
    int i, len;

    len = PyList_Size(list);
    for (i = 0; i < len; i++) {
        item = PyList_GetItem(list, i);
        if (!PyGtk_Check(item)) {
	    PyErr_SetString(PyExc_TypeError, "list item not a GtkObject");
	    g_list_free(ret);
	    return NULL;
	}
	ret = g_list_append(ret, PyGtk_Get(item));
    }
    return ret;
}

static PyObject *_wrap_gtk_list_insert_items(PyObject *self, PyObject *args) {
    PyObject *list, *py_items;
    GList *items = NULL;
    int pos;

    if (!PyArg_ParseTuple(args, "O!O!i:gtk_list_insert_items", &PyGtk_Type,
			  &list, &PyList_Type, &py_items, &pos))
        return NULL;
    if (PyList_Size(py_items) && (items = GList_FromPyList(py_items)) == NULL)
      return NULL;
    gtk_list_insert_items(GTK_LIST(PyGtk_Get(list)), items, pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_list_append_items(PyObject *self, PyObject *args) {
    PyObject *list, *py_items;
    GList *items = NULL;

    if (!PyArg_ParseTuple(args, "O!O!:gtk_list_append_items", &PyGtk_Type,
			  &list, &PyList_Type, &py_items))
        return NULL;
    if (PyList_Size(py_items) && (items = GList_FromPyList(py_items)) == NULL)
      return NULL;
    gtk_list_append_items(GTK_LIST(PyGtk_Get(list)), items);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_list_prepend_items(PyObject *self, PyObject *args) {
    PyObject *list, *py_items;
    GList *items = NULL;

    if (!PyArg_ParseTuple(args, "O!O!:gtk_list_prepend_items", &PyGtk_Type,
			  &list, &PyList_Type, &py_items))
        return NULL;
    if (PyList_Size(py_items) && (items = GList_FromPyList(py_items)) == NULL)
      return NULL;
    gtk_list_prepend_items(GTK_LIST(PyGtk_Get(list)), items);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_list_remove_items(PyObject *self, PyObject *args) {
    PyObject *list, *py_items;
    GList *items = NULL;

    if (!PyArg_ParseTuple(args, "O!O!:gtk_list_remove_items", &PyGtk_Type,
			  &list, &PyList_Type, &py_items))
        return NULL;
    if (PyList_Size(py_items) && (items = GList_FromPyList(py_items)) == NULL)
      return NULL;
    gtk_list_remove_items(GTK_LIST(PyGtk_Get(list)), items);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_list_get_selection(PyObject *self, PyObject *args) {
    PyObject *list, *ret;
    GList *tmp;

    if (!PyArg_ParseTuple(args, "O!:gtk_list_get_selection",&PyGtk_Type,&list))
        return NULL;
    tmp = GTK_LIST(PyGtk_Get(list))->selection;
    ret = PyList_New(0);
    for (; tmp; tmp = tmp->next)
        PyList_Append(ret, PyGtk_New(tmp->data));
    return ret;
}

static PyObject *_wrap_gtk_tree_remove_items(PyObject *self, PyObject *args) {
    PyObject *tree, *py_items;
    GList *items = NULL;

    if (!PyArg_ParseTuple(args, "O!O!:gtk_tree_remove_items", &PyGtk_Type,
			  &tree, &PyList_Type, &py_items))
        return NULL;
    if (PyList_Size(py_items) && (items = GList_FromPyList(py_items)) == NULL)
      return NULL;
    gtk_tree_remove_items(GTK_TREE(PyGtk_Get(tree)), items);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_tree_get_selection(PyObject *self, PyObject *args) {
    PyObject *tree, *ret;
    GList *tmp;

    if (!PyArg_ParseTuple(args, "O!:gtk_tree_get_selection",&PyGtk_Type,&tree))
        return NULL;
    tmp = GTK_TREE(PyGtk_Get(tree))->selection;
    ret = PyList_New(0);
    for (; tmp; tmp = tmp->next)
        PyList_Append(ret, PyGtk_New(tmp->data));
    return ret;
}

static PyObject *_wrap_gtk_spin_button_new_no_adj(PyObject *self, PyObject *args) {
    double climb_rate;
    int digits;

    if (!PyArg_ParseTuple(args, "di:gtk_spin_button_new_no_adj",
			  &climb_rate, &digits))
        return NULL;
    return PyGtk_New((GtkObject *)gtk_spin_button_new(NULL,climb_rate,digits));
}

static PyObject *_wrap_gtk_calendar_get_date(PyObject *self, PyObject *args) {
  PyObject *cal;
  guint year, month, day;

  if (!PyArg_ParseTuple(args, "O!:gtk_calendar_get_date", &PyGtk_Type, &cal))
    return NULL;
  gtk_calendar_get_date(GTK_CALENDAR(PyGtk_Get(cal)), &year, &month, &day);
  return Py_BuildValue("(iii)", year, month, day);
}

static PyObject *_wrap_gtk_notebook_query_tab_label_packing(PyObject *self, PyObject *args) {
  PyObject *notebook, *child;
  gboolean expand, fill;
  GtkPackType pack_type;

  if (!PyArg_ParseTuple(args, "O!O!:gtk_notebook_query_tab_label_packing",
			&PyGtk_Type, &notebook, &PyGtk_Type, &child))
    return NULL;
  gtk_notebook_query_tab_label_packing(GTK_NOTEBOOK(PyGtk_Get(notebook)),
				       GTK_WIDGET(PyGtk_Get(child)),
				       &expand, &fill, &pack_type);
  return Py_BuildValue("(iii)", (int)expand, (int)fill, pack_type);
}

static PyObject *_wrap_gtk_ctree_new_with_titles(PyObject *self, PyObject *args) {
  int c, tree_col, i;
  PyObject *l, *item;
  char **list;
  if (!PyArg_ParseTuple(args, "iiO:gtk_ctree_new_with_titles",
			&c, &tree_col, &l))
    return NULL;
  if (!PySequence_Check(l)) {
    PyErr_SetString(PyExc_TypeError,"3rd argument not a sequence");
    return NULL;
  }
  if (PySequence_Length(l) < c) {
    PyErr_SetString(PyExc_TypeError, "sequence not long enough");
    return NULL;
  }
  list = malloc(sizeof(char *)*c);
  for (i = 0; i < c; i++) {
    item = PySequence_GetItem(l, i);
    if (!PyString_Check(item)) {
      PyErr_SetString(PyExc_TypeError,
		      "sequence item not a string");
      free(list);
      return NULL;
    }
    list[i] = PyString_AsString(item);
  }
  item = (PyObject *) PyGtk_New((GtkObject *)gtk_ctree_new_with_titles(
						c, tree_col, list));
  free(list);
  return item;
}

static PyObject *_wrap_gtk_ctree_get_selection(PyObject *self, PyObject *args) {
  GList *selection;
  GtkCTreeNode *node;
  PyObject *clist, *ret;
  if (!PyArg_ParseTuple(args, "O!:gtk_ctree_get_selection", &PyGtk_Type,
			&clist))
    return NULL;
  ret = PyList_New(0);
  for (selection = GTK_CLIST(PyGtk_Get(clist))->selection; selection != NULL;
       selection = selection->next) {
    node = selection->data;
    PyList_Append(ret, PyGtkCTreeNode_New(node));
  }
  return ret;
}

static PyObject *_wrap_gtk_ctree_insert_node(PyObject *self, PyObject *args) {
  PyObject *ctree, *py_parent, *py_sibling, *py_text;
  PyObject *py_pixmap_closed, *py_mask_closed;
  PyObject *py_pixmap_opened, *py_mask_opened;
  GtkCTreeNode *parent = NULL, *sibling = NULL, *ret;
  gchar **text = NULL;
  GdkPixmap *pixmap_closed = NULL, *pixmap_opened = NULL;
  GdkBitmap *mask_closed = NULL, *mask_opened = NULL;
  gint spacing, is_leaf, expanded, col, i;

  /* just about all the arguments can be substituted with None */
  if (!PyArg_ParseTuple(args, "O!OOOiOOOOii:gtk_ctree_insert_node",
			&PyGtk_Type, &ctree, &py_parent, &py_sibling, &py_text,
			&spacing, &py_pixmap_closed, &py_mask_closed,
			&py_pixmap_opened, &py_mask_opened, &is_leaf,
			&expanded))
    return NULL;
  if (PyGtkCTreeNode_Check(py_parent))
    parent = PyGtkCTreeNode_Get(py_parent);
  else if (py_parent != Py_None) {
    PyErr_SetString(PyExc_TypeError, "2nd arg must be a CTreeNode or None");
    return NULL;
  }
  if (PyGtkCTreeNode_Check(py_sibling))
    sibling = PyGtkCTreeNode_Get(py_sibling);
  else if (py_sibling != Py_None) {
    PyErr_SetString(PyExc_TypeError, "3rd arg must be a CTreeNode or None");
    return NULL;
  }
  if (PyGdkWindow_Check(py_pixmap_closed))
    pixmap_closed = PyGdkWindow_Get(py_pixmap_closed);
  else if (py_pixmap_closed != Py_None) {
    PyErr_SetString(PyExc_TypeError, "6th arg must be a GdkWindow or None");
    return NULL;
  }
  if (PyGdkWindow_Check(py_mask_closed))
    mask_closed = PyGdkWindow_Get(py_mask_closed);
  else if (py_mask_closed != Py_None) {
    PyErr_SetString(PyExc_TypeError, "7th arg must be a GdkWindow or None");
    return NULL;
  }
  if (PyGdkWindow_Check(py_pixmap_opened))
    pixmap_opened = PyGdkWindow_Get(py_pixmap_opened);
  else if (py_pixmap_opened != Py_None) {
    PyErr_SetString(PyExc_TypeError, "8th arg must be a GdkWindow or None");
    return NULL;
  }
  if (PyGdkWindow_Check(py_mask_opened))
    mask_opened = PyGdkWindow_Get(py_mask_opened);
  else if (py_mask_opened != Py_None) {
    PyErr_SetString(PyExc_TypeError, "9th arg must be a GdkWindow or None");
    return NULL;
  }
  if (!PySequence_Check(py_text)) {
    PyErr_SetString(PyExc_TypeError, "4th arg must be a sequence");
    return NULL;
  }
  col = GTK_CLIST(PyGtk_Get(ctree))->columns;
  if (PySequence_Length(py_text) < col) {
    PyErr_SetString(PyExc_TypeError, "sequence too short");
    return NULL;
  }
  text = g_new(gchar *, col);
  for (i = 0; i < col; i++) {
    PyObject *item = PySequence_GetItem(py_text, i);
    if (!PyString_Check(item)) {
      PyErr_SetString(PyExc_TypeError, "sequence item not a string");
      g_free(text);
      return NULL;
    }
    text[i] = PyString_AsString(item);
  }
  ret = gtk_ctree_insert_node(GTK_CTREE(PyGtk_Get(ctree)), parent, sibling,
			      text, spacing, pixmap_closed, mask_closed,
			      pixmap_opened, mask_opened, is_leaf, expanded);
  g_free(text);
  return PyGtkCTreeNode_New(ret);
}

static PyObject *_wrap_gtk_ctree_find_by_row_data(PyObject *self, PyObject *args) {
  PyObject *ctree, *py_node, *data;
  GtkCTreeNode *node = NULL, *ret;
  
  if (!PyArg_ParseTuple(args, "O!OO:gtk_ctree_find_by_row_data", &PyGtk_Type,
			&ctree, &py_node, &data))
    return NULL;
  if (PyGtkCTreeNode_Check(py_node))
    node = PyGtkCTreeNode_Get(py_node);
  else if (py_node != Py_None) {
    PyErr_SetString(PyExc_TypeError, "2nd arg must be a GTreeNode or None");
    return NULL;
  }
  ret = gtk_ctree_find_by_row_data(GTK_CTREE(PyGtk_Get(ctree)), node, data);
  if (ret)
    return PyGtkCTreeNode_New(ret);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_ctree_find_all_by_row_data(PyObject *self, PyObject *args) {
  PyObject *ctree, *py_node, *data, *list;
  GtkCTreeNode *node = NULL;
  GList *ret, *tmp;
  
  if (!PyArg_ParseTuple(args, "O!OO:gtk_ctree_find_all_by_row_data",
			&PyGtk_Type, &ctree, &py_node, &data))
    return NULL;
  if (PyGtkCTreeNode_Check(py_node))
    node = PyGtkCTreeNode_Get(py_node);
  else if (py_node != Py_None) {
    PyErr_SetString(PyExc_TypeError, "2nd arg must be a GTreeNode or None");
    return NULL;
  }
  ret = gtk_ctree_find_all_by_row_data(GTK_CTREE(PyGtk_Get(ctree)), node,data);
  list = PyList_New(0);
  for (tmp = ret; tmp; tmp = tmp->next)
    PyList_Append(list, PyGtkCTreeNode_New(ret->data));
  g_list_free(ret);
  return list;
}

static PyObject *_wrap_gtk_ctree_move(PyObject *self, PyObject *args) {
  PyObject *ctree, *node, *py_parent, *py_sibling;
  GtkCTreeNode *parent, *sibling;

  if (!PyArg_ParseTuple(args, "O!O!OO:gtk_ctree_move", &PyGtk_Type, &ctree,
			&PyGtkCTreeNode_Type, &node, &py_parent, &py_sibling))
    return NULL;
  if (PyGtkCTreeNode_Check(py_parent))
    parent = PyGtkCTreeNode_Get(py_parent);
  else if (py_parent != Py_None) {
    PyErr_SetString(PyExc_TypeError, "3rd arg must be a CTreeNode or None");
    return NULL;
  }
  if (PyGtkCTreeNode_Check(py_sibling))
    sibling = PyGtkCTreeNode_Get(py_sibling);
  else if (py_sibling != Py_None) {
    PyErr_SetString(PyExc_TypeError, "4th arg must be a CTreeNode or None");
    return NULL;
  }
  gtk_ctree_move(GTK_CTREE(PyGtk_Get(ctree)), PyGtkCTreeNode_Get(node),
		 parent, sibling);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_ctree_node_get_text(PyObject *self, PyObject *args) {
  PyObject *ctree, *node;
  int col;
  char *text;

  if (!PyArg_ParseTuple(args, "O!O!i:gtk_ctree_node_get_text", &PyGtk_Type,
			&ctree, &PyGtkCTreeNode_Type, &node, &col))
    return NULL;
  if (!gtk_ctree_node_get_text(GTK_CTREE(PyGtk_Get(ctree)),
			       PyGtkCTreeNode_Get(node), col, &text)) {
    PyErr_SetString(PyExc_ValueError, "can't get text value");
    return NULL;
  }
  return PyString_FromString(text);
}

static PyObject *_wrap_gtk_ctree_node_get_pixmap(PyObject *self, PyObject *args) {
  PyObject *ctree, *node, *mask;
  int col;
  GdkPixmap *p;
  GdkBitmap *m;

  if (!PyArg_ParseTuple(args, "O!O!i:gtk_ctree_node_get_pixmap", &PyGtk_Type,
			&ctree, &PyGtkCTreeNode_Type, &node, &col))
    return NULL;
  if (!gtk_ctree_node_get_pixmap(GTK_CTREE(PyGtk_Get(ctree)), 
				 PyGtkCTreeNode_Get(node), col, &p, &m)) {
    PyErr_SetString(PyExc_ValueError, "can't get pixmap value");
    return NULL;
  }
  if (m)
    mask = PyGdkWindow_New(m);
  else {
    Py_INCREF(Py_None);
    mask = Py_None;
  }
  return Py_BuildValue("(OO)", PyGdkWindow_New(p), PyGdkWindow_New(m));
}

static PyObject *_wrap_gtk_ctree_node_get_pixtext(PyObject *self, PyObject *args) {
  PyObject *ctree, *node, *mask;
  int col;
  guint8 spacing;
  char *text;
  GdkPixmap *p;
  GdkBitmap *m;

  if (!PyArg_ParseTuple(args, "O!O!i:gtk_ctree_node_get_pixtext", &PyGtk_Type,
			&ctree, &PyGtkCTreeNode_Type, &node, &col))
    return NULL;
  if (!gtk_ctree_node_get_pixtext(GTK_CTREE(PyGtk_Get(ctree)),
				  PyGtkCTreeNode_Get(node), col,
				  &text, &spacing, &p, &m)) {
    PyErr_SetString(PyExc_ValueError, "can't get pixtext value");
    return NULL;
  }
  if (m)
    mask = PyGdkWindow_New(m);
  else {
    Py_INCREF(Py_None);
    mask = Py_None;
  }
  return Py_BuildValue("(siOO)", text, (int)spacing,
		       PyGdkWindow_New(p), mask);
}

static PyObject *_wrap_gtk_ctree_get_node_info(PyObject *self, PyObject *args) {
  PyObject *ctree, *node, *p_c, *m_c, *p_o, *m_o;
  gchar *text;
  guint8 spacing;
  GdkPixmap *pixmap_closed, *pixmap_opened;
  GdkBitmap *mask_closed, *mask_opened;
  gboolean is_leaf, expanded;

  if (!PyArg_ParseTuple(args, "O!O!:gtk_ctree_get_node_info", &PyGtk_Type,
			&ctree, &PyGtkCTreeNode_Type, &node))
    return NULL;
  if (!gtk_ctree_get_node_info(GTK_CTREE(PyGtk_Get(ctree)),
			       PyGtkCTreeNode_Get(node), &text, &spacing,
			       &pixmap_closed, &mask_closed, &pixmap_opened,
			       &mask_opened, &is_leaf, &expanded)) {
    PyErr_SetString(PyExc_ValueError, "can't retrieve node info");
    return NULL;
  }
  if (pixmap_closed)
    p_c = PyGdkWindow_New(pixmap_closed);
  else {
    Py_INCREF(Py_None);
    p_c = Py_None;
  }
  if (mask_closed)
    m_c = PyGdkWindow_New(mask_closed);
  else {
    Py_INCREF(Py_None);
    m_c = Py_None;
  }
  if (pixmap_opened)
    p_o = PyGdkWindow_New(pixmap_opened);
  else {
    Py_INCREF(Py_None);
    p_o = Py_None;
  }
  if (mask_opened)
    m_o = PyGdkWindow_New(mask_opened);
  else {
    Py_INCREF(Py_None);
    m_o = Py_None;
  }
  return Py_BuildValue("(siOOOOii)", text, (int)spacing, p_c, m_c, p_o, m_o,
		       (int)is_leaf, (int)expanded);
}

static PyObject *_wrap_gtk_ctree_node_set_row_data(PyObject *self, PyObject *args) {
  PyObject *ctree, *node, *data;

  if (!PyArg_ParseTuple(args, "O!O!O:gtk_ctree_node_set_row_data", &PyGtk_Type,
			&ctree, &PyGtkCTreeNode_Type, &node, &data))
    return NULL;
  Py_INCREF(data);
  gtk_ctree_node_set_row_data_full(GTK_CTREE(PyGtk_Get(ctree)),
				   PyGtkCTreeNode_Get(node), data,
				   (GtkDestroyNotify)PyGtk_DestroyNotify);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyObject *_wrap_gtk_ctree_node_get_row_data(PyObject *self, PyObject *args) {
  PyObject *ctree, *node, *data;

  if (!PyArg_ParseTuple(args, "O!O!:gtk_ctree_node_get_row_data", &PyGtk_Type,
			&ctree, &PyGtkCTreeNode_Type, &node))
    return NULL;
  data = gtk_ctree_node_get_row_data(GTK_CTREE(PyGtk_Get(ctree)),
				     PyGtkCTreeNode_Get(node));
  if (!data) data = Py_None;
  Py_INCREF(data);
  return data;
}

static PyObject *_wrap_gtk_ctree_base_nodes(PyObject *self, PyObject *args) {
  PyObject *ctree, *ret;
  GtkCTreeNode *node;

  if (!PyArg_ParseTuple(args, "O!:gtk_ctree_base_nodes", &PyGtk_Type, &ctree))
    return NULL;
  /* the first row is always a base node */
  node = GTK_CTREE_NODE(GTK_CLIST(PyGtk_Get(ctree))->row_list);
  ret = PyList_New(0);
  while (node) {
    PyList_Append(ret, PyGtkCTreeNode_New(node));
    node = GTK_CTREE_ROW(node)->sibling;
  }
  return ret;
}

static PyMethodDef _gtkmoduleMethods[] = {
    { "gtk_signal_connect", _wrap_gtk_signal_connect, 1 },
    { "gtk_signal_connect_after", _wrap_gtk_signal_connect_after, 1 },
    { "gtk_signal_disconnect_by_data", _wrap_gtk_signal_disconnect_by_data, 1 },
    { "gtk_signal_handler_block_by_data", _wrap_gtk_signal_handler_block_by_data, 1 },
    { "gtk_signal_handler_unblock_by_data", _wrap_gtk_signal_handler_unblock_by_data, 1 },
    { "gtk_signal_emitv_by_name", _wrap_gtk_signal_emitv_by_name, 1 },
    { "gtk_init", _wrap_gtk_init, 1 },
    { "gtk_main_iteration", _wrap_gtk_main_iteration, 1 },
    { "gtk_timeout_add", _wrap_gtk_timeout_add, 1 },
    { "gtk_idle_add", _wrap_gtk_idle_add, 1 },
    { "gtk_idle_add_priority", _wrap_gtk_idle_add_priority, 1 },
    { "gtk_idle_remove_function", _wrap_gtk_idle_remove_function, 1 },
    { "gtk_quit_add", _wrap_gtk_quit_add, 1 },
    { "gtk_quit_remove_function", _wrap_gtk_quit_remove_function, 1 },
    { "gtk_input_add", _wrap_gtk_input_add, 1 },
    { "gtk_object_set", _wrap_gtk_object_set, 1 },
    { "gtk_object_new", _wrap_gtk_object_new, 1 },
    { "gtk_object_get", _wrap_gtk_object_get, 1 },
    { "gtk_object_set_data", _wrap_gtk_object_set_data, 1 },
    { "gtk_object_get_data", _wrap_gtk_object_get_data, 1 },
    { "gtk_object_remove_data", _wrap_gtk_object_remove_data, 1 },
    { "gtk_widget_get_window", _wrap_gtk_widget_get_window, 1 },
    { "gtk_widget_draw", _wrap_gtk_widget_draw, 1 },
    { "gtk_widget_size_request", _wrap_gtk_widget_size_request, 1 },
    { "gtk_widget_size_allocate", _wrap_gtk_widget_size_allocate, 1 },
    { "gtk_widget_intersect", _wrap_gtk_widget_intersect, 1 },
    { "gtk_widget_get_pointer", _wrap_gtk_widget_get_pointer, 1 },
    { "gtk_container_add", _wrap_gtk_container_add, 1 },
    { "gtk_container_child_set", _wrap_gtk_container_child_set, 1 },
    { "gtk_container_child_get", _wrap_gtk_container_child_get, 1 },
    { "gtk_container_children", _wrap_gtk_container_children, 1 },
    { "gtk_window_set_icon", _wrap_gtk_window_set_icon, 1 },
    { "gtk_window_set_icon_name", _wrap_gtk_window_set_icon_name, 1 },
    { "gtk_box_query_child_packing", _wrap_gtk_box_query_child_packing, 1 },
    { "gtk_button_box_get_child_size_default", _wrap_gtk_button_box_get_child_size_default, 1 },
    { "gtk_button_box_get_child_ipadding_default", _wrap_gtk_button_box_get_child_ipadding_default, 1 },
    { "gtk_button_box_get_child_size", _wrap_gtk_button_box_get_child_size, 1 },
    { "gtk_button_box_get_child_ipadding", _wrap_gtk_button_box_get_child_ipadding, 1 },
    { "gtk_clist_get_selection", _wrap_gtk_clist_get_selection, 1 },
    { "gtk_clist_new_with_titles", _wrap_gtk_clist_new_with_titles, 1 },
    { "gtk_clist_get_text", _wrap_gtk_clist_get_text, 1 },
    { "gtk_clist_get_pixmap", _wrap_gtk_clist_get_pixmap, 1 },
    { "gtk_clist_get_pixtext", _wrap_gtk_clist_get_pixtext, 1 },
    { "gtk_clist_prepend", _wrap_gtk_clist_prepend, 1 },
    { "gtk_clist_append", _wrap_gtk_clist_append, 1 },
    { "gtk_clist_insert", _wrap_gtk_clist_insert, 1 },
    { "gtk_clist_set_row_data", _wrap_gtk_clist_set_row_data, 1 },
    { "gtk_clist_get_row_data", _wrap_gtk_clist_get_row_data, 1 },
    { "gtk_clist_find_row_from_data", _wrap_gtk_clist_find_row_from_data, 1 },
    { "gtk_clist_get_selection_info", _wrap_gtk_clist_get_selection_info, 1 },
    { "gtk_combo_set_popdown_strings", _wrap_gtk_combo_set_popdown_strings,1 },
    { "gtk_curve_get_vector", _wrap_gtk_curve_get_vector, 1 },
    { "gtk_curve_set_vector", _wrap_gtk_curve_set_vector, 1 },
    { "gtk_editable_insert_text", _wrap_gtk_editable_insert_text, 1 },
    { "gtk_frame_new", _wrap_gtk_frame_new, 1 },
    { "gtk_item_factory_create_items", _wrap_gtk_item_factory_create_items,1 },
    { "gtk_menu_popup", _wrap_gtk_menu_popup, 1 },
    { "gtk_pixmap_new_from_xpm", _wrap_gtk_pixmap_new_from_xpm, 1 },
    { "gtk_pixmap_get", _wrap_gtk_pixmap_get, 1 },
    { "gtk_preview_draw_row", _wrap_gtk_preview_draw_row, 1 },
    { "gtk_radio_menu_item_new", _wrap_gtk_radio_menu_item_new, 1 },
    { "gtk_radio_menu_item_new_with_label", _wrap_gtk_radio_menu_item_new_with_label, 1 },
    { "gtk_radio_button_new", _wrap_gtk_radio_button_new, 1 },
    { "gtk_radio_button_new_with_label", _wrap_gtk_radio_button_new_with_label, 1 },
    { "gtk_text_insert_defaults", _wrap_gtk_text_insert_defaults, 1 },
    { "gtk_toolbar_append_item", _wrap_gtk_toolbar_append_item, 1 },
    { "gtk_toolbar_prepend_item", _wrap_gtk_toolbar_prepend_item, 1 },
    { "gtk_toolbar_insert_item", _wrap_gtk_toolbar_insert_item, 1 },
    { "gtk_label_get", _wrap_gtk_label_get, 1 },
    { "gtk_color_selection_get_color", _wrap_gtk_color_selection_get_color,1 },
    { "gtk_color_selection_set_color", _wrap_gtk_color_selection_set_color,1 },
    { "gtk_list_insert_items", _wrap_gtk_list_insert_items, 1 },
    { "gtk_list_append_items", _wrap_gtk_list_append_items, 1 },
    { "gtk_list_prepend_items", _wrap_gtk_list_prepend_items, 1 },
    { "gtk_list_remove_items", _wrap_gtk_list_remove_items, 1 },
    { "gtk_list_get_selection", _wrap_gtk_list_get_selection, 1 },
    { "gtk_tree_remove_items", _wrap_gtk_tree_remove_items, 1 },
    { "gtk_tree_get_selection", _wrap_gtk_tree_get_selection, 1 },
    { "gtk_spin_button_new_no_adj", _wrap_gtk_spin_button_new_no_adj, 1 },
    { "gtk_calendar_get_date", _wrap_gtk_calendar_get_date, 1 },
    { "gtk_notebook_query_tab_label_packing", _wrap_gtk_notebook_query_tab_label_packing, 1 },
    { "gtk_drag_dest_set", _wrap_gtk_drag_dest_set, 1 },
    { "gtk_drag_source_set", _wrap_gtk_drag_source_set, 1 },
    { "gtk_drag_begin", _wrap_gtk_drag_begin, 1 },
    { "gtk_ctree_new_with_titles", _wrap_gtk_ctree_new_with_titles, 1 },
    { "gtk_ctree_get_selection", _wrap_gtk_ctree_get_selection, 1 },
    { "gtk_ctree_insert_node", _wrap_gtk_ctree_insert_node, 1 },
    { "gtk_ctree_find_by_row_data", _wrap_gtk_ctree_find_by_row_data, 1 },
    { "gtk_ctree_find_all_by_row_data", _wrap_gtk_ctree_find_all_by_row_data, 1 },
    { "gtk_ctree_move", _wrap_gtk_ctree_move, 1 },
    { "gtk_ctree_node_get_text", _wrap_gtk_ctree_node_get_text, 1 },
    { "gtk_ctree_node_get_pixmap", _wrap_gtk_ctree_node_get_pixmap, 1 },
    { "gtk_ctree_node_get_pixtext", _wrap_gtk_ctree_node_get_pixtext, 1 },
    { "gtk_ctree_get_node_info", _wrap_gtk_ctree_get_node_info, 1 },
    { "gtk_ctree_node_set_row_data", _wrap_gtk_ctree_node_set_row_data, 1 },
    { "gtk_ctree_node_get_row_data", _wrap_gtk_ctree_node_get_row_data, 1 },
    { "gtk_ctree_base_nodes", _wrap_gtk_ctree_base_nodes, 1 },
#include "gtkmodule_defs.c"
    { "gdk_pixmap_new", _wrap_gdk_pixmap_new, 1 },
    { "gdk_pixmap_create_from_xpm", _wrap_gdk_pixmap_create_from_xpm, 1 },
    { "gdk_pixmap_create_from_xpm_d", _wrap_gdk_pixmap_create_from_xpm_d, 1 },
    { "gdk_draw_polygon", _wrap_gdk_draw_polygon, 1 },
    { "gdk_draw_text", _wrap_gdk_draw_text, 1 },
    { "gdk_draw_points", _wrap_gdk_draw_points, 1 },
    { "gdk_draw_segments", _wrap_gdk_draw_segments, 1 },
    { "gdk_draw_lines", _wrap_gdk_draw_lines, 1 },
    { "gdk_color_alloc", _wrap_gdk_color_alloc, 1 },
    { NULL, NULL }
};

void init_gtk() {
     PyObject *m, *d, *private;
     m = Py_InitModule("_gtk", _gtkmoduleMethods);
     d = PyModule_GetDict(m);

     /* initialise the boxed_funcs hash_table */
     boxed_funcs = g_hash_table_new(g_direct_hash, g_direct_equal);

     PyDict_SetItemString(d, "GtkObjectType", (PyObject *)&PyGtk_Type);
     PyDict_SetItemString(d, "GtkAccelGroupType",
                          (PyObject *)&PyGtkAccelGroup_Type);
     PyDict_SetItemString(d, "GtkStyleType", (PyObject *)&PyGtkStyle_Type);
     PyDict_SetItemString(d, "GdkFontType", (PyObject *)&PyGdkFont_Type);
     PyDict_SetItemString(d, "GdkColorType", (PyObject *)&PyGdkColor_Type);
     PyDict_SetItemString(d, "GdkEventType", (PyObject *)&PyGdkEvent_Type);
     PyDict_SetItemString(d, "GdkWindowType", (PyObject *)&PyGdkWindow_Type);
     PyDict_SetItemString(d, "GdkGCType", (PyObject *)&PyGdkGC_Type);
     PyDict_SetItemString(d, "GdkColormapType",(PyObject*)&PyGdkColormap_Type);
     PyDict_SetItemString(d, "GdkDragContextType",
			  (PyObject *)&PyGdkDragContext_Type);
     PyDict_SetItemString(d, "GtkSelectionDataType",
			  (PyObject *)&PyGtkSelectionData_Type);
     PyDict_SetItemString(d, "GdkAtomType", (PyObject *)&PyGdkAtom_Type);
     PyDict_SetItemString(d, "GdkCursorType", (PyObject *)&PyGdkCursor_Type);
     PyDict_SetItemString(d, "GtkCTreeNodeType",
			  (PyObject *)&PyGtkCTreeNode_Type);

     private = PyDict_New();
     PyDict_SetItemString(d, "_private", private); Py_DECREF(private);
     PyDict_SetItemString(private, "PyGtk_New", 
                          d=PyCObject_FromVoidPtr(PyGtk_New, NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtkAccelGroup_New",
                          d=PyCObject_FromVoidPtr(PyGtkAccelGroup_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtkStyle_New",
                          d=PyCObject_FromVoidPtr(PyGtkStyle_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkFont_New",
                          d=PyCObject_FromVoidPtr(PyGdkFont_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkColor_New",
                          d=PyCObject_FromVoidPtr(PyGdkColor_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkEvent_New",
                          d=PyCObject_FromVoidPtr(PyGdkEvent_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkWindow_New",
                          d=PyCObject_FromVoidPtr(PyGdkWindow_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkGC_New",
                          d=PyCObject_FromVoidPtr(PyGdkGC_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkColormap_New",
                          d=PyCObject_FromVoidPtr(PyGdkColormap_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkDragContext_New",
                          d=PyCObject_FromVoidPtr(PyGdkDragContext_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtkSelectionData_New",
                         d=PyCObject_FromVoidPtr(PyGtkSelectionData_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkAtom_New",
                          d=PyCObject_FromVoidPtr(PyGdkAtom_New, NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGdkCursor_New",
                          d=PyCObject_FromVoidPtr(PyGdkCursor_New, NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtkCTreeNode_New",
                         d=PyCObject_FromVoidPtr(PyGtkCTreeNode_New,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtk_DestroyNotify",
                          d=PyCObject_FromVoidPtr(PyGtk_DestroyNotify,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtk_CallbackMarshal",
                          d=PyCObject_FromVoidPtr(PyGtk_CallbackMarshal,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "GtkArgs_AsTuple",
                          d=PyCObject_FromVoidPtr(GtkArgs_AsTuple,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "GtkArgs_FromSequence",
                          d=PyCObject_FromVoidPtr(GtkArgs_FromSequence,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "GtkArg_FromPyObject",
                          d=PyCObject_FromVoidPtr(GtkArg_FromPyObject,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "GtkArg_AsPyObject",
                          d=PyCObject_FromVoidPtr(GtkArg_AsPyObject,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "GtkRet_FromPyObject",
                          d=PyCObject_FromVoidPtr(GtkRet_FromPyObject,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "GtkRet_AsPyObject",
                          d=PyCObject_FromVoidPtr(GtkRet_AsPyObject,NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtkEnum_get_value",
                          d=PyCObject_FromVoidPtr(PyGtkEnum_get_value, NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyGtkFlag_get_value",
                          d=PyCObject_FromVoidPtr(PyGtkFlag_get_value, NULL));
     Py_DECREF(d);
     PyDict_SetItemString(private, "PyDict_AsGtkArgs",
                          d=PyCObject_FromVoidPtr(PyDict_AsGtkArgs, NULL));
     Py_DECREF(d);

     PyDict_SetItemString(private, "PyGtk_RegisterBoxed",
                          d=PyCObject_FromVoidPtr(PyGtk_RegisterBoxed, NULL));
     Py_DECREF(d);

     if (PyErr_Occurred())
         Py_FatalError("can't initialise module _gtk");
}