Ignore calls with <= width or height.

Mon Jul  3 14:24:16 2000  Owen Taylor  <otaylor@redhat.com>

	* gtk/gtkwidget.c (gtk_widget_draw): Ignore calls with
	<= width or height.

	* gtk/gtktable.c (gtk_table_attach): Fix missed merge
	from 1.2 for parent/child states.

	* gdk/gdkgc.c (gdk_gc_set_rgb_fg/bg_color): Fix a couple
	of typos.

	* gdk/gdkevents.[ch]: Remove press/xtilt/ytilt fields of
	event structures, replace with a generic axes field. Replace
	deviceid/source with GdkDevice *device.

	* gdk/gdkevents.[ch] (gdk_event_get_axis): Add function
	to extract particular axis use value from event. (Also
	can be used for normal X/Y.)

	* gdk/gdkinput.h gdk/x11/gdkinput*: Major revision;
	allow for arbitrary number of axes, namespace everything
	as gdk_device_*. Replace guint32 deviceid with GdkDevice *
	everywhere.

	* gdk/x11/{gdkmain-x11.c,gdkevent-x11.c,gdkinput*}:
	Get rid of the gdk_input_vtable setup if favor of simply
	defining the functions in gdkinput-none/gxi/xfree.c in
	a similar fashion to the way that the port structure is
	done.

	* gtk/gtkdnd.c: Fix fields of synthesized button press event
	for new event structures.

	* gtk/gtkinputdialog.c gtk/testinput.c: Revise to match
	new device interfaces.

12 files changed, 780 insertions, 851 deletions

diff --git a/gdk/gdkevents.c b/gdk/gdkevents.c
index 86658bc44..9fd127c24 100644
--- a/gdk/gdkevents.c
+++ b/gdk/gdkevents.c
@@ -377,6 +377,17 @@ gdk_event_free (GdkEvent *event)
     case GDK_DROP_FINISHED:
       gdk_drag_context_unref (event->dnd.context);
       break;
+
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+      if (event->button.axes)
+	g_free (event->button.axes);
+      break;
+
+    case GDK_MOTION_NOTIFY:
+      if (event->motion.axes)
+	g_free (event->motion.axes);
+      break;
       
     default:
       break;
@@ -440,6 +451,80 @@ gdk_event_get_time (GdkEvent *event)
   return GDK_CURRENT_TIME;
 }
 
+/**
+ * gdk_event_get_axis:
+ * @event: a #GdkEvent
+ * @axis_use: the axis use to look for
+ * @value: location to store the value found
+ * 
+ * Extract the axis value for a particular axis use from
+ * an event structure.
+ * 
+ * Return value: %TRUE if the specified axis was found, otherwise %FALSE
+ **/
+gboolean
+gdk_event_get_axis (GdkEvent   *event,
+		    GdkAxisUse  axis_use,
+		    gdouble    *value)
+{
+  gdouble *axes;
+  GdkDevice *device;
+  
+  g_return_val_if_fail (event != NULL, FALSE);
+  
+  if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)
+    {
+      gdouble x, y;
+      
+      switch (event->type)
+	{
+	case GDK_MOTION_NOTIFY:
+	  x = event->motion.x;
+	  y = event->motion.y;
+	  break;
+	case GDK_SCROLL:
+	  x = event->scroll.x;
+	  y = event->scroll.y;
+	  break;
+	case GDK_BUTTON_PRESS:
+	case GDK_BUTTON_RELEASE:
+	  x = event->button.x;
+	  y = event->button.y;
+	  break;
+	case GDK_ENTER_NOTIFY:
+	case GDK_LEAVE_NOTIFY:
+	  x = event->crossing.x;
+	  y = event->crossing.y;
+	  break;
+	  
+	default:
+	  return FALSE;
+	}
+
+      if (axis_use == GDK_AXIS_X && value)
+	*value = x;
+      if (axis_use == GDK_AXIS_Y && value)
+	*value = y;
+
+      return TRUE;
+    }
+  else if (event->type == GDK_BUTTON_PRESS ||
+	   event->type == GDK_BUTTON_RELEASE)
+    {
+      device = event->button.device;
+      axes = event->button.axes;
+    }
+  else if (event->type == GDK_MOTION_NOTIFY)
+    {
+      device = event->motion.device;
+      axes = event->motion.axes;
+    }
+  else
+    return FALSE;
+
+  return gdk_device_get_axis (device, axes, axis_use, value);
+}
+
 /*
  *--------------------------------------------------------------
  * gdk_set_show_events
diff --git a/gdk/gdkevents.h b/gdk/gdkevents.h
index 9997fbee2..a6d8384f6 100644
--- a/gdk/gdkevents.h
+++ b/gdk/gdkevents.h
@@ -231,13 +231,10 @@ struct _GdkEventMotion
   guint32 time;
   gdouble x;
   gdouble y;
-  gdouble pressure;
-  gdouble xtilt;
-  gdouble ytilt;
+  gdouble *axes;
   guint state;
   gint16 is_hint;
-  GdkInputSource source;
-  guint32 deviceid;
+  GdkDevice *device;
   gdouble x_root, y_root;
 };
 
@@ -249,13 +246,10 @@ struct _GdkEventButton
   guint32 time;
   gdouble x;
   gdouble y;
-  gdouble pressure;
-  gdouble xtilt;
-  gdouble ytilt;
+  gdouble *axes;
   guint state;
   guint button;
-  GdkInputSource source;
-  guint32 deviceid;
+  GdkDevice *device;
   gdouble x_root, y_root;
 };
 
@@ -267,13 +261,9 @@ struct _GdkEventScroll
   guint32 time;
   gdouble x;
   gdouble y;
-  gdouble pressure;
-  gdouble xtilt;
-  gdouble ytilt;
   guint state;
   GdkScrollDirection direction;
-  GdkInputSource source;
-  guint32 deviceid;
+  GdkDevice *device;
   gdouble x_root, y_root;
 };
 
@@ -355,8 +345,7 @@ struct _GdkEventProximity
   GdkWindow *window;
   gint8 send_event;
   guint32 time;
-  GdkInputSource source;
-  guint32 deviceid;
+  GdkDevice *device;
 };
 
 struct _GdkEventClient
@@ -416,6 +405,9 @@ void      gdk_event_put	 		(GdkEvent  	*event);
 GdkEvent* gdk_event_copy     		(GdkEvent 	*event);
 void	  gdk_event_free     		(GdkEvent 	*event);
 guint32   gdk_event_get_time 		(GdkEvent 	*event);
+gboolean  gdk_event_get_axis            (GdkEvent       *event,
+					 GdkAxisUse      axis_use,
+					 gdouble        *value);
 
 void	  gdk_event_handler_set 	(GdkEventFunc    func,
 					 gpointer        data,
diff --git a/gdk/gdkgc.c b/gdk/gdkgc.c
index 8a54612e2..07f80e94a 100644
--- a/gdk/gdkgc.c
+++ b/gdk/gdkgc.c
@@ -443,7 +443,7 @@ gdk_gc_set_rgb_fg_color (GdkGC *gc, GdkColor *color)
 
   tmp_color = *color;
   gdk_rgb_find_color (cmap, &tmp_color);
-  gdk_gc_set_foreground (cmap, &tmp_color);
+  gdk_gc_set_foreground (gc, &tmp_color);
 }
 
 /**
@@ -474,5 +474,5 @@ gdk_gc_set_rgb_bg_color (GdkGC *gc, GdkColor *color)
 
   tmp_color = *color;
   gdk_rgb_find_color (cmap, &tmp_color);
-  gdk_gc_set_foreground (cmap, &tmp_color);
+  gdk_gc_set_foreground (gc, &tmp_color);
 }
diff --git a/gdk/gdkinput.h b/gdk/gdkinput.h
index 35550b265..35c915f72 100644
--- a/gdk/gdkinput.h
+++ b/gdk/gdkinput.h
@@ -8,7 +8,8 @@ extern "C" {
 #endif /* __cplusplus */
 
 typedef struct _GdkDeviceKey	    GdkDeviceKey;
-typedef struct _GdkDeviceInfo	    GdkDeviceInfo;
+typedef struct _GdkDeviceAxis	    GdkDeviceAxis;
+typedef struct _GdkDevice	    GdkDevice;
 typedef struct _GdkTimeCoord	    GdkTimeCoord;
 
 typedef enum
@@ -41,66 +42,91 @@ typedef enum
   GDK_AXIS_PRESSURE,
   GDK_AXIS_XTILT,
   GDK_AXIS_YTILT,
+  GDK_AXIS_WHEEL,
   GDK_AXIS_LAST
 } GdkAxisUse;
 
-struct _GdkDeviceInfo
+struct _GdkDeviceKey
+{
+  guint keyval;
+  GdkModifierType modifiers;
+};
+
+struct _GdkDeviceAxis
+{
+  GdkAxisUse use;
+  gdouble    min;
+  gdouble    max;
+};
+
+struct _GdkDevice
 {
-  guint32 deviceid;
+  /* All fields are read-only */
+	  
   gchar *name;
   GdkInputSource source;
   GdkInputMode mode;
-  gint has_cursor;	/* TRUE if the X pointer follows device motion */
+  gboolean has_cursor;	     /* TRUE if the X pointer follows device motion */
+	  
   gint num_axes;
-  GdkAxisUse *axes;    /* Specifies use for each axis */
+  GdkDeviceAxis *axes;
+	  
   gint num_keys;
   GdkDeviceKey *keys;
 };
 
-struct _GdkDeviceKey
-{
-  guint keyval;
-  GdkModifierType modifiers;
-};
+/* We don't allocate each coordinate this big, but we use it to
+ * be ANSI compliant and avoid accessing past the defined limits.
+ */
+#define GDK_MAX_TIMECOORD_AXES 128
 
 struct _GdkTimeCoord
 {
   guint32 time;
-  gdouble x;
-  gdouble y;
-  gdouble pressure;
-  gdouble xtilt;
-  gdouble ytilt;
+  gdouble axes[GDK_MAX_TIMECOORD_AXES];
 };
 
-GList *       gdk_input_list_devices         (void);
-void          gdk_input_set_extension_events (GdkWindow        *window,
-					      gint              mask,
-					      GdkExtensionMode  mode);
-void          gdk_input_set_source           (guint32           deviceid,
-					      GdkInputSource    source);
-gboolean      gdk_input_set_mode             (guint32           deviceid,
-					      GdkInputMode      mode);
-void          gdk_input_set_axes             (guint32           deviceid,
-					      GdkAxisUse       *axes);
-void          gdk_input_set_key              (guint32           deviceid,
-					      guint             index,
-					      guint             keyval,
-					      GdkModifierType   modifiers);
-void          gdk_input_window_get_pointer   (GdkWindow        *window,
-					      guint32           deviceid,
-					      gdouble          *x,
-					      gdouble          *y,
-					      gdouble          *pressure,
-					      gdouble          *xtilt,
-					      gdouble          *ytilt,
-					      GdkModifierType  *mask);
-GdkTimeCoord *gdk_input_motion_events        (GdkWindow        *window,
-					      guint32           deviceid,
-					      guint32           start,
-					      guint32           stop,
-					      gint             *nevents_return);
+/* Returns a list of GdkDevice * */	  
+GList *        gdk_devices_list         (void);
+
+/* Functions to configure a device */
+void           gdk_device_set_source    (GdkDevice      *device,
+					 GdkInputSource  source);
+	  
+gboolean       gdk_device_set_mode      (GdkDevice      *device,
+					 GdkInputMode    mode);
+
+void           gdk_device_set_key       (GdkDevice      *device,
+					 guint           index,
+					 guint           keyval,
+					 GdkModifierType modifiers);
+
+void     gdk_device_set_axis_use (GdkDevice         *device,
+				  guint              index,
+				  GdkAxisUse         use);
+void     gdk_device_get_state    (GdkDevice         *device,
+				  GdkWindow         *window,
+				  gdouble           *axes,
+				  GdkModifierType   *mask);
+gboolean gdk_device_get_history  (GdkDevice         *device,
+				  GdkWindow         *window,
+				  guint32            start,
+				  guint32            stop,
+				  GdkTimeCoord    ***events,
+				  gint              *n_events);
+void     gdk_device_free_history (GdkTimeCoord     **events,
+				  gint               n_events);
+gboolean gdk_device_get_axis     (GdkDevice         *device,
+				  gdouble           *axes,
+				  GdkAxisUse         use,
+				  gdouble           *value);
+
+void gdk_input_set_extension_events (GdkWindow        *window,
+				     gint              mask,
+				     GdkExtensionMode  mode);
 
+extern GdkDevice *gdk_core_pointer;
+ 
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/gdk/x11/gdkevents-x11.c b/gdk/x11/gdkevents-x11.c
index 0086247c0..c6156c390 100644
--- a/gdk/x11/gdkevents-x11.c
+++ b/gdk/x11/gdkevents-x11.c
@@ -283,10 +283,9 @@ gdk_event_translate (GdkEvent *event,
    *  some circumstances.
    */
   
-  if ((xevent->xany.window == None) &&
-      gdk_input_vtable.window_none_event)
+  if (xevent->xany.window == None)
     {
-      return_val = gdk_input_vtable.window_none_event (event,xevent);
+      return_val = _gdk_input_window_none_event (event, xevent);
       
       if (return_val >= 0)	/* was handled */
 	return return_val;
@@ -517,12 +516,8 @@ gdk_event_translate (GdkEvent *event,
 	  event->scroll.y = xevent->xbutton.y + yoffset;
 	  event->scroll.x_root = (gfloat)xevent->xbutton.x_root;
 	  event->scroll.y_root = (gfloat)xevent->xbutton.y_root;
-	  event->scroll.pressure = 0.5;
-	  event->scroll.xtilt = 0;
-	  event->scroll.ytilt = 0;
 	  event->scroll.state = (GdkModifierType) xevent->xbutton.state;
-	  event->scroll.source = GDK_SOURCE_MOUSE;
-	  event->scroll.deviceid = GDK_CORE_POINTER;
+	  event->scroll.device = gdk_core_pointer;
 	}
       else
 	{
@@ -533,13 +528,10 @@ gdk_event_translate (GdkEvent *event,
 	  event->button.y = xevent->xbutton.y + yoffset;
 	  event->button.x_root = (gfloat)xevent->xbutton.x_root;
 	  event->button.y_root = (gfloat)xevent->xbutton.y_root;
-	  event->button.pressure = 0.5;
-	  event->button.xtilt = 0;
-	  event->button.ytilt = 0;
+	  event->button.axes = NULL;
 	  event->button.state = (GdkModifierType) xevent->xbutton.state;
 	  event->button.button = xevent->xbutton.button;
-	  event->button.source = GDK_SOURCE_MOUSE;
-	  event->button.deviceid = GDK_CORE_POINTER;
+	  event->button.device = gdk_core_pointer;
 	  
 	  gdk_event_button_generate (event);
 	}
@@ -575,13 +567,10 @@ gdk_event_translate (GdkEvent *event,
       event->button.y = xevent->xbutton.y + yoffset;
       event->button.x_root = (gfloat)xevent->xbutton.x_root;
       event->button.y_root = (gfloat)xevent->xbutton.y_root;
-      event->button.pressure = 0.5;
-      event->button.xtilt = 0;
-      event->button.ytilt = 0;
+      event->button.axes = NULL;
       event->button.state = (GdkModifierType) xevent->xbutton.state;
       event->button.button = xevent->xbutton.button;
-      event->button.source = GDK_SOURCE_MOUSE;
-      event->button.deviceid = GDK_CORE_POINTER;
+      event->button.device = gdk_core_pointer;
       
       break;
       
@@ -607,13 +596,10 @@ gdk_event_translate (GdkEvent *event,
       event->motion.y = xevent->xmotion.y + yoffset;
       event->motion.x_root = (gfloat)xevent->xmotion.x_root;
       event->motion.y_root = (gfloat)xevent->xmotion.y_root;
-      event->motion.pressure = 0.5;
-      event->motion.xtilt = 0;
-      event->motion.ytilt = 0;
+      event->motion.axes = NULL;
       event->motion.state = (GdkModifierType) xevent->xmotion.state;
       event->motion.is_hint = xevent->xmotion.is_hint;
-      event->motion.source = GDK_SOURCE_MOUSE;
-      event->motion.deviceid = GDK_CORE_POINTER;
+      event->motion.device = gdk_core_pointer;
       
       break;
       
@@ -627,9 +613,8 @@ gdk_event_translate (GdkEvent *event,
       /* Tell XInput stuff about it if appropriate */
       if (window_private &&
 	  !GDK_WINDOW_DESTROYED (window) &&
-	  (window_private->extension_events != 0) &&
-	  gdk_input_vtable.enter_event)
-	gdk_input_vtable.enter_event (&xevent->xcrossing, window);
+	  window_private->extension_events != 0)
+	_gdk_input_enter_event (&xevent->xcrossing, window);
       
       event->crossing.type = GDK_ENTER_NOTIFY;
       event->crossing.window = window;
@@ -999,9 +984,8 @@ gdk_event_translate (GdkEvent *event,
 			   : ""));
       if (window &&
 	  !GDK_WINDOW_DESTROYED (window) &&
-	  (window_private->extension_events != 0) &&
-	  gdk_input_vtable.configure_event)
-	gdk_input_vtable.configure_event (&xevent->xconfigure, window);
+	  (window_private->extension_events != 0))
+	_gdk_input_configure_event (&xevent->xconfigure, window);
 
       if (!window || GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
 	return_val = FALSE;
@@ -1180,9 +1164,8 @@ gdk_event_translate (GdkEvent *event,
       
       if (window_private &&
 	  !GDK_WINDOW_DESTROYED (window_private) &&
-	  (window_private->extension_events != 0) &&
-	  gdk_input_vtable.other_event)
-	return_val = gdk_input_vtable.other_event(event, xevent, window);
+	  (window_private->extension_events != 0))
+	return_val = _gdk_input_other_event(event, xevent, window);
       else
 	return_val = FALSE;
       
diff --git a/gdk/x11/gdkinput-gxi.c b/gdk/x11/gdkinput-gxi.c
index b73b674fe..2f173ca16 100644
--- a/gdk/x11/gdkinput-gxi.c
+++ b/gdk/x11/gdkinput-gxi.c
@@ -35,45 +35,13 @@
 
 /* Forward declarations */
 static void gdk_input_gxi_select_notify (GdkDevicePrivate *gdkdev);
-static gint gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode);
-static gint gdk_input_is_extension_device (guint32 deviceid);
-static void gdk_input_gxi_configure_event (XConfigureEvent *xevent, 
-					   GdkWindow *window);
-static void gdk_input_gxi_enter_event (XCrossingEvent *xevent, 
-				       GdkWindow *window);
-static gint gdk_input_gxi_other_event (GdkEvent *event, 
-				       XEvent *xevent, 
-				       GdkWindow *window);
+static gint gdk_input_is_extension_device (GdkDevicePrivate *device_private);
 static void gdk_input_gxi_update_device (GdkDevicePrivate *gdkdev);
 
-static gint gdk_input_gxi_window_none_event (GdkEvent *event, XEvent *xevent);
-static gint gdk_input_gxi_enable_window (GdkWindow *window, 
-					 GdkDevicePrivate *gdkdev);
-static gint gdk_input_gxi_disable_window (GdkWindow *window, 
-					  GdkDevicePrivate *gdkdev);
 static Window gdk_input_find_root_child(Display *dpy, Window w);
 static void gdk_input_compute_obscuring(GdkInputWindow *input_window);
 static gint gdk_input_is_obscured(GdkInputWindow *input_window, gdouble x, 
 				  gdouble y);
-static GdkTimeCoord *gdk_input_gxi_motion_events (GdkWindow *window,
-						  guint32 deviceid,
-						  guint32 start,
-						  guint32 stop,
-						  gint *nevents_return);
-static void gdk_input_gxi_get_pointer (GdkWindow       *window,
-				       guint32	   deviceid,
-				       gdouble         *x,
-				       gdouble         *y,
-				       gdouble         *pressure,
-				       gdouble         *xtilt,
-				       gdouble         *ytilt,
-				       GdkModifierType *mask);
-static gint gdk_input_gxi_grab_pointer (GdkWindow *     window,
-					gint            owner_events,
-					GdkEventMask    event_mask,
-					GdkWindow *     confine_to,
-					guint32         time);
-static void gdk_input_gxi_ungrab_pointer (guint32 time);
 
 /* Local variables */
 
@@ -85,20 +53,6 @@ gdk_input_init(void)
 {
   GList *tmp_list;
   
-  gdk_input_vtable.set_mode           = gdk_input_gxi_set_mode;
-  gdk_input_vtable.set_axes           = gdk_input_common_set_axes;
-  gdk_input_vtable.set_key            = gdk_input_common_set_key;
-  gdk_input_vtable.motion_events      = gdk_input_gxi_motion_events;
-  gdk_input_vtable.get_pointer	      = gdk_input_gxi_get_pointer;
-  gdk_input_vtable.grab_pointer	      = gdk_input_gxi_grab_pointer;
-  gdk_input_vtable.ungrab_pointer     = gdk_input_gxi_ungrab_pointer;
-  gdk_input_vtable.configure_event    = gdk_input_gxi_configure_event;
-  gdk_input_vtable.enter_event        = gdk_input_gxi_enter_event;
-  gdk_input_vtable.other_event        = gdk_input_gxi_other_event;
-  gdk_input_vtable.window_none_event  = gdk_input_gxi_window_none_event;
-  gdk_input_vtable.enable_window      = gdk_input_gxi_enable_window;
-  gdk_input_vtable.disable_window     = gdk_input_gxi_disable_window;
-
   gdk_input_ignore_core = FALSE;
   gdk_input_core_pointer = NULL;
 
@@ -120,13 +74,13 @@ gdk_input_init(void)
   for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next) 
     {
       GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)tmp_list->data;
-      if (gdk_input_is_extension_device(gdkdev->info.deviceid))
+      if (gdk_input_is_extension_device (gdkdev))
 	{
 	  gdk_input_gxi_select_notify (gdkdev);
 	}
       else
 	{
-	  if (gdkdev->info.deviceid != GDK_CORE_POINTER)
+	  if (!GDK_IS_CORE (gdkdev))
 	    gdk_input_core_pointer = gdkdev;
 	}
     }
@@ -146,19 +100,26 @@ gdk_input_gxi_select_notify (GdkDevicePrivate *gdkdev)
 static gint
 gdk_input_gxi_set_core_pointer(GdkDevicePrivate *gdkdev)
 {
-  int x_axis,y_axis;
+  gint x_axis = -1;
+  gint y_axis = -1;
+  gint i;
 
   g_return_val_if_fail(gdkdev->xdevice,FALSE);
 
-  x_axis = gdkdev->axis_for_use[GDK_AXIS_X];
-  y_axis = gdkdev->axis_for_use[GDK_AXIS_Y];
-
-  g_return_val_if_fail(x_axis != -1 && y_axis != -1,FALSE);
+  for (i=0; i<gdkdev->info.num_axes; i++)
+    {
+      if (gdkdev->info.axes[i].use == GDK_AXIS_X)
+	x_axis = i;
+      else if (gdkdev->info.axes[i].use == GDK_AXIS_Y)
+	y_axis = i;
+    }
+  
+  g_return_val_if_fail (x_axis != -1 && y_axis != -1,FALSE);
 
   /* core_pointer might not be up to date so we check with the server
      before change the pointer */
 
-  if ( !gdk_input_is_extension_device(gdkdev->info.deviceid) )
+  if (!gdk_input_is_extension_device (gdkdev))
     {
 #if 0
       if (gdkdev != gdk_input_core_pointer)
@@ -181,24 +142,27 @@ gdk_input_gxi_set_core_pointer(GdkDevicePrivate *gdkdev)
 }
 
 
-/* FIXME, merge with gdk_input_xfree_set_mode */
+/* FIXME, merge with the XFree implementation */
 
-static gint
-gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode)
+gboolean
+gdk_device_set_mode (GdkDevice      *device,
+		     GdkInputMode    mode)
 {
   GList *tmp_list;
   GdkDevicePrivate *gdkdev;
   GdkInputMode old_mode;
   GdkInputWindow *input_window;
 
-  gdkdev = gdk_input_find_device(deviceid);
-  g_return_val_if_fail (gdkdev != NULL,FALSE);
-  old_mode = gdkdev->info.mode;
+  if (GDK_IS_CORE (device))
+    return FALSE;
+
+  gdkdev = (GdkDevicePrivate *)device;
 
-  if (gdkdev->info.mode == mode)
+  if (device->mode == mode)
     return TRUE;
-  
-  gdkdev->info.mode = mode;
+
+  old_mode = device->mode;
+  device->mode = mode;
 
   if (old_mode != GDK_MODE_DISABLED)
     {
@@ -206,7 +170,7 @@ gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode)
 	{
 	  input_window = (GdkInputWindow *)tmp_list->data;
 	  if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR)
-	    gdk_input_disable_window (input_window->window, gdkdev);
+	    _gdk_input_disable_window (input_window->window, gdkdev);
 	}
     }
   
@@ -216,31 +180,31 @@ gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode)
 	{
 	  input_window = (GdkInputWindow *)tmp_list->data;
 	  if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR)
-	    if (!gdk_input_enable_window(input_window->window, gdkdev))
+	    if (!_gdk_input_enable_window(input_window->window, gdkdev))
 	      {
-		gdk_input_set_mode(deviceid, old_mode);
+		gdk_device_set_mode (device, old_mode);
 		return FALSE;
 	      }
 	}
     }
 
   return TRUE;
-
 }
 
 gint
-gdk_input_is_extension_device (guint32 deviceid)
+gdk_input_is_extension_device (GdkDevicePrivate *private)
 {
   XDeviceInfo   *devices;
   int num_devices, loop;
 
-  if (deviceid == GDK_CORE_POINTER)
+  if (GDK_IS_CORE (private))
     return FALSE;
   
   devices = XListInputDevices(gdk_display, &num_devices);
   for(loop=0; loop<num_devices; loop++)
     {
-      if ((devices[loop].id == deviceid) && (devices[loop].use == IsXExtensionDevice)) 
+      if ((devices[loop].id == private->deviceid) &&
+	  (devices[loop].use == IsXExtensionDevice)) 
 	{
 	  XFreeDeviceList(devices);
 	  return TRUE;
@@ -251,8 +215,8 @@ gdk_input_is_extension_device (guint32 deviceid)
   return FALSE;
 }
 
-static void
-gdk_input_gxi_configure_event (XConfigureEvent *xevent, GdkWindow *window)
+void
+_gdk_input_configure_event (XConfigureEvent *xevent, GdkWindow *window)
 {
   GdkInputWindow *input_window;
   gint root_x, root_y;
@@ -267,8 +231,8 @@ gdk_input_gxi_configure_event (XConfigureEvent *xevent, GdkWindow *window)
   gdk_input_compute_obscuring(input_window);
 }
 
-static void
-gdk_input_gxi_enter_event (XCrossingEvent *xevent, GdkWindow *window)
+void
+_gdk_input_enter_event (XCrossingEvent *xevent, GdkWindow *window)
 {
   GdkInputWindow *input_window;
 
@@ -278,28 +242,32 @@ gdk_input_gxi_enter_event (XCrossingEvent *xevent, GdkWindow *window)
   gdk_input_compute_obscuring(input_window);
 }
 
-static gint 
-gdk_input_gxi_other_event (GdkEvent *event, 
+gint
+_gdk_input_other_event (GdkEvent *event, 
 			   XEvent *xevent, 
 			   GdkWindow *window)
 {
   GdkInputWindow *input_window;
-
+  GdkWindowImplX11 *impl;
+  
   GdkDevicePrivate *gdkdev;
   gint return_val;
 
   input_window = gdk_input_window_find(window);
   g_return_val_if_fail (window != NULL, -1);
 
+  impl = GDK_WINDOW_IMPL_X11 (((GdkWindowObject *) input_window->window)->impl);
+
   /* This is a sort of a hack, as there isn't any XDeviceAnyEvent -
      but it's potentially faster than scanning through the types of
      every device. If we were deceived, then it won't match any of
      the types for the device anyways */
   gdkdev = gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid);
 
-  if (!gdkdev) {
-    return -1;			/* we don't handle it - not an XInput event */
-  }
+  if (!gdkdev)
+    {
+      return -1;			/* we don't handle it - not an XInput event */
+    }
 
   if (gdkdev->info.mode == GDK_MODE_DISABLED ||
       input_window->mode == GDK_EXTENSION_EVENTS_CURSOR)
@@ -317,8 +285,8 @@ gdk_input_gxi_other_event (GdkEvent *event,
   if (return_val > 0 && event->type == GDK_MOTION_NOTIFY &&
       (!gdkdev->button_state) && (!input_window->grabbed) &&
       ((event->motion.x < 0) || (event->motion.y < 0) ||
-       (event->motion.x > ((GdkDrawablePrivate *)window)->width) || 
-       (event->motion.y > ((GdkDrawablePrivate *)window)->height) ||
+       (event->motion.x > impl->width) || 
+       (event->motion.y > impl->height) ||
        gdk_input_is_obscured(input_window,event->motion.x,event->motion.y)))
     {
 #ifdef DEBUG_SWITCHING
@@ -341,11 +309,11 @@ gdk_input_gxi_update_device (GdkDevicePrivate *gdkdev)
 {
   GList *t;
 
-  if (gdk_input_is_extension_device (gdkdev->info.deviceid))
+  if (gdk_input_is_extension_device (gdkdev))
     {
       if (!gdkdev->xdevice)
 	{
-	  gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->info.deviceid);
+	  gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->deviceid);
 	  gdk_input_gxi_select_notify (gdkdev);
 	  gdkdev->needs_update = 1;
 	}
@@ -359,8 +327,8 @@ gdk_input_gxi_update_device (GdkDevicePrivate *gdkdev)
     }
 }
 
-static gint 
-gdk_input_gxi_window_none_event (GdkEvent *event, XEvent *xevent)
+gint
+_gdk_input_window_none_event (GdkEvent *event, XEvent *xevent)
 {
   GdkDevicePrivate *gdkdev = 
     gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid);
@@ -386,8 +354,8 @@ gdk_input_gxi_window_none_event (GdkEvent *event, XEvent *xevent)
   return FALSE;
 }
 
-static gint
-gdk_input_gxi_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
+gboolean
+_gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
 {
   GdkInputWindow *input_window;
 
@@ -397,7 +365,7 @@ gdk_input_gxi_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
   if (!gdkdev->claimed)
     {
       if (gxid_claim_device(gdk_input_gxid_host, gdk_input_gxid_port,
-			    gdkdev->info.deviceid,
+			    gdkdev->deviceid,
 			    GDK_WINDOW_XWINDOW(window), FALSE) !=
 	  GXID_RETURN_OK)
 	{
@@ -415,8 +383,8 @@ gdk_input_gxi_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
   return TRUE;
 }
 
-static gint
-gdk_input_gxi_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
+gboolean
+_gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
 {
   GdkInputWindow *input_window;
 
@@ -426,7 +394,7 @@ gdk_input_gxi_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
   if (gdkdev->claimed)
     {
       gxid_release_device(gdk_input_gxid_host, gdk_input_gxid_port,
-			  gdkdev->info.deviceid,
+			  gdkdev->deviceid,
 			  GDK_WINDOW_XWINDOW(window));
 
       gdkdev->claimed = FALSE;
@@ -478,7 +446,7 @@ gdk_input_find_root_child(Display *dpy, Window w)
   return w;
 }
 
-void
+static void
 gdk_input_compute_obscuring(GdkInputWindow *input_window)
 {
   int i;
@@ -549,57 +517,12 @@ gdk_input_compute_obscuring(GdkInputWindow *input_window)
     XFree(children);
 }
 
-static void 
-gdk_input_gxi_get_pointer     (GdkWindow       *window,
-			       guint32	   deviceid,
-			       gdouble         *x,
-			       gdouble         *y,
-			       gdouble         *pressure,
-			       gdouble         *xtilt,
-			       gdouble         *ytilt,
-			       GdkModifierType *mask)
-{
-  GdkDevicePrivate *gdkdev;
-
-  gdkdev = gdk_input_find_device (deviceid);
-  g_return_if_fail (gdkdev != NULL);
-
-  if (gdkdev == gdk_input_core_pointer)
-    gdk_input_common_get_pointer (window, GDK_CORE_POINTER, x, y,
-				  pressure, xtilt, ytilt, mask);
-  else
-    gdk_input_common_get_pointer (window, deviceid, x, y,
-				  pressure, xtilt, ytilt, mask);
-}
-
-static GdkTimeCoord *
-gdk_input_gxi_motion_events (GdkWindow *window,
-			     guint32 deviceid,
-			     guint32 start,
-			     guint32 stop,
-			     gint *nevents_return)
-{
-  GdkDevicePrivate *gdkdev;
-
-  gdkdev = gdk_input_find_device (deviceid);
-  g_return_val_if_fail (gdkdev != NULL, NULL);
-  
-
-  if (gdkdev == gdk_input_core_pointer)
-    return gdk_input_motion_events (window, GDK_CORE_POINTER, start, stop,
-				    nevents_return);
-  else
-    return gdk_input_common_motion_events (window, deviceid, start, stop,
-					   nevents_return);
-  
-}
-
-static gint 
-gdk_input_gxi_grab_pointer (GdkWindow *     window,
-			    gint            owner_events,
-			    GdkEventMask    event_mask,
-			    GdkWindow *     confine_to,
-			    guint32         time)
+gint 
+_gdk_input_grab_pointer (GdkWindow *     window,
+			 gint            owner_events,
+			 GdkEventMask    event_mask,
+			 GdkWindow *     confine_to,
+			 guint32         time)
 {
   GList *tmp_list;
   GdkInputWindow *input_window;
@@ -622,7 +545,7 @@ gdk_input_gxi_grab_pointer (GdkWindow *     window,
   while (tmp_list)
     {
       gdkdev = (GdkDevicePrivate *)tmp_list->data;
-      if (gdkdev->info.deviceid != GDK_CORE_POINTER && 
+      if (!GDK_IS_CORE (gdkdev) && 
 	  gdkdev->xdevice &&
 	  (gdkdev->button_state != 0))
 	gdkdev->button_state = 0;
@@ -633,8 +556,8 @@ gdk_input_gxi_grab_pointer (GdkWindow *     window,
   return Success;
 }
 
-static void 
-gdk_input_gxi_ungrab_pointer (guint32 time)
+void 
+_gdk_input_ungrab_pointer (guint32 time)
 {
   GdkInputWindow *input_window;
   GList *tmp_list;
diff --git a/gdk/x11/gdkinput-none.c b/gdk/x11/gdkinput-none.c
index d3aba3dd9..4c7cf705e 100644
--- a/gdk/x11/gdkinput-none.c
+++ b/gdk/x11/gdkinput-none.c
@@ -26,54 +26,104 @@
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
 
-static void gdk_input_none_get_pointer (GdkWindow       *window,
-					guint32	  deviceid,
-					gdouble         *x,
-					gdouble         *y,
-					gdouble         *pressure,
-					gdouble         *xtilt,
-					gdouble         *ytilt,
-					GdkModifierType *mask);
-
 void
 gdk_input_init (void)
 {
-  gdk_input_vtable.set_mode           = NULL;
-  gdk_input_vtable.set_axes           = NULL;
-  gdk_input_vtable.set_key            = NULL;
-  gdk_input_vtable.motion_events      = NULL;
-  gdk_input_vtable.get_pointer        = gdk_input_none_get_pointer;
-  gdk_input_vtable.grab_pointer       = NULL;
-  gdk_input_vtable.ungrab_pointer     = NULL;
-  gdk_input_vtable.configure_event    = NULL;
-  gdk_input_vtable.enter_event        = NULL;
-  gdk_input_vtable.other_event        = NULL;
-  gdk_input_vtable.window_none_event  = NULL;
-  gdk_input_vtable.enable_window      = NULL;
-  gdk_input_vtable.disable_window     = NULL;
-
-  gdk_input_devices = g_list_append (NULL, (GdkDeviceInfo *) &gdk_input_core_info);
+  gdk_input_devices = g_list_append (NULL, gdk_core_pointer);
 
   gdk_input_ignore_core = FALSE;
 }
 
-static void
-gdk_input_none_get_pointer (GdkWindow       *window,
-			    guint32          deviceid,
-			    gdouble         *x,
-			    gdouble         *y,
-			    gdouble         *pressure,
-			    gdouble         *xtilt,
-			    gdouble         *ytilt,
-			    GdkModifierType *mask)
+void 
+gdk_device_get_state (GdkDevice       *device,
+		      GdkWindow       *window,
+		      gdouble         *axes,
+		      GdkModifierType *mask)
 {
   gint x_int, y_int;
 
+  g_return_if_fail (device != NULL);
+  g_return_if_fail (GDK_IS_WINDOW (window));
+
   gdk_window_get_pointer (window, &x_int, &y_int, mask);
 
-  if (x) *x = x_int;
-  if (y) *y = y_int;
-  if (pressure) *pressure = 0.5;
-  if (xtilt) *xtilt = 0;
-  if (ytilt) *ytilt = 0;
+  if (axes)
+    {
+      axes[0] = x_int;
+      axes[1] = y_int;
+    }
+}
+
+gboolean
+_gdk_device_get_history (GdkDevice         *device,
+			 GdkWindow         *window,
+			 guint32            start,
+			 guint32            stop,
+			 GdkTimeCoord    ***events,
+			 gint              *n_events)
+{
+  g_warning ("gdk_device_get_history() called for invalid device");
+  return FALSE;
+}
+
+gboolean
+_gdk_input_enable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
+{
+  return TRUE;
+}
+
+gboolean
+_gdk_input_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
+{
+  return TRUE;
+}
+
+gint 
+_gdk_input_window_none_event (GdkEvent         *event,
+			     XEvent           *xevent)
+{
+  return -1;
 }
+
+gint 
+_gdk_input_other_event (GdkEvent *event, 
+			XEvent *xevent, 
+			GdkWindow *window)
+{
+  return -1;
+}
+
+void
+_gdk_input_configure_event (XConfigureEvent *xevent,
+			    GdkWindow       *window)
+{
+}
+
+void 
+_gdk_input_enter_event (XCrossingEvent *xevent, 
+			GdkWindow      *window)
+{
+}
+
+gint 
+_gdk_input_grab_pointer (GdkWindow *     window,
+			 gint            owner_events,
+			 GdkEventMask    event_mask,
+			 GdkWindow *     confine_to,
+			 guint32         time)
+{
+  return Success;
+}
+
+void
+_gdk_input_ungrab_pointer (guint32         time)
+{
+}
+
+gboolean
+gdk_device_set_mode (GdkDevice   *device,
+		     GdkInputMode mode)
+{
+  return FALSE;
+}
+
diff --git a/gdk/x11/gdkinput-x11.c b/gdk/x11/gdkinput-x11.c
index 1e1c501e9..c3c245a34 100644
--- a/gdk/x11/gdkinput-x11.c
+++ b/gdk/x11/gdkinput-x11.c
@@ -27,6 +27,7 @@
 #include "gdkinputprivate.h"
 #include "gdkinternals.h"
 #include "gdkx.h"
+#include "gdk.h"		/* For gdk_error_trap_push()/pop() */
 
 #include <string.h>
 
@@ -34,56 +35,49 @@
 static GdkDevicePrivate *gdk_input_device_new(XDeviceInfo *device, 
 					      gint include_core);
 static void gdk_input_translate_coordinates(GdkDevicePrivate *gdkdev,
-					    GdkInputWindow *input_window,
-					    gint *axis_data,
-					    gdouble *x, gdouble *y,
-					    gdouble *pressure,
-					    gdouble *xtilt, gdouble *ytilt);
+					    GdkInputWindow   *input_window,
+					    gint             *axis_data,
+					    gdouble          *axis_out,
+					    gdouble          *x_out,
+					    gdouble          *y_out);
 static guint gdk_input_translate_state(guint state, guint device_state);
-void  gdk_input_common_get_pointer     (GdkWindow       *window,
-					guint32	   deviceid,
-					gdouble         *x,
-					gdouble         *y,
-					gdouble         *pressure,
-					gdouble         *xtilt,
-					gdouble         *ytilt,
-					GdkModifierType *mask);
 
 /* Global variables */
 
-static gint gdk_input_root_width;
-static gint gdk_input_root_height;
+GdkDevicePrivate *
+gdk_input_find_device (guint32 id)
+{
+  GList *tmp_list = gdk_input_devices;
+  GdkDevicePrivate *gdkdev;
+  while (tmp_list)
+    {
+      gdkdev = (GdkDevicePrivate *)(tmp_list->data);
+      if (gdkdev->deviceid == id)
+	return gdkdev;
+      tmp_list = tmp_list->next;
+    }
+  return NULL;
+}
 
 void
 gdk_input_get_root_relative_geometry(Display *dpy, Window w, int *x_ret, int *y_ret,
-			       int *width_ret, int *height_ret)
+				     int *width_ret, int *height_ret)
 {
-  Window root,parent;
+  Window root, parent, child;
   Window *children;
   guint nchildren;
   gint x,y;
   guint width, height;
-  gint xc,yc;
-  guint widthc,heightc,border_widthc,depthc;
+  guint border_widthc, depthc;
+   
+  XQueryTree (dpy, w, &root, &parent, &children, &nchildren);
+  if (children)
+    XFree(children);
   
-  XQueryTree(dpy,w,&root,&parent,&children,&nchildren);
-  if (children) XFree(children);
-  XGetGeometry(dpy,w,&root,&x,&y,&width,&height,&border_widthc,
-	       &depthc);
-  x += border_widthc;
-  y += border_widthc;
-
-  while (root != parent)
-    {
-      w = parent;
-      XQueryTree(dpy,w,&root,&parent,&children,&nchildren);
-      if (children) XFree(children);
-      XGetGeometry(dpy,w,&root,&xc,&yc,&widthc,&heightc,
-		   &border_widthc,&depthc);
-      x += xc + border_widthc;
-      y += yc + border_widthc;
-    }
+  XGetGeometry (dpy, w, &root, &x, &y, &width, &height, &border_widthc, &depthc);
 
+  XTranslateCoordinates (dpy, w, root, 0, 0, &x, &y, &child);
+ 
   if (x_ret)
     *x_ret = x;
   if (y_ret)
@@ -95,26 +89,22 @@ gdk_input_get_root_relative_geometry(Display *dpy, Window w, int *x_ret, int *y_
 }
 
 static GdkDevicePrivate *
-gdk_input_device_new(XDeviceInfo *device, gint include_core)
+gdk_input_device_new (XDeviceInfo *device, gint include_core)
 {
   GdkDevicePrivate *gdkdev;
-  gchar *tmp_name, *p;
+  gchar *tmp_name;
   XAnyClassPtr class;
   gint i,j;
 
   gdkdev = g_new(GdkDevicePrivate,1);
 
-  gdkdev->info.deviceid = device->id;
-  if (device->name[0]) {
-    gdkdev->info.name = g_new(char, strlen(device->name)+1);
-    strcpy(gdkdev->info.name,device->name);
-  } else {
-    /* XFree86 3.2 gives an empty name to the default core devices,
-       (fixed in 3.2A) */
-    gdkdev->info.name = g_strdup("pointer");
-    strcpy(gdkdev->info.name,"pointer");
-    gdkdev->info.source = GDK_SOURCE_MOUSE;
-  }
+  gdkdev->deviceid = device->id;
+  if (device->name[0])
+    gdkdev->info.name = g_strdup (device->name);
+ else
+   /* XFree86 3.2 gives an empty name to the default core devices,
+      (fixed in 3.2A) */
+   gdkdev->info.name = g_strdup ("pointer");
 
   gdkdev->info.mode = GDK_MODE_DISABLED;
 
@@ -122,12 +112,8 @@ gdk_input_device_new(XDeviceInfo *device, gint include_core)
      could invite a very, very, long list... Lowercase name
      for comparison purposes */
 
-  tmp_name = g_strdup(gdkdev->info.name);
-  for (p = tmp_name; *p; p++)
-    {
-      if (*p >= 'A' && *p <= 'Z')
-	*p += 'a' - 'A';
-    }
+  tmp_name = g_strdup (gdkdev->info.name);
+  g_strdown (tmp_name);
   
   if (!strcmp (tmp_name, "pointer"))
     gdkdev->info.source = GDK_SOURCE_MOUSE;
@@ -162,9 +148,7 @@ gdk_input_device_new(XDeviceInfo *device, gint include_core)
     {
       switch (class->class) {
       case ButtonClass:
-	{
-	  break;
-	}
+	break;
       case KeyClass:
 	{
 	  XKeyInfo *xki = (XKeyInfo *)class;
@@ -195,8 +179,8 @@ gdk_input_device_new(XDeviceInfo *device, gint include_core)
 	{
 	  XValuatorInfo *xvi = (XValuatorInfo *)class;
 	  gdkdev->info.num_axes = xvi->num_axes;
-	  gdkdev->axes = g_new(GdkAxisInfo, xvi->num_axes);
-	  gdkdev->info.axes = g_new(GdkAxisUse, xvi->num_axes);
+	  gdkdev->axes = g_new (GdkAxisInfo, xvi->num_axes);
+	  gdkdev->info.axes = g_new0 (GdkDeviceAxis, xvi->num_axes);
 	  for (j=0;j<xvi->num_axes;j++)
 	    {
 	      gdkdev->axes[j].resolution = 
@@ -205,27 +189,21 @@ gdk_input_device_new(XDeviceInfo *device, gint include_core)
 		gdkdev->axes[j].xmin_value = xvi->axes[j].min_value;
 	      gdkdev->axes[j].max_value =
 		gdkdev->axes[j].xmax_value = xvi->axes[j].max_value;
-	      gdkdev->info.axes[j] = GDK_AXIS_IGNORE;
+	      gdkdev->info.axes[j].use = GDK_AXIS_IGNORE;
 	    }
 	  j=0;
 	  if (j<xvi->num_axes)
-	    gdkdev->info.axes[j++] = GDK_AXIS_X;
+	    gdk_device_set_axis_use (&gdkdev->info, j++, GDK_AXIS_X);
 	  if (j<xvi->num_axes)
-	    gdkdev->info.axes[j++] = GDK_AXIS_Y;
+	    gdk_device_set_axis_use (&gdkdev->info, j++, GDK_AXIS_Y);
 	  if (j<xvi->num_axes)
-	    gdkdev->info.axes[j++] = GDK_AXIS_PRESSURE;
+	    gdk_device_set_axis_use (&gdkdev->info, j++, GDK_AXIS_PRESSURE);
 	  if (j<xvi->num_axes)
-	    gdkdev->info.axes[j++] = GDK_AXIS_XTILT;
+	    gdk_device_set_axis_use (&gdkdev->info, j++, GDK_AXIS_XTILT);
 	  if (j<xvi->num_axes)
-	    gdkdev->info.axes[j++] = GDK_AXIS_YTILT;
-	  
-	  /* set up reverse lookup on axis use */
-	  for (j=GDK_AXIS_IGNORE;j<GDK_AXIS_LAST;j++)
-	    gdkdev->axis_for_use[j] = -1;
-	  
-	  for (j=0;j<xvi->num_axes;j++)
-	    if (gdkdev->info.axes[j] != GDK_AXIS_IGNORE)
-	      gdkdev->axis_for_use[gdkdev->info.axes[j]] = j;
+	    gdk_device_set_axis_use (&gdkdev->info, j++, GDK_AXIS_YTILT);
+	  if (j<xvi->num_axes)
+	    gdk_device_set_axis_use (&gdkdev->info, j++, GDK_AXIS_WHEEL);
 		       
 	  break;
 	}
@@ -235,41 +213,16 @@ gdk_input_device_new(XDeviceInfo *device, gint include_core)
   /* return NULL if no axes */
   if (!gdkdev->info.num_axes || !gdkdev->axes ||
       (!include_core && device->use == IsXPointer))
-    {
-      g_free(gdkdev->info.name);
-      if (gdkdev->axes)
-	g_free(gdkdev->axes);
-      if (gdkdev->info.keys)
-	g_free(gdkdev->info.keys);
-      if (gdkdev->info.axes)
-	g_free (gdkdev->info.axes);
-      g_free(gdkdev);
-      return NULL;
-    }
+    goto error;
 
   if (device->use != IsXPointer)
     {
-      int error_warn = gdk_error_warnings;
-
-      gdk_error_warnings = 0;
-      gdk_error_code = 0;
-      gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->info.deviceid);
-      gdk_error_warnings = error_warn;
+      gdk_error_trap_push ();
+      gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->deviceid);
 
       /* return NULL if device is not ready */
-      if (gdk_error_code)
-	{
-	  g_free (gdkdev->info.name);
-	  if (gdkdev->axes)
-	    g_free (gdkdev->axes);
-	  if (gdkdev->info.keys)
-	    g_free (gdkdev->info.keys);
-	  if (gdkdev->info.axes)
-	    g_free (gdkdev->info.axes);
-	  g_free (gdkdev);
-
-	  return NULL;
-	}
+      if (gdk_error_trap_pop ())
+	goto error;
     }
 
   gdkdev->buttonpress_type = 0;
@@ -282,6 +235,19 @@ gdk_input_device_new(XDeviceInfo *device, gint include_core)
   gdkdev->changenotify_type = 0;
 
   return gdkdev;
+
+ error:
+
+  g_free (gdkdev->info.name);
+  if (gdkdev->axes)
+    g_free (gdkdev->axes);
+  if (gdkdev->info.keys)
+    g_free (gdkdev->info.keys);
+  if (gdkdev->info.axes)
+    g_free (gdkdev->info.axes);
+  g_free (gdkdev);
+  
+  return NULL;
 }
 
 void
@@ -414,12 +380,6 @@ gdk_input_common_init(gint include_core)
   int num_extensions, loop;
   Display *display = gdk_display;
 
-  /* Init global vars */
-  gdk_window_get_geometry(NULL,	/* use root window */
-			  NULL,NULL,
-			  &gdk_input_root_width,&gdk_input_root_height, 
-			  NULL);
-
   /* Init XInput extension */
   
   extensions = XListExtensions(display, &num_extensions);
@@ -443,33 +403,44 @@ gdk_input_common_init(gint include_core)
       XFreeDeviceList(devices);
     }
 
-  gdk_input_devices = g_list_append (gdk_input_devices, (gpointer)&gdk_input_core_info);
+  gdk_input_devices = g_list_append (gdk_input_devices, gdk_core_pointer);
 
   return TRUE;
 }
 
 static void
 gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
-				 GdkInputWindow *input_window,
-				 gint *axis_data,
-				 gdouble *x, gdouble *y, gdouble *pressure,
-				 gdouble *xtilt, gdouble *ytilt)
+				 GdkInputWindow   *input_window,
+				 gint             *axis_data,
+				 gdouble          *axis_out,
+				 gdouble          *x_out,
+				 gdouble          *y_out)
 {
   GdkWindowImplX11 *impl;
-
-  int x_axis, y_axis, pressure_axis, xtilt_axis, ytilt_axis;
+  int i;
+  int x_axis = 0;
+  int y_axis = 0;
 
   double device_width, device_height;
   double x_offset, y_offset, x_scale, y_scale;
 
   impl = GDK_WINDOW_IMPL_X11 (((GdkWindowObject *) input_window->window)->impl);
 
-  x_axis = gdkdev->axis_for_use[GDK_AXIS_X];
-  y_axis = gdkdev->axis_for_use[GDK_AXIS_Y];
-  pressure_axis = gdkdev->axis_for_use[GDK_AXIS_PRESSURE];
-  xtilt_axis = gdkdev->axis_for_use[GDK_AXIS_XTILT];
-  ytilt_axis = gdkdev->axis_for_use[GDK_AXIS_YTILT];
-
+  for (i=0; i<gdkdev->info.num_axes; i++)
+    {
+      switch (gdkdev->info.axes[i].use)
+	{
+	case GDK_AXIS_X:
+	  x_axis = i;
+	  break;
+	case GDK_AXIS_Y:
+	  y_axis = i;
+	  break;
+	default:
+	  break;
+	}
+    }
+  
   device_width = gdkdev->axes[x_axis].max_value - 
 		   gdkdev->axes[x_axis].min_value;
   device_height = gdkdev->axes[y_axis].max_value - 
@@ -477,8 +448,8 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
 
   if (gdkdev->info.mode == GDK_MODE_SCREEN) 
     {
-      x_scale = gdk_input_root_width / device_width;
-      y_scale = gdk_input_root_height / device_height;
+      x_scale = gdk_screen_width() / device_width;
+      y_scale = gdk_screen_height() / device_height;
 
       x_offset = - input_window->root_x;
       y_offset = - input_window->root_y;
@@ -510,54 +481,37 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
 	  x_offset = - (device_width * x_scale - impl->width)/2;
 	}
     }
-  
-  if (x) *x = x_offset + x_scale*axis_data[x_axis];
-  if (y) *y = y_offset + y_scale*axis_data[y_axis];
 
-  if (pressure)
-    {
-      if (pressure_axis != -1)
-	*pressure = ((double)axis_data[pressure_axis] 
-		     - gdkdev->axes[pressure_axis].min_value) 
-	  / (gdkdev->axes[pressure_axis].max_value 
-	     - gdkdev->axes[pressure_axis].min_value);
-      else
-	*pressure = 0.5;
-    }
-
-  if (xtilt)
-    {
-      if (xtilt_axis != -1)
-	{
-	  *xtilt = 2. * (double)(axis_data[xtilt_axis] - 
-				 (gdkdev->axes[xtilt_axis].min_value +
-				  gdkdev->axes[xtilt_axis].max_value)/2) /
-	    (gdkdev->axes[xtilt_axis].max_value -
-	     gdkdev->axes[xtilt_axis].min_value);
-	}
-      else *xtilt = 0;
-    }
-  
-  if (ytilt)
+  for (i=0; i<gdkdev->info.num_axes; i++)
     {
-      if (ytilt_axis != -1)
+      switch (gdkdev->info.axes[i].use)
 	{
-	  *ytilt = 2. * (double)(axis_data[ytilt_axis] - 
-				 (gdkdev->axes[ytilt_axis].min_value +
-				  gdkdev->axes[ytilt_axis].max_value)/2) /
-	    (gdkdev->axes[ytilt_axis].max_value -
-	     gdkdev->axes[ytilt_axis].min_value);
+	case GDK_AXIS_X:
+	  axis_out[i] = x_offset + x_scale*axis_data[x_axis];
+	  if (x_out)
+	    *x_out = axis_out[i];
+	  break;
+	case GDK_AXIS_Y:
+	  axis_out[i] = y_offset + y_scale*axis_data[y_axis];
+	  if (y_out)
+	    *y_out = axis_out[i];
+	  break;
+	default:
+	  axis_out[i] =
+	    (gdkdev->info.axes[i].max * (axis_data[i] - gdkdev->axes[i].min_value) +
+	     gdkdev->info.axes[i].min * (gdkdev->axes[i].max_value - axis_data[i])) /
+	    (gdkdev->axes[i].max_value - gdkdev->axes[i].min_value);
+	  break;
 	}
-      else
-	*ytilt = 0;
     }
 }
 
 /* combine the state of the core device and the device state
-   into one - for now we do this in a simple-minded manner -
-   we just take the keyboard portion of the core device and
-   the button portion (all of?) the device state.
-   Any button remapping should go on here. */
+ * into one - for now we do this in a simple-minded manner -
+ * we just take the keyboard portion of the core device and
+ * the button portion (all of?) the device state.
+ * Any button remapping should go on here.
+ */
 static guint
 gdk_input_translate_state(guint state, guint device_state)
 {
@@ -586,16 +540,14 @@ gdk_input_common_other_event (GdkEvent         *event,
 	  event->button.type = GDK_BUTTON_RELEASE;
 	  gdkdev->button_state &= ~(1 << xdbe->button);
 	}
+      event->button.device = &gdkdev->info;
       event->button.window = input_window->window;
       event->button.time = xdbe->time;
-      event->button.source = gdkdev->info.source;
-      event->button.deviceid = xdbe->deviceid;
 
+      event->button.axes = g_new (gdouble, gdkdev->info.num_axes);
       gdk_input_translate_coordinates (gdkdev,input_window, xdbe->axis_data,
-				       &event->button.x,&event->button.y,
-				       &event->button.pressure,
-				       &event->button.xtilt, 
-				       &event->button.ytilt);
+				       event->button.axes, 
+				       &event->button.x,&event->button.y);
       event->button.state = gdk_input_translate_state(xdbe->state,xdbe->device_state);
       event->button.button = xdbe->button;
 
@@ -674,21 +626,19 @@ gdk_input_common_other_event (GdkEvent         *event,
     {
       XDeviceMotionEvent *xdme = (XDeviceMotionEvent *)(xevent);
 
+      event->motion.device = &gdkdev->info;
+      
+      event->motion.axes = g_new (gdouble, gdkdev->info.num_axes);
       gdk_input_translate_coordinates(gdkdev,input_window,xdme->axis_data,
-				      &event->motion.x,&event->motion.y,
-				      &event->motion.pressure,
-				      &event->motion.xtilt, 
-				      &event->motion.ytilt);
+				      event->motion.axes,
+				      &event->motion.x,&event->motion.y);
 
       event->motion.type = GDK_MOTION_NOTIFY;
       event->motion.window = input_window->window;
       event->motion.time = xdme->time;
-      event->motion.deviceid = xdme->deviceid;
       event->motion.state = gdk_input_translate_state(xdme->state,
 						      xdme->device_state);
       event->motion.is_hint = xdme->is_hint;
-      event->motion.source = gdkdev->info.source;
-      event->motion.deviceid = xdme->deviceid;
 
       GDK_NOTE (EVENTS,
 	g_print ("motion notify:\t\twindow: %ld  device: %ld  x,y: %f %f  state %#4x  hint: %s\n",
@@ -707,12 +657,11 @@ gdk_input_common_other_event (GdkEvent         *event,
     {
       XProximityNotifyEvent *xpne = (XProximityNotifyEvent *)(xevent);
 
+      event->proximity.device = &gdkdev->info;
       event->proximity.type = (xevent->type == gdkdev->proximityin_type)?
   	GDK_PROXIMITY_IN:GDK_PROXIMITY_OUT;
       event->proximity.window = input_window->window;
       event->proximity.time = xpne->time;
-      event->proximity.source = gdkdev->info.source;
-      event->proximity.deviceid = xpne->deviceid;
       
       return TRUE;
   }
@@ -720,128 +669,91 @@ gdk_input_common_other_event (GdkEvent         *event,
   return -1;			/* wasn't one of our event types */
 }
 
-void
-gdk_input_common_set_axes (guint32 deviceid, GdkAxisUse *axes)
+gboolean
+_gdk_device_get_history (GdkDevice         *device,
+			 GdkWindow         *window,
+			 guint32            start,
+			 guint32            stop,
+			 GdkTimeCoord    ***events,
+			 gint              *n_events)
 {
-  int i;
-  GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid);
-  g_return_if_fail (gdkdev != NULL);
-
-  for (i=GDK_AXIS_IGNORE;i<GDK_AXIS_LAST;i++)
-    {
-      gdkdev->axis_for_use[i] = -1;
-    }
-
-  for (i=0;i<gdkdev->info.num_axes;i++)
-    {
-      gdkdev->info.axes[i] = axes[i];
-      gdkdev->axis_for_use[axes[i]] = i;
-    }
-}
-
-void 
-gdk_input_common_set_key (guint32 deviceid,
-			  guint   index,
-			  guint   keyval,
-			  GdkModifierType modifiers)
-{
-  GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid);
-  
-  gdkdev = gdk_input_find_device (deviceid);
-  g_return_if_fail (gdkdev != NULL);
-  g_return_if_fail (index < gdkdev->info.num_keys);
-
-  gdkdev->info.keys[index].keyval = keyval;
-  gdkdev->info.keys[index].modifiers = modifiers;
-}
-
-GdkTimeCoord *
-gdk_input_common_motion_events (GdkWindow *window,
-				guint32 deviceid,
-				guint32 start,
-				guint32 stop,
-				gint *nevents_return)
-{
-  GdkTimeCoord *coords;
+  GdkTimeCoord **coords;
   XDeviceTimeCoord *device_coords;
   GdkInputWindow *input_window;
   GdkDevicePrivate *gdkdev;
+  gint mode_return;
+  gint axis_count_return;
+  gint i;
 
-  int mode_return;
-  int axis_count_return;
-  int i;
-
-  gdkdev = gdk_input_find_device (deviceid);
+  gdkdev = (GdkDevicePrivate *)device;
   input_window = gdk_input_window_find (window);
 
-  g_return_val_if_fail (gdkdev != NULL, NULL);
-  g_return_val_if_fail (gdkdev->xdevice != NULL, NULL);
-  g_return_val_if_fail (input_window != NULL, NULL);
+  g_return_val_if_fail (input_window != NULL, FALSE);
 
   device_coords = XGetDeviceMotionEvents (gdk_display,
 					  gdkdev->xdevice,
 					  start, stop,
-					  nevents_return, &mode_return,
+					  n_events, &mode_return,
 					  &axis_count_return);
 
   if (device_coords)
     {
-      coords = g_new (GdkTimeCoord, *nevents_return);
+      coords = _gdk_device_allocate_history (device, *n_events);
       
-      for (i=0; i<*nevents_return; i++)
-	{
-	  gdk_input_translate_coordinates (gdkdev, input_window,
-					   device_coords[i].data,
-					   &coords[i].x, &coords[i].y,
-					   &coords[i].pressure,
-					   &coords[i].xtilt, &coords[i].ytilt);
-	}
+      for (i=0; i<*n_events; i++)
+	gdk_input_translate_coordinates (gdkdev, input_window,
+					 device_coords[i].data,
+					 coords[i]->axes, NULL, NULL);
       XFreeDeviceMotionEvents (device_coords);
 
-      return coords;
+      *events = coords;
+
+      return TRUE;
     }
   else
-    return NULL;
+    {
+      *events = NULL;
+      *n_events = 0;
+
+      return FALSE;
+    }
 }
 
 void 
-gdk_input_common_get_pointer     (GdkWindow       *window,
-				  guint32	   deviceid,
-				  gdouble         *x,
-				  gdouble         *y,
-				  gdouble         *pressure,
-				  gdouble         *xtilt,
-				  gdouble         *ytilt,
-				  GdkModifierType *mask)
+gdk_device_get_state (GdkDevice       *device,
+		      GdkWindow       *window,
+		      gdouble         *axes,
+		      GdkModifierType *mask)
 {
-  GdkDevicePrivate *gdkdev;
-  GdkInputWindow *input_window;
-  XDeviceState *state;
-  XInputClass *input_class;
-  gint x_int, y_int;
   gint i;
 
-  /* we probably need to get the mask in any case */
+  g_return_if_fail (device != NULL);
+  g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (deviceid == GDK_CORE_POINTER)
+  if (GDK_IS_CORE (device))
     {
+      gint x_int, y_int;
+      
       gdk_window_get_pointer (window, &x_int, &y_int, mask);
-      if (x) *x = x_int;
-      if (y) *y = y_int;
-      if (pressure) *pressure = 0.5;
-      if (xtilt) *xtilt = 0;
-      if (ytilt) *ytilt = 0;
+
+      if (axes)
+	{
+	  axes[0] = x_int;
+	  axes[1] = y_int;
+	}
     }
   else
     {
+      GdkDevicePrivate *gdkdev;
+      GdkInputWindow *input_window;
+      XDeviceState *state;
+      XInputClass *input_class;
+      
       if (mask)
 	gdk_window_get_pointer (window, NULL, NULL, mask);
       
-      gdkdev = gdk_input_find_device (deviceid);
+      gdkdev = (GdkDevicePrivate *)device;
       input_window = gdk_input_window_find (window);
-
-      g_return_if_fail (gdkdev != NULL);
-      g_return_if_fail (gdkdev->xdevice != NULL);
       g_return_if_fail (input_window != NULL);
 
       state = XQueryDeviceState (gdk_display, gdkdev->xdevice);
@@ -851,13 +763,12 @@ gdk_input_common_get_pointer     (GdkWindow       *window,
 	  switch (input_class->class)
 	    {
 	    case ValuatorClass:
-	      gdk_input_translate_coordinates (gdkdev, input_window,
-					       ((XValuatorState *)input_class)->valuators,
-					       x, y, pressure,
-					       xtilt, ytilt);
-						       
-						       
-		break;
+	      if (axes)
+		gdk_input_translate_coordinates (gdkdev, input_window,
+						 ((XValuatorState *)input_class)->valuators,
+						 axes, NULL, NULL);
+	      break;
+	      
 	    case ButtonClass:
 	      if (mask)
 		{
diff --git a/gdk/x11/gdkinput-xfree.c b/gdk/x11/gdkinput-xfree.c
index 396151210..c0b0fe972 100644
--- a/gdk/x11/gdkinput-xfree.c
+++ b/gdk/x11/gdkinput-xfree.c
@@ -28,83 +28,54 @@
 
 /* forward declarations */
 
-static gint gdk_input_xfree_set_mode (guint32 deviceid, GdkInputMode mode);
 static void gdk_input_check_proximity (void);
-static void gdk_input_xfree_configure_event (XConfigureEvent *xevent, 
-					     GdkWindow *window);
-static void gdk_input_xfree_enter_event (XCrossingEvent *xevent, 
-				       GdkWindow *window);
-static gint gdk_input_xfree_other_event (GdkEvent *event, 
-					 XEvent *xevent, 
-					 GdkWindow *window);
-static gint gdk_input_xfree_enable_window(GdkWindow *window, 
-					  GdkDevicePrivate *gdkdev);
-static gint gdk_input_xfree_disable_window(GdkWindow *window,
-					   GdkDevicePrivate *gdkdev);
-static gint gdk_input_xfree_grab_pointer (GdkWindow *     window,
-					  gint            owner_events,
-					  GdkEventMask    event_mask,
-					  GdkWindow *     confine_to,
-					  guint32         time);
-static void gdk_input_xfree_ungrab_pointer (guint32 time);
 
 void 
 gdk_input_init(void)
 {
-  gdk_input_vtable.set_mode           = gdk_input_xfree_set_mode;
-  gdk_input_vtable.set_axes           = gdk_input_common_set_axes;
-  gdk_input_vtable.set_key            = gdk_input_common_set_key;
-  gdk_input_vtable.motion_events      = gdk_input_common_motion_events;
-  gdk_input_vtable.get_pointer	      = gdk_input_common_get_pointer;
-  gdk_input_vtable.grab_pointer	      = gdk_input_xfree_grab_pointer;
-  gdk_input_vtable.ungrab_pointer     = gdk_input_xfree_ungrab_pointer;
-  gdk_input_vtable.configure_event    = gdk_input_xfree_configure_event;
-  gdk_input_vtable.enter_event        = gdk_input_xfree_enter_event;
-  gdk_input_vtable.other_event        = gdk_input_xfree_other_event;
-  gdk_input_vtable.window_none_event  = NULL;
-  gdk_input_vtable.enable_window      = gdk_input_xfree_enable_window;
-  gdk_input_vtable.disable_window     = gdk_input_xfree_disable_window;
-
   gdk_input_ignore_core = FALSE;
   gdk_input_common_init(FALSE);
 }
 
-static gint
-gdk_input_xfree_set_mode (guint32 deviceid, GdkInputMode mode)
+gboolean
+gdk_device_set_mode (GdkDevice      *device,
+		     GdkInputMode    mode)
 {
   GList *tmp_list;
   GdkDevicePrivate *gdkdev;
   GdkInputMode old_mode;
   GdkInputWindow *input_window;
 
-  gdkdev = gdk_input_find_device(deviceid);
-  g_return_val_if_fail (gdkdev != NULL,FALSE);
-  old_mode = gdkdev->info.mode;
+  if (GDK_IS_CORE (device))
+    return FALSE;
+
+  gdkdev = (GdkDevicePrivate *)device;
 
-  if (gdkdev->info.mode == mode)
+  if (device->mode == mode)
     return TRUE;
 
-  gdkdev->info.mode = mode;
+  old_mode = device->mode;
+  device->mode = mode;
 
   if (mode == GDK_MODE_WINDOW)
     {
-      gdkdev->info.has_cursor = FALSE;
+      device->has_cursor = FALSE;
       for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
 	{
 	  input_window = (GdkInputWindow *)tmp_list->data;
 	  if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR)
-	    gdk_input_enable_window (input_window->window, gdkdev);
+	    _gdk_input_enable_window (input_window->window, gdkdev);
 	  else
 	    if (old_mode != GDK_MODE_DISABLED)
-	      gdk_input_disable_window (input_window->window, gdkdev);
+	      _gdk_input_disable_window (input_window->window, gdkdev);
 	}
     }
   else if (mode == GDK_MODE_SCREEN)
     {
-      gdkdev->info.has_cursor = TRUE;
+      device->has_cursor = TRUE;
       for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
-	gdk_input_enable_window (((GdkInputWindow *)tmp_list->data)->window,
-				 gdkdev);
+	_gdk_input_enable_window (((GdkInputWindow *)tmp_list->data)->window,
+				  gdkdev);
     }
   else  /* mode == GDK_MODE_DISABLED */
     {
@@ -113,7 +84,7 @@ gdk_input_xfree_set_mode (guint32 deviceid, GdkInputMode mode)
 	  input_window = (GdkInputWindow *)tmp_list->data;
 	  if (old_mode != GDK_MODE_WINDOW ||
 	      input_window->mode != GDK_EXTENSION_EVENTS_CURSOR)
-	    gdk_input_disable_window (input_window->window, gdkdev);
+	    _gdk_input_disable_window (input_window->window, gdkdev);
 	}
     }
 
@@ -132,7 +103,7 @@ gdk_input_check_proximity (void)
       GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data);
 
       if (gdkdev->info.mode != GDK_MODE_DISABLED 
-	  && gdkdev->info.deviceid != GDK_CORE_POINTER
+	  && !GDK_IS_CORE (gdkdev)
 	  && gdkdev->xdevice)
 	{
 	  XDeviceState *state = XQueryDeviceState(GDK_DISPLAY(),
@@ -163,8 +134,9 @@ gdk_input_check_proximity (void)
   gdk_input_ignore_core = new_proximity;
 }
 
-static void
-gdk_input_xfree_configure_event (XConfigureEvent *xevent, GdkWindow *window)
+void
+_gdk_input_configure_event (XConfigureEvent *xevent,
+			    GdkWindow       *window)
 {
   GdkInputWindow *input_window;
   gint root_x, root_y;
@@ -180,9 +152,9 @@ gdk_input_xfree_configure_event (XConfigureEvent *xevent, GdkWindow *window)
   input_window->root_y = root_y;
 }
 
-static void 
-gdk_input_xfree_enter_event (XCrossingEvent *xevent, 
-			     GdkWindow      *window)
+void 
+_gdk_input_enter_event (XCrossingEvent *xevent, 
+			GdkWindow      *window)
 {
   GdkInputWindow *input_window;
   gint root_x, root_y;
@@ -200,13 +172,13 @@ gdk_input_xfree_enter_event (XCrossingEvent *xevent,
   input_window->root_y = root_y;
 }
 
-static gint 
-gdk_input_xfree_other_event (GdkEvent *event, 
-			     XEvent *xevent, 
-			     GdkWindow *window)
+gint 
+_gdk_input_other_event (GdkEvent *event, 
+			XEvent *xevent, 
+			GdkWindow *window)
 {
   GdkInputWindow *input_window;
-
+  
   GdkDevicePrivate *gdkdev;
   gint return_val;
 
@@ -217,11 +189,10 @@ gdk_input_xfree_other_event (GdkEvent *event,
      but it's potentially faster than scanning through the types of
      every device. If we were deceived, then it won't match any of
      the types for the device anyways */
-  gdkdev = gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid);
+  gdkdev = gdk_input_find_device (((XDeviceButtonEvent *)xevent)->deviceid);
 
-  if (!gdkdev) {
+  if (!gdkdev)
     return -1;			/* we don't handle it - not an XInput event */
-  }
 
   /* FIXME: It would be nice if we could just get rid of the events 
      entirely, instead of having to ignore them */
@@ -243,27 +214,27 @@ gdk_input_xfree_other_event (GdkEvent *event,
   return return_val;
 }
 
-static gint
-gdk_input_xfree_enable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
+gboolean
+_gdk_input_enable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
 {
   /* FIXME: watchout, gdkdev might be core pointer, never opened */
   gdk_input_common_select_events (window, gdkdev);
   return TRUE;
 }
 
-static gint
-gdk_input_xfree_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
+gboolean
+_gdk_input_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev)
 {
   gdk_input_common_select_events (window, gdkdev);
   return TRUE;
 }
 
-static gint 
-gdk_input_xfree_grab_pointer (GdkWindow *     window,
-			      gint            owner_events,
-			      GdkEventMask    event_mask,
-			      GdkWindow *     confine_to,
-			      guint32         time)
+gint 
+_gdk_input_grab_pointer (GdkWindow *     window,
+			 gint            owner_events,
+			 GdkEventMask    event_mask,
+			 GdkWindow *     confine_to,
+			 guint32         time)
 {
   GdkInputWindow *input_window, *new_window;
   gboolean need_ungrab;
@@ -300,8 +271,7 @@ gdk_input_xfree_grab_pointer (GdkWindow *     window,
       while (tmp_list)
 	{
 	  gdkdev = (GdkDevicePrivate *)tmp_list->data;
-	  if (gdkdev->info.deviceid != GDK_CORE_POINTER &&
-	      gdkdev->xdevice)
+	  if (!GDK_IS_CORE (gdkdev) && gdkdev->xdevice)
 	    {
 	      gdk_input_common_find_events (window, gdkdev,
 					    event_mask,
@@ -326,7 +296,7 @@ gdk_input_xfree_grab_pointer (GdkWindow *     window,
       while (tmp_list)
 	{
 	  gdkdev = (GdkDevicePrivate *)tmp_list->data;
-	  if (gdkdev->info.deviceid != GDK_CORE_POINTER && gdkdev->xdevice &&
+	  if (!GDK_IS_CORE (gdkdev) && gdkdev->xdevice &&
 	      ((gdkdev->button_state != 0) || need_ungrab))
 	    {
 	      XUngrabDevice( gdk_display, gdkdev->xdevice, time);
@@ -341,8 +311,8 @@ gdk_input_xfree_grab_pointer (GdkWindow *     window,
       
 }
 
-static void 
-gdk_input_xfree_ungrab_pointer (guint32 time)
+void 
+_gdk_input_ungrab_pointer (guint32 time)
 {
   GdkInputWindow *input_window;
   GdkDevicePrivate *gdkdev;
@@ -365,10 +335,17 @@ gdk_input_xfree_ungrab_pointer (guint32 time)
       while (tmp_list)
 	{
 	  gdkdev = (GdkDevicePrivate *)tmp_list->data;
-	  if (gdkdev->info.deviceid != GDK_CORE_POINTER && gdkdev->xdevice)
+	  if (!GDK_IS_CORE (gdkdev) && gdkdev->xdevice)
 	    XUngrabDevice( gdk_display, gdkdev->xdevice, time);
 
 	  tmp_list = tmp_list->next;
 	}
     }
 }
+
+gint 
+_gdk_input_window_none_event (GdkEvent         *event,
+			     XEvent           *xevent)
+{
+  return -1;
+}
diff --git a/gdk/x11/gdkinput.c b/gdk/x11/gdkinput.c
index 4ee51b315..d87cf05f7 100644
--- a/gdk/x11/gdkinput.c
+++ b/gdk/x11/gdkinput.c
@@ -34,22 +34,29 @@
 #include "gdkprivate.h"
 #include "gdkinputprivate.h"
 
-static const GdkAxisUse gdk_input_core_axes[] = { GDK_AXIS_X, GDK_AXIS_Y };
+static GdkDeviceAxis gdk_input_core_axes[] = {
+  { GDK_AXIS_X, 0, 0 },
+  { GDK_AXIS_Y, 0, 0 }
+};
 
-const GdkDeviceInfo gdk_input_core_info =
+static const GdkDevice gdk_input_core_info =
 {
-  GDK_CORE_POINTER,
   "Core Pointer",
   GDK_SOURCE_MOUSE,
   GDK_MODE_SCREEN,
   TRUE,
+  
   2,
-  gdk_input_core_axes
+  gdk_input_core_axes,
+
+  0,
+  NULL
 };
 
+GdkDevice *gdk_core_pointer = (GdkDevice *)&gdk_input_core_info;
+ 
 /* Global variables  */
 
-GdkInputVTable    gdk_input_vtable;
 /* information about network port and host for gxid daemon */
 gchar            *gdk_input_gxid_host;
 gint              gdk_input_gxid_port;
@@ -59,124 +66,138 @@ GList            *gdk_input_devices;
 GList            *gdk_input_windows;
 
 GList *
-gdk_input_list_devices (void)
+gdk_devices_list (void)
 {
   return gdk_input_devices;
 }
 
 void
-gdk_input_set_source (guint32 deviceid, GdkInputSource source)
+gdk_device_set_source (GdkDevice      *device,
+		       GdkInputSource  source)
 {
-  GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid);
-  g_return_if_fail (gdkdev != NULL);
+  g_return_if_fail (device != NULL);
 
-  gdkdev->info.source = source;
+  device->source = source;
 }
 
-gboolean
-gdk_input_set_mode (guint32 deviceid, GdkInputMode mode)
+void
+gdk_device_set_key (GdkDevice      *device,
+		    guint           index,
+		    guint           keyval,
+		    GdkModifierType modifiers)
 {
-  if (deviceid == GDK_CORE_POINTER)
-    return FALSE;
+  g_return_if_fail (device != NULL);
+  g_return_if_fail (index < device->num_keys);
 
-  if (gdk_input_vtable.set_mode)
-    return gdk_input_vtable.set_mode(deviceid,mode);
-  else
-    return FALSE;
+  device->keys[index].keyval = keyval;
+  device->keys[index].modifiers = modifiers;
 }
 
 void
-gdk_input_set_axes (guint32 deviceid, GdkAxisUse *axes)
+gdk_device_set_axis_use (GdkDevice   *device,
+			 guint        index,
+			 GdkAxisUse   use)
 {
-  if (deviceid != GDK_CORE_POINTER && gdk_input_vtable.set_axes)
-    gdk_input_vtable.set_axes (deviceid, axes);
-}
+  g_return_if_fail (device != NULL);
+  g_return_if_fail (index < device->num_axes);
 
-void gdk_input_set_key (guint32 deviceid,
-			guint   index,
-			guint   keyval,
-			GdkModifierType modifiers)
-{
-  if (deviceid != GDK_CORE_POINTER && gdk_input_vtable.set_key)
-    gdk_input_vtable.set_key (deviceid, index, keyval, modifiers);
+  device->axes[index].use = use;
+
+  switch (use)
+    {
+    case GDK_AXIS_X:
+    case GDK_AXIS_Y:
+      device->axes[index].min = 0.;
+      device->axes[index].max = 0.;
+      break;
+    case GDK_AXIS_XTILT:
+    case GDK_AXIS_YTILT:
+      device->axes[index].min = -1.;
+      device->axes[index].max = 1;
+      break;
+    default:
+      device->axes[index].min = 0.;
+      device->axes[index].max = 1;
+      break;
+    }
 }
 
-GdkTimeCoord *
-gdk_input_motion_events (GdkWindow *window,
-			 guint32 deviceid,
-			 guint32 start,
-			 guint32 stop,
-			 gint *nevents_return)
+gboolean
+gdk_device_get_history  (GdkDevice         *device,
+			 GdkWindow         *window,
+			 guint32            start,
+			 guint32            stop,
+			 GdkTimeCoord    ***events,
+			 gint              *n_events)
 {
-  XTimeCoord *xcoords;
-  GdkTimeCoord *coords;
+  GdkTimeCoord **coords;
   int i;
 
-  g_return_val_if_fail (window != NULL, NULL);
-  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-  
-  if (GDK_WINDOW_DESTROYED (window))
-    return NULL;
+  g_return_val_if_fail (window != NULL, FALSE);
+  g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
+  g_return_val_if_fail (events != NULL, FALSE);
+  g_return_val_if_fail (n_events != NULL, FALSE);
+
+  *n_events = 0;
+  *events = NULL;
 
-  if (deviceid == GDK_CORE_POINTER)
+  if (GDK_WINDOW_DESTROYED (window))
+    return FALSE;
+    
+  if (GDK_IS_CORE (device))
     {
+      XTimeCoord *xcoords;
+      
       xcoords = XGetMotionEvents (GDK_DRAWABLE_XDISPLAY (window),
 				  GDK_DRAWABLE_XID (window),
-				  start, stop, nevents_return);
+				  start, stop, n_events);
       if (xcoords)
 	{
-	  coords = g_new (GdkTimeCoord, *nevents_return);
-	  for (i=0; i<*nevents_return; i++)
+	  coords = _gdk_device_allocate_history (device, *n_events);
+	  for (i=0; i<*n_events; i++)
 	    {
-	      coords[i].time = xcoords[i].time;
-	      coords[i].x = xcoords[i].x;
-	      coords[i].y = xcoords[i].y;
-	      coords[i].pressure = 0.5;
-	      coords[i].xtilt = 0.0;
-	      coords[i].ytilt = 0.0;
+	      coords[i]->time = xcoords[i].time;
+	      coords[i]->axes[0] = xcoords[i].x;
+	      coords[i]->axes[1] = xcoords[i].y;
 	    }
 
 	  XFree (xcoords);
 
-	  return coords;
+	  *events = coords;
+	  return TRUE;
 	}
       else
-	return NULL;
+	return FALSE;
     }
   else
-    {
-      if (gdk_input_vtable.motion_events)
-	{
-	  return gdk_input_vtable.motion_events(window,
-						deviceid, start, stop,
-						nevents_return);
-	}
-      else
-	{
-	  *nevents_return = 0;
-	  return NULL;
-	}
-    }
+    return _gdk_device_get_history (device, window, start, stop, events, n_events);
 }
 
-gint
-gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
+GdkTimeCoord ** 
+_gdk_device_allocate_history (GdkDevice *device,
+			      gint       n_events)
 {
-  if (gdk_input_vtable.enable_window)
-    return gdk_input_vtable.enable_window (window, gdkdev);
-  else
-    return TRUE;
+  GdkTimeCoord **result = g_new (GdkTimeCoord *, n_events);
+  gint i;
+
+  for (i=0; i<n_events; i++)
+    result[i] = g_malloc (sizeof (GdkTimeCoord) -
+			  sizeof (double) * (GDK_MAX_TIMECOORD_AXES - device->num_axes));
+
+  return result;
 }
 
-gint
-gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
+void 
+gdk_device_free_history (GdkTimeCoord **events,
+			 gint           n_events)
 {
-  if (gdk_input_vtable.disable_window)
-    return gdk_input_vtable.disable_window(window,gdkdev);
-  else
-    return TRUE;
-}
+  gint i;
+  
+  for (i=0; i<n_events; i++)
+    g_free (events[i]);
 
+  g_free (events);
+}
 
 GdkInputWindow *
 gdk_input_window_find(GdkWindow *window)
@@ -248,15 +269,15 @@ gdk_input_set_extension_events (GdkWindow *window, gint mask,
 
   for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
     {
-      GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data);
+      GdkDevicePrivate *gdkdev = tmp_list->data;
 
-      if (gdkdev->info.deviceid != GDK_CORE_POINTER)
+      if (!GDK_IS_CORE (gdkdev))
 	{
 	  if (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED
 	      && (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL))
-	    gdk_input_enable_window(window,gdkdev);
+	    _gdk_input_enable_window (window,gdkdev);
 	  else
-	    gdk_input_disable_window(window,gdkdev);
+	    _gdk_input_disable_window (window,gdkdev);
 	}
     }
 }
@@ -282,9 +303,9 @@ gdk_input_exit (void)
   for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
     {
       gdkdev = (GdkDevicePrivate *)(tmp_list->data);
-      if (gdkdev->info.deviceid != GDK_CORE_POINTER)
+      if (!GDK_IS_CORE (gdkdev))
 	{
-	  gdk_input_set_mode(gdkdev->info.deviceid,GDK_MODE_DISABLED);
+	  gdk_device_set_mode (&gdkdev->info, GDK_MODE_DISABLED);
 
 	  g_free(gdkdev->info.name);
 #ifndef XINPUT_NONE	  
@@ -299,38 +320,40 @@ gdk_input_exit (void)
   g_list_free(gdk_input_devices);
 
   for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
-    {
-      g_free(tmp_list->data);
-    }
+    g_free(tmp_list->data);
+
   g_list_free(gdk_input_windows);
 }
 
-GdkDevicePrivate *
-gdk_input_find_device(guint32 id)
+/**
+ * gdk_device_get_axis:
+ * @axis: a #GdkDevice
+ * @axes: pointer to an array of axes
+ * @use: the use to look for
+ * @value: location to store the found value.
+ * 
+ * Interprets an array of double as axis values for a given device,
+ * and locates the value in the array for a given axis use.
+ * 
+ * Return value: %TRUE if the given axis use was found, otherwies %FALSE
+ **/
+gboolean
+gdk_device_get_axis (GdkDevice *device, gdouble *axes, GdkAxisUse use, gdouble *value)
 {
-  GList *tmp_list = gdk_input_devices;
-  GdkDevicePrivate *gdkdev;
-  while (tmp_list)
-    {
-      gdkdev = (GdkDevicePrivate *)(tmp_list->data);
-      if (gdkdev->info.deviceid == id)
-	return gdkdev;
-      tmp_list = tmp_list->next;
-    }
-  return NULL;
-}
+  gint i;
+  
+  g_return_val_if_fail (device != NULL, FALSE);
 
-void
-gdk_input_window_get_pointer (GdkWindow       *window,
-			      guint32	  deviceid,
-			      gdouble         *x,
-			      gdouble         *y,
-			      gdouble         *pressure,
-			      gdouble         *xtilt,
-			      gdouble         *ytilt,
-			      GdkModifierType *mask)
-{
-  if (gdk_input_vtable.get_pointer)
-    gdk_input_vtable.get_pointer (window, deviceid, x, y, pressure,
-				  xtilt, ytilt, mask);
+  if (axes == NULL)
+    return FALSE;
+  
+  for (i=0; i<device->num_axes; i++)
+    if (device->axes[i].use == use)
+      {
+	if (value)
+	  *value = axes[i];
+	return TRUE;
+      }
+  
+  return FALSE;
 }
diff --git a/gdk/x11/gdkinputprivate.h b/gdk/x11/gdkinputprivate.h
index 552bd1b03..be680d0df 100644
--- a/gdk/x11/gdkinputprivate.h
+++ b/gdk/x11/gdkinputprivate.h
@@ -39,48 +39,9 @@
 #endif
 
 typedef struct _GdkAxisInfo    GdkAxisInfo;
-typedef struct _GdkInputVTable GdkInputVTable;
 typedef struct _GdkDevicePrivate GdkDevicePrivate;
 typedef struct _GdkInputWindow GdkInputWindow;
 
-struct _GdkInputVTable {
-  gint (*set_mode) (guint32 deviceid, GdkInputMode mode);
-  void (*set_axes) (guint32 deviceid, GdkAxisUse *axes);
-  void (*set_key)  (guint32 deviceid,
-		    guint   index,
-		    guint   keyval,
-		    GdkModifierType modifiers);
-	
-  GdkTimeCoord* (*motion_events) (GdkWindow *window,
-				  guint32 deviceid,
-				  guint32 start,
-				  guint32 stop,
-				  gint *nevents_return);
-  void (*get_pointer)   (GdkWindow       *window,
-			 guint32	  deviceid,
-			 gdouble         *x,
-			 gdouble         *y,
-			 gdouble         *pressure,
-			 gdouble         *xtilt,
-			 gdouble         *ytilt,
-			 GdkModifierType *mask);
-  gint (*grab_pointer) (GdkWindow *     window,
-			gint            owner_events,
-			GdkEventMask    event_mask,
-			GdkWindow *     confine_to,
-			guint32         time);
-  void (*ungrab_pointer) (guint32 time);
-
-  void (*configure_event) (XConfigureEvent *xevent, GdkWindow *window);
-  void (*enter_event) (XCrossingEvent *xevent, GdkWindow *window);
-  gint (*other_event) (GdkEvent *event, XEvent *xevent, GdkWindow *window);
-  /* Handle an unidentified event. Returns TRUE if handled, FALSE
-     otherwise */
-  gint (*window_none_event) (GdkEvent *event, XEvent *xevent);
-  gint (*enable_window) (GdkWindow *window, GdkDevicePrivate *gdkdev);
-  gint (*disable_window) (GdkWindow *window, GdkDevicePrivate *gdkdev);
-};
-
 /* information about a device axis */
 struct _GdkAxisInfo
 {
@@ -100,16 +61,17 @@ struct _GdkAxisInfo
 
 #define GDK_INPUT_NUM_EVENTC 6
 
-struct _GdkDevicePrivate {
-  GdkDeviceInfo  info;
+struct _GdkDevicePrivate
+{
+  GdkDevice info;
+
+  guint32 deviceid;
+  
 
 #ifndef XINPUT_NONE
   /* information about the axes */
   GdkAxisInfo *axes;
 
-  /* reverse lookup on axis use type */
-  gint axis_for_use[GDK_AXIS_LAST];
-  
   /* Information about XInput device */
   XDevice       *xdevice;
 
@@ -154,11 +116,11 @@ struct _GdkInputWindow
 
 /* Global data */
 
-extern const GdkDeviceInfo gdk_input_core_info;
+#define GDK_IS_CORE(d) (((GdkDevice *)(d)) == gdk_core_pointer)
+
 extern GList *gdk_input_devices;
 extern GList *gdk_input_windows;
 
-extern GdkInputVTable gdk_input_vtable;
 /* information about network port and host for gxid daemon */
 extern gchar           *gdk_input_gxid_host;
 extern gint             gdk_input_gxid_port;
@@ -166,63 +128,64 @@ extern gint             gdk_input_ignore_core;
 
 /* Function declarations */
 
-GdkDevicePrivate * gdk_input_find_device    (guint32           id);
-GdkInputWindow *   gdk_input_window_find    (GdkWindow        *window);
-void               gdk_input_window_destroy (GdkWindow        *window);
-void               gdk_input_init           (void);
-void               gdk_input_exit           (void);
-gint               gdk_input_enable_window  (GdkWindow        *window,
-					     GdkDevicePrivate *gdkdev);
-gint               gdk_input_disable_window (GdkWindow        *window,
-					     GdkDevicePrivate *gdkdev);
+GdkInputWindow *gdk_input_window_find        (GdkWindow *window);
+void            gdk_input_window_destroy     (GdkWindow *window);
+GdkTimeCoord ** _gdk_device_allocate_history (GdkDevice *device,
+					      gint       n_events);
+
+/* The following functions are provided by each implementation
+ * (xfree, gxi, and none)
+ */
+gint             _gdk_input_enable_window     (GdkWindow        *window,
+					      GdkDevicePrivate *gdkdev);
+gint             _gdk_input_disable_window    (GdkWindow        *window,
+					      GdkDevicePrivate *gdkdev);
+gint             _gdk_input_window_none_event (GdkEvent         *event,
+					      XEvent           *xevent);
+void             _gdk_input_configure_event  (XConfigureEvent  *xevent,
+					      GdkWindow        *window);
+void             _gdk_input_enter_event      (XCrossingEvent   *xevent,
+					      GdkWindow        *window);
+gint             _gdk_input_other_event      (GdkEvent         *event,
+					      XEvent           *xevent,
+					      GdkWindow        *window);
+gint             _gdk_input_grab_pointer     (GdkWindow        *window,
+					      gint              owner_events,
+					      GdkEventMask      event_mask,
+					      GdkWindow        *confine_to,
+					      guint32           time);
+void             _gdk_input_ungrab_pointer   (guint32           time);
+gboolean         _gdk_device_get_history     (GdkDevice         *device,
+					      GdkWindow         *window,
+					      guint32            start,
+					      guint32            stop,
+					      GdkTimeCoord    ***events,
+					      gint              *n_events);
 
 #ifndef XINPUT_NONE
 
 #define GDK_MAX_DEVICE_CLASSES 13
 
-gint           gdk_input_common_init                (gint              include_core);
-void           gdk_input_get_root_relative_geometry (Display          *dpy,
-						     Window            w,
-						     int              *x_ret,
-						     int              *y_ret,
-						     int              *width_ret,
-						     int              *height_ret);
-void           gdk_input_common_find_events         (GdkWindow        *window,
-						     GdkDevicePrivate *gdkdev,
-						     gint              mask,
-						     XEventClass      *classes,
-						     int              *num_classes);
-void           gdk_input_common_select_events       (GdkWindow        *window,
-						     GdkDevicePrivate *gdkdev);
-gint           gdk_input_common_other_event         (GdkEvent         *event,
-						     XEvent           *xevent,
-						     GdkInputWindow   *input_window,
-						     GdkDevicePrivate *gdkdev);
-void           gdk_input_common_get_pointer         (GdkWindow        *window,
-						     guint32           deviceid,
-						     gdouble          *x,
-						     gdouble          *y,
-						     gdouble          *pressure,
-						     gdouble          *xtilt,
-						     gdouble          *ytilt,
-						     GdkModifierType  *mask);
-void           gdk_input_common_set_key             (guint32           deviceid,
-						     guint             index,
-						     guint             keyval,
-						     GdkModifierType   modifiers);
-void           gdk_input_common_set_axes            (guint32           deviceid,
-						     GdkAxisUse       *axes);
-GdkTimeCoord * gdk_input_common_motion_events       (GdkWindow        *window,
-						     guint32           deviceid,
-						     guint32           start,
-						     guint32           stop,
-						     gint             *nevents_return);
+gint               gdk_input_common_init                (gint              include_core);
+GdkDevicePrivate * gdk_input_find_device                (guint32           id);
+void               gdk_input_get_root_relative_geometry (Display          *dpy,
+							 Window            w,
+							 int              *x_ret,
+							 int              *y_ret,
+							 int              *width_ret,
+							 int              *height_ret);
+void               gdk_input_common_find_events         (GdkWindow        *window,
+							 GdkDevicePrivate *gdkdev,
+							 gint              mask,
+							 XEventClass      *classes,
+							 int              *num_classes);
+void               gdk_input_common_select_events       (GdkWindow        *window,
+							 GdkDevicePrivate *gdkdev);
+gint               gdk_input_common_other_event         (GdkEvent         *event,
+							 XEvent           *xevent,
+							 GdkInputWindow   *input_window,
+							 GdkDevicePrivate *gdkdev);
 
 #endif /* !XINPUT_NONE */
 
-GdkDevicePrivate *gdk_input_find_device (guint32 id);
-GdkInputWindow *gdk_input_window_find (GdkWindow *window);
-void gdk_input_window_destroy (GdkWindow *window);
-void gdk_input_exit           (void);
-
 #endif /* __GDK_INPUTPRIVATE_H__ */
diff --git a/gdk/x11/gdkmain-x11.c b/gdk/x11/gdkmain-x11.c
index b266a67e2..7b48264b6 100644
--- a/gdk/x11/gdkmain-x11.c
+++ b/gdk/x11/gdkmain-x11.c
@@ -267,15 +267,12 @@ gdk_pointer_grab (GdkWindow *	  window,
 	xevent_mask |= gdk_event_mask_table[i];
     }
   
-  if (gdk_input_vtable.grab_pointer)
-    return_val = gdk_input_vtable.grab_pointer (window,
-						owner_events,
-						event_mask,
-						confine_to,
-						time);
-  else
-    return_val = Success;
-  
+  return_val = _gdk_input_grab_pointer (window,
+					owner_events,
+					event_mask,
+					confine_to,
+					time);
+
   if (return_val == Success)
     {
       if (!GDK_WINDOW_DESTROYED (window))
@@ -315,8 +312,7 @@ gdk_pointer_grab (GdkWindow *	  window,
 void
 gdk_pointer_ungrab (guint32 time)
 {
-  if (gdk_input_vtable.ungrab_pointer)
-    gdk_input_vtable.ungrab_pointer (time);
+  _gdk_input_ungrab_pointer (time);
   
   XUngrabPointer (gdk_display, time);
   gdk_xgrab_window = NULL;