remove GdkDevice stuff from this file.

2001-06-30  James Henstridge  <james@daa.com.au>

	* gtk/gtk-types.c: remove GdkDevice stuff from this file.

	* gtk/gtk.override: add attribute getters for some GdkDevice
	attributes, and overrides for some GdkDevice methods.
	(_wrap_gdk_event_getattr): change stuff for GdkDevices, as they
	are now GObjects.

	* gtk/gdk.defs (Device): add device boxed type here.

6 files changed, 227 insertions, 275 deletions

diff --git a/gtk/gdk.defs b/gtk/gdk.defs
index 8eca14af..e5ec4874 100644
--- a/gtk/gdk.defs
+++ b/gtk/gdk.defs
@@ -6,6 +6,20 @@
   (c-name GdkColormap)
 )
 
+(object Device
+  (in-module Gdk)
+  (parent Object (G))
+  (c-name GdkDevice)
+  (field (type-and-name gchar* name))
+  (field (type-and-name GdkInputSource source))
+  (field (type-and-name GdkInputMode mode))
+  (field (type-and-name gboolean has_cursor))
+  (field (type-and-name gint num_axes))
+  (field (type-and-name GdkDeviceAxis* axes))
+  (field (type-and-name gint num_keys))
+  (field (type-and-name GdkDeviceKey* keys))
+)
+
 (object DragContext
   (in-module Gdk)
   (parent Object (G))
@@ -1627,11 +1641,83 @@
 
 ;; From /opt/gtk2/include/gtk-2.0/gdk/gdkinput.h
 
-(function input_list_devices
-  (c-name gdk_input_list_devices)
+(function gdk_device_get_type
+  (c-name gdk_device_get_type)
+  (return-type GType)
+)
+
+(function gdk_devices_list
+  (c-name gdk_devices_list)
   (return-type GList*)
 )
 
+(method set_source
+  (of-object Device (Gdk))
+  (c-name gdk_device_set_source)
+  (return-type none)
+  (parameter (type-and-name GdkInputSource source))
+)
+
+(method set_mode
+  (of-object Device (Gdk))
+  (c-name gdk_device_set_mode)
+  (return-type gboolean)
+  (parameter (type-and-name GdkInputMode mode))
+)
+
+(method set_key
+  (of-object Device (Gdk))
+  (c-name gdk_device_set_key)
+  (return-type none)
+  (parameter (type-and-name guint index))
+  (parameter (type-and-name guint keyval))
+  (parameter (type-and-name GdkModifierType modifiers))
+)
+
+(method set_axis_use
+  (of-object Device (Gdk))
+  (c-name gdk_device_set_axis_use)
+  (return-type none)
+  (parameter (type-and-name guint index))
+  (parameter (type-and-name GdkAxisUse use))
+)
+
+(method get_state
+  (of-object Device (Gdk))
+  (c-name gdk_device_get_state)
+  (return-type none)
+  (parameter (type-and-name GdkWindow* window))
+  (parameter (type-and-name gdouble* axes))
+  (parameter (type-and-name GdkModifierType* mask))
+)
+
+(method get_history
+  (of-object Device (Gdk))
+  (c-name gdk_device_get_history)
+  (return-type gboolean)
+  (parameter (type-and-name GdkWindow* window))
+  (parameter (type-and-name guint32 start))
+  (parameter (type-and-name guint32 stop))
+  (parameter (type-and-name GdkTimeCoord*** events))
+  (parameter (type-and-name gint* n_events))
+)
+
+(function gdk_device_free_history
+  (c-name gdk_device_free_history)
+  (return-type none)
+  (parameter (type-and-name GdkTimeCoord** events))
+  (parameter (type-and-name gint n_events))
+)
+
+(method get_axis
+  (of-object Device (Gdk))
+  (c-name gdk_device_get_axis)
+  (return-type gboolean)
+  (parameter (type-and-name gdouble* axes))
+  (parameter (type-and-name GdkAxisUse use))
+  (parameter (type-and-name gdouble* value))
+)
+
 (method input_set_extension_events
   (of-object Window (Gdk))
   (c-name gdk_input_set_extension_events)
diff --git a/gtk/gtk-types.c b/gtk/gtk-types.c
index ff65eace..43140bf1 100644
--- a/gtk/gtk-types.c
+++ b/gtk/gtk-types.c
@@ -95,19 +95,6 @@ PyGtkCTreeNode_New(GtkCTreeNode *node)
     return (PyObject *)self;
 }
 
-PyObject *
-PyGdkDevice_New(GdkDevice *device)
-{
-    PyGdkDevice_Object *self;
-
-    self = (PyGdkDevice_Object *)PyObject_NEW(PyGdkDevice_Object,
-					      &PyGdkDevice_Type);
-    if (self == NULL)
-	return NULL;
-    self->obj = device;
-    return (PyObject *)self;
-}
-
 #if 0
 typedef struct {
     PyObject_HEAD
@@ -1490,245 +1477,6 @@ PyTypeObject PyGtkCTreeNode_Type = {
     NULL
 };
 
-static void
-pygdk_device_dealloc(PyGdkDevice_Object *self)
-{
-    PyMem_DEL(self);
-}
-
-static int
-pygdk_device_compare(PyGdkDevice_Object *self, PyGdkDevice_Object *v)
-{
-    if (self->obj == v->obj) return 0;
-    if (self->obj > v->obj) return -1;
-    return 1;
-}
-
-static long
-pygdk_device_hash(PyGdkDevice_Object *self)
-{
-    return (long)self->obj;
-}
-
-static PyObject *
-pygdk_device_set_source(PyGdkDevice_Object *self, PyObject *args)
-{
-    GdkInputSource source;
-
-    if (!PyArg_ParseTuple(args, "i:GdkDevice.set_source", &source))
-	return NULL;
-    gdk_device_set_source(self->obj, source);
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-static PyObject *
-pygdk_device_set_mode(PyGdkDevice_Object *self, PyObject *args)
-{
-    GdkInputMode mode;
-
-    if (!PyArg_ParseTuple(args, "i:GdkDevice.set_mode", &mode))
-	return NULL;
-    gdk_device_set_mode(self->obj, mode);
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-static PyObject *
-pygdk_device_set_key(PyGdkDevice_Object *self, PyObject *args)
-{
-    guint index, keyval;
-    GdkModifierType modifiers;
-
-    if (!PyArg_ParseTuple(args, "iii:GdkDevice.set_key", &index, &keyval,
-			  &modifiers))
-	return NULL;
-    gdk_device_set_key(self->obj, index, keyval, modifiers);
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-static PyObject *
-pygdk_device_set_axis_use(PyGdkDevice_Object *self, PyObject *args)
-{
-    guint index;
-    GdkAxisUse use;
-
-    if (!PyArg_ParseTuple(args, "ii:GdkDevice.set_axis_use", &index, &use))
-	return NULL;
-    gdk_device_set_axis_use(self->obj, index, use);
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-static PyObject *
-pygdk_device_get_state(PyGdkDevice_Object *self, PyObject *args)
-{
-    PyGObject *window;
-    gdouble *axes;
-    GdkModifierType mask;
-    PyObject *pyaxes;
-    guint i;
-    extern PyExtensionClass PyGdkWindow_Type;
-
-    if (!PyArg_ParseTuple(args, "O:GdkDevice.get_state", &window))
-	return NULL;
-    if (!pygobject_check(window, &PyGdkWindow_Type)) {
-	PyErr_SetString(PyExc_TypeError, "window should be a GdkWindow");
-	return NULL;
-    }
-    axes = g_new0(gdouble, self->obj->num_axes);
-    gdk_device_get_state(self->obj, GDK_WINDOW(window->obj), axes, &mask);
-    pyaxes = PyTuple_New(self->obj->num_axes);
-    for (i = 0; i < self->obj->num_axes; i++)
-	PyTuple_SetItem(pyaxes, i, PyFloat_FromDouble(axes[i]));
-    g_free(axes);
-    return Py_BuildValue("(Ni)", pyaxes, mask);
-}
-
-static PyObject *
-pygdk_device_get_history(PyGdkDevice_Object *self, PyObject *args)
-{
-    PyGObject *window;
-    guint start, stop;
-    GdkTimeCoord **events;
-    gint n_events;
-    PyObject *pyevents;
-    guint i;
-    extern PyExtensionClass PyGdkWindow_Type;
-
-    if (!PyArg_ParseTuple(args, "Oii:GdkDevice.get_history", &window,
-			  &start, &stop))
-	return NULL;
-    if (!pygobject_check(window, &PyGdkWindow_Type)) {
-	PyErr_SetString(PyExc_TypeError, "window should be a GdkWindow");
-	return NULL;
-    }
-    gdk_device_get_history(self->obj, GDK_WINDOW(window->obj), start, stop,
-			   &events, &n_events);
-    pyevents = PyTuple_New(n_events);
-    for (i = 0; i < n_events; i++) {
-	PyObject *axes;
-	gint j;
-
-	axes = PyTuple_New(self->obj->num_axes);
-	for (j = 0; j < self->obj->num_axes; j++)
-	    PyTuple_SetItem(axes, j, PyFloat_FromDouble(events[i]->axes[j]));
-	PyTuple_SetItem(pyevents, i, Py_BuildValue("(iN)", events[i]->time,
-						 axes));
-    }
-    gdk_device_free_history(events, n_events);
-    return pyevents;
-}
-
-static PyObject *
-pygdk_device_get_axis(PyGdkDevice_Object *self, PyObject *args)
-{
-    PyObject *pyaxes;
-    gdouble *axes, value;
-    GdkAxisUse use;
-    gboolean ret;
-    gint i;
-
-    if (!PyArg_ParseTuple(args, "Oi:GdkDevice.get_axis", &pyaxes, &use))
-	return NULL;
-    if (!PySequence_Check(pyaxes)) {
-	PyErr_SetString(PyExc_TypeError, "axes must be a sequence");
-	return NULL;
-    }
-    if (PySequence_Length(pyaxes) != self->obj->num_axes) {
-	PyErr_SetString(PyExc_TypeError, "axes has the wrong length");
-	return NULL;
-    }
-    axes = g_new(gdouble, self->obj->num_axes);
-    for (i = 0; i < self->obj->num_axes; i++) {
-	PyObject *item = PySequence_GetItem(pyaxes, i);
-
-	axes[i] = PyFloat_AsDouble(item);
-	Py_DECREF(item);
-	if (PyErr_Occurred()) {
-	    g_free(axes);
-	    return NULL;
-	}
-    }
-    ret = gdk_device_get_axis(self->obj, axes, use, &value);
-    g_free(axes);
-    if (ret)
-	return PyFloat_FromDouble(value);
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-static PyMethodDef pygdk_device_methods[] = {
-    { "set_source", (PyCFunction)pygdk_device_set_source, METH_VARARGS },
-    { "set_mode", (PyCFunction)pygdk_device_set_mode, METH_VARARGS },
-    { "set_key", (PyCFunction)pygdk_device_set_key, METH_VARARGS },
-    { "set_axis_use", (PyCFunction)pygdk_device_set_axis_use, METH_VARARGS },
-    { "get_state", (PyCFunction)pygdk_device_get_state, METH_VARARGS },
-    { "get_history", (PyCFunction)pygdk_device_get_history, METH_VARARGS },
-    { "get_axis", (PyCFunction)pygdk_device_get_axis, METH_VARARGS },
-    { NULL, NULL, 0 }
-};
-
-static PyObject *
-pygdk_device_getattr(PyGdkDevice_Object *self, char *attr)
-{
-    if (!strcmp(attr, "__members__"))
-	return Py_BuildValue("[ssssss]", "axes", "has_cursor", "keys",
-			     "mode", "name", "source");
-    else if (!strcmp(attr, "name"))
-	return PyString_FromString(self->obj->name);
-    else if (!strcmp(attr, "source"))
-	return PyInt_FromLong(self->obj->source);
-    else if (!strcmp(attr, "mode"))
-	return PyInt_FromLong(self->obj->mode);
-    else if (!strcmp(attr, "axes")) {
-	PyObject *ret;
-	gint i;
-
-	ret = PyTuple_New(self->obj->num_axes);
-	for (i = 0; i < self->obj->num_axes; i++)
-	    PyTuple_SetItem(ret, i, Py_BuildValue("(idd)",
-						  self->obj->axes[i].use,
-						  self->obj->axes[i].min,
-						  self->obj->axes[i].max));
-	return ret;
-    } else if (!strcmp(attr, "keys")) {
-	PyObject *ret;
-	gint i;
-
-	ret = PyTuple_New(self->obj->num_keys);
-	for (i = 0; i < self->obj->num_keys; i++)
-	    PyTuple_SetItem(ret, i, Py_BuildValue("(ii)",
-						self->obj->keys[i].keyval,
-						self->obj->keys[i].modifiers));
-	return ret;
-    }
-    return Py_FindMethod(pygdk_device_methods, (PyObject *)self, attr);
-}
-
-PyTypeObject PyGdkDevice_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
-    "GdkDevice",
-    sizeof(PyGdkDevice_Object),
-    0,
-    (destructor)pygdk_device_dealloc,
-    (printfunc)0,
-    (getattrfunc)pygdk_device_getattr,
-    (setattrfunc)0,
-    (cmpfunc)pygdk_device_compare,
-    (reprfunc)0,
-    0,
-    0,
-    0,
-    (hashfunc)pygdk_device_hash,
-    (ternaryfunc)0,
-    (reprfunc)0,
-    0L,0L,0L,0L,
-    NULL
-};
-
 PyObject *
 pygtk_tree_path_to_pyobject(GtkTreePath *path)
 {
@@ -1813,7 +1561,6 @@ _pygtk_register_boxed_types(PyObject *moddict)
 #endif
     register_tp(GdkAtom);
     register_tp(GtkCTreeNode);
-    register_tp(GdkDevice);
     pyg_boxed_register(GTK_TYPE_TREE_PATH,
 		       PyGtkTreePath_from_value,
 		       PyGtkTreePath_to_value);
diff --git a/gtk/gtk.override b/gtk/gtk.override
index a5c340bf..6f17339f 100644
--- a/gtk/gtk.override
+++ b/gtk/gtk.override
@@ -610,7 +610,7 @@ _wrap_gdk_event_getattr(PyObject *self, char *attr)
 	if (!strcmp(attr, "is_hint"))
 	    return PyInt_FromLong(event->motion.is_hint);
 	if (!strcmp(attr, "device"))
-	    return PyGdkDevice_New(event->motion.device);
+	    return pygobject_new((GObject *)event->motion.device);
 	if (!strcmp(attr, "x_root"))
 	    return PyFloat_FromDouble(event->motion.x_root);
 	if (!strcmp(attr, "y_root"))
@@ -644,7 +644,7 @@ _wrap_gdk_event_getattr(PyObject *self, char *attr)
 	if (!strcmp(attr, "button"))
 	    return PyInt_FromLong(event->button.button);
 	if (!strcmp(attr, "device"))
-	    return PyGdkDevice_New(event->button.device);
+	    return pygobject_new((GObject *)event->button.device);
 	if (!strcmp(attr, "x_root"))
 	    return PyFloat_FromDouble(event->button.x_root);
 	if (!strcmp(attr, "y_root"))
@@ -728,7 +728,7 @@ _wrap_gdk_event_getattr(PyObject *self, char *attr)
 	if (!strcmp(attr, "time"))
 	    return PyInt_FromLong(event->proximity.time);
 	if (!strcmp(attr, "device"))
-	    return PyGdkDevice_New(event->proximity.device);
+	    return pygobject_new((GObject *)event->proximity.device);
 	break;
     case GDK_DRAG_ENTER:        /*GdkEventDND               dnd*/
     case GDK_DRAG_LEAVE:        /*GdkEventDND               dnd*/
@@ -771,7 +771,7 @@ _wrap_gdk_event_getattr(PyObject *self, char *attr)
 	if (!strcmp(attr, "direction"))
 	    return PyInt_FromLong(event->scroll.direction);
 	if (!strcmp(attr, "device"))
-	    return PyGdkDevice_New(event->scroll.device);
+	    return pygobject_new((GObject *)event->scroll.device);
 	if (!strcmp(attr, "x_root"))
 	    return PyFloat_FromDouble(event->scroll.x_root);
 	if (!strcmp(attr, "y_root"))
@@ -796,6 +796,141 @@ _wrap_gdk_event_getattr(PyObject *self, char *attr)
     return NULL;
 }
 %%
+override_attr GdkDevice.axes
+GdkDevice *device = GDK_DEVICE(self->obj);
+PyObject *ret;
+gint i;
+
+ret = PyTuple_New(device->num_axes);
+for (i = 0; i < device->num_axes; i++)
+    PyTuple_SetItem(ret, i, Py_BuildValue("(idd)",
+					  device->axes[i].use,
+					  device->axes[i].min,
+					  device->axes[i].max));
+return ret;
+%%
+override_attr GdkDevice.keys
+GdkDevice *device = GDK_DEVICE(self->obj);
+PyObject *ret;
+gint i;
+
+ret = PyTuple_New(device->num_keys);
+for (i = 0; i < device->num_keys; i++)
+    PyTuple_SetItem(ret, i, Py_BuildValue("(ii)",
+					  device->keys[i].keyval,
+					  device->keys[i].modifiers));
+return ret;
+%%
+override gdk_device_get_state kwargs
+static PyObject *
+_wrap_gdk_device_get_state(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "window", NULL };
+    GdkDevice *device = GDK_DEVICE(self->obj);
+    PyGObject *window;
+    gdouble *axes;
+    GdkModifierType mask;
+    PyObject *py_axes;
+    guint i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GdkDevice.get_state",
+				     kwlist, &window))
+	return NULL;
+    if (!pygobject_check(window, &PyGdkWindow_Type)) {
+	PyErr_SetString(PyExc_TypeError, "window should be a GdkWindow");
+	return NULL;
+    }
+    axes = g_new0(gdouble, device->num_axes);
+    gdk_device_get_state(device, GDK_WINDOW(window->obj), axes, &mask);
+    py_axes = PyTuple_New(device->num_axes);
+    for (i = 0; i < device->num_axes; i++)
+	PyTuple_SetItem(py_axes, i, PyFloat_FromDouble(axes[i]));
+    g_free(axes);
+    return Py_BuildValue("(Ni)", py_axes, mask);
+}
+%%
+ignore gdk_device_free_history
+%%
+override gdk_device_get_history kwargs
+static PyObject *
+_wrap_gdk_device_get_history(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "window", "start", "stop", NULL };
+    GdkDevice *device = GDK_DEVICE(self->obj);
+    PyGObject *window;
+    guint start, stop;
+    GdkTimeCoord **events;
+    gint n_events;
+    PyObject *pyevents;
+    guint i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "Oii:GdkDevice.get_history", kwlist,
+				     &window, &start, &stop))
+	return NULL;
+    if (!pygobject_check(window, &PyGdkWindow_Type)) {
+	PyErr_SetString(PyExc_TypeError, "window should be a GdkWindow");
+	return NULL;
+    }
+    gdk_device_get_history(device, GDK_WINDOW(window->obj), start, stop,
+			   &events, &n_events);
+    pyevents = PyTuple_New(n_events);
+    for (i = 0; i < n_events; i++) {
+	PyObject *axes;
+	gint j;
+
+	axes = PyTuple_New(device->num_axes);
+	for (j = 0; j < device->num_axes; j++)
+	    PyTuple_SetItem(axes, j, PyFloat_FromDouble(events[i]->axes[j]));
+	PyTuple_SetItem(pyevents, i, Py_BuildValue("(iN)", events[i]->time,
+						   axes));
+    }
+    gdk_device_free_history(events, n_events);
+    return pyevents;
+}
+%%
+override gdk_device_get_axis kwargs
+static PyObject *
+_wrap_gdk_device_get_axis(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "axes", "use", NULL };
+    GdkDevice *device = GDK_DEVICE(self->obj);
+    PyObject *py_axes;
+    gdouble *axes, value;
+    GdkAxisUse use;
+    gboolean ret;
+    gint i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi:GdkDevice.get_axis",
+				     kwlist, &py_axes, &use))
+	return NULL;
+    if (!PySequence_Check(py_axes)) {
+	PyErr_SetString(PyExc_TypeError, "axes must be a sequence");
+	return NULL;
+    }
+    if (PySequence_Length(py_axes) != device->num_axes) {
+	PyErr_SetString(PyExc_TypeError, "axes has the wrong length");
+	return NULL;
+    }
+    axes = g_new(gdouble, device->num_axes);
+    for (i = 0; i < device->num_axes; i++) {
+	PyObject *item = PySequence_GetItem(py_axes, i);
+
+	axes[i] = PyFloat_AsDouble(item);
+	Py_DECREF(item);
+	if (PyErr_Occurred()) {
+	    g_free(axes);
+	    return NULL;
+       }
+    }
+    ret = gdk_device_get_axis(device, axes, use, &value);
+    g_free(axes);
+    if (ret)
+	return PyFloat_FromDouble(value);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
 ignore gtk_selection_data_copy gtk_selection_data_free
 %%
 override_attr GtkSelectionData.data
diff --git a/gtk/gtkmodule.c b/gtk/gtkmodule.c
index 0d0342be..2c6e0d03 100644
--- a/gtk/gtkmodule.c
+++ b/gtk/gtkmodule.c
@@ -23,7 +23,6 @@ static struct _PyGtk_FunctionStruct functions = {
 
     &PyGdkAtom_Type,  PyGdkAtom_New,
     &PyGtkCTreeNode_Type,  PyGtkCTreeNode_New,
-    &PyGdkDevice_Type, PyGdkDevice_New,
 };
 
 DL_EXPORT(void)
diff --git a/gtk/pygtk-private.h b/gtk/pygtk-private.h
index c570b0f5..ffb46388 100644
--- a/gtk/pygtk-private.h
+++ b/gtk/pygtk-private.h
@@ -16,17 +16,14 @@
 /* type objects */
 extern PyTypeObject PyGdkAtom_Type;
 extern PyTypeObject PyGtkCTreeNode_Type;
-extern PyTypeObject PyGdkDevice_Type;
 
 /* check the type of a PyObject */
 #define PyGdkAtom_Check(v) ((v)->ob_type == &PyGdkAtom_Type)
 #define PyGtkCTreeNode_Check(v) ((v)->ob_type == &PyGtkCTreeNode_Type)
-#define PyGdkDevice_Check(v) ((v)->ob_type == &PyGdkDevice_Type)
 
 /* constructors for PyObject wrappers ... */
 PyObject *PyGdkAtom_New(GdkAtom atom);
 PyObject *PyGtkCTreeNode_New(GtkCTreeNode *node);
-PyObject *PyGdkDevice_New(GdkDevice *device);
 
 /* miscelaneous functions */
 void pygtk_block_threads(void);
diff --git a/gtk/pygtk.h b/gtk/pygtk.h
index 35ef57c6..1851750c 100644
--- a/gtk/pygtk.h
+++ b/gtk/pygtk.h
@@ -22,9 +22,6 @@ struct _PyGtk_FunctionStruct {
 
     PyTypeObject *gtkCTreeNode_type;
     PyObject *(* gtkCTreeNode_new)(GtkCTreeNode *node);
-
-    PyTypeObject *gdkDevice_type;
-    PyObject *(* gdkDevice_new)(GdkDevice *device);
 };
 
 /* structure definitions for the various object types in PyGTK */
@@ -39,15 +36,9 @@ typedef struct {
     GtkCTreeNode *node;
 } PyGtkCTreeNode_Object;
 
-typedef struct {
-    PyObject_HEAD
-    GdkDevice *obj;
-} PyGdkDevice_Object;
-
 /* routines to get the C object value out of the PyObject wrapper */
 #define PyGdkAtom_Get(v) (((PyGdkAtom_Object *)(v))->atom)
 #define PyGtkCTreeNode_Get(v) (((PyGtkCTreeNode_Object *)(v))->node)
-#define PyGdkDevice_Get(v) (((PyGdkDevice_Object *)(v))->obj)
 
 /* this section is dependent on whether we are being included from gtkmodule.c
  * or not.  A similar source level interface should be provided in both
@@ -65,17 +56,14 @@ struct _PyGtk_FunctionStruct *_PyGtk_API;
 /* type objects */
 #define PyGdkAtom_Type          *(_PyGtk_API->gdkAtom_type)
 #define PyGtkCTreeNode_Type     *(_PyGtk_API->gtkCTreeNode_type)
-#define PyGdkDevice_Type        *(_PyGtk_API->gdkDevice_type)
 
 /* type checking routines */
 #define PyGdkAtom_Check(v) ((v)->ob_type == _PyGtk_API->gdkAtom_type)
 #define PyGtkCTreeNode_Check(v) ((v)->ob_type == _PyGtk_API->gtkCTreeNode_type)
-#define PyGdkDevice_Check(v) ((v)->ob_type == _PyGtk_API->gdkDevice_type)
 
 /* type objects */
 #define PyGdkAtom_New          (_PyGtk_API->gdkAtom_new)
 #define PyGtkCTreeNode_New     (_PyGtk_API->gtkCTreeNode_new)
-#define PyGdkDevice_New        (_PyGtk_API->gdkDevice_new)
 
 /* miscelaneous other functions */
 #define pygtk_block_threads (_PyGtk_API->block_threads)