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.

1 files changed, 138 insertions, 115 deletions

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;
 }