* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
- * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#include "config.h"
+
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
-#include "config.h"
#include "gdkx.h"
#include "gdkinput.h"
#include "gdkprivate.h"
#include "gdkinputprivate.h"
+#include "gdkscreen-x11.h"
+#include "gdkdisplay-x11.h"
+#include "gdkalias.h"
+
+static GdkDeviceAxis gdk_input_core_axes[] = {
+ { GDK_AXIS_X, 0, 0 },
+ { GDK_AXIS_Y, 0, 0 }
+};
-/* Forward declarations */
+void
+_gdk_init_input_core (GdkDisplay *display)
+{
+ GdkDevicePrivate *private;
-static gint gdk_input_enable_window (GdkWindow *window,
- GdkDevicePrivate *gdkdev);
-static gint gdk_input_disable_window (GdkWindow *window,
- GdkDevicePrivate *gdkdev);
-static GdkInputWindow *gdk_input_window_find (GdkWindow *window);
-static GdkDevicePrivate *gdk_input_find_device (guint32 id);
+ display->core_pointer = g_object_new (GDK_TYPE_DEVICE, NULL);
+ private = (GdkDevicePrivate *)display->core_pointer;
+ display->core_pointer->name = "Core Pointer";
+ display->core_pointer->source = GDK_SOURCE_MOUSE;
+ display->core_pointer->mode = GDK_MODE_SCREEN;
+ display->core_pointer->has_cursor = TRUE;
+ display->core_pointer->num_axes = 2;
+ display->core_pointer->axes = gdk_input_core_axes;
+ display->core_pointer->num_keys = 0;
+ display->core_pointer->keys = NULL;
-/* Incorporate the specific routines depending on compilation options */
+ private->display = display;
+}
-static const GdkAxisUse gdk_input_core_axes[] = { GDK_AXIS_X, GDK_AXIS_Y };
+static void gdk_device_class_init (GdkDeviceClass *klass);
+static void gdk_device_dispose (GObject *object);
-static const GdkDeviceInfo gdk_input_core_info =
+static gpointer gdk_device_parent_class = NULL;
+
+GType
+gdk_device_get_type (void)
{
- GDK_CORE_POINTER,
- "Core Pointer",
- GDK_SOURCE_MOUSE,
- GDK_MODE_SCREEN,
- TRUE,
- 2,
- gdk_input_core_axes
-};
+ static GType object_type = 0;
-/* Global variables */
+ if (!object_type)
+ {
+ const GTypeInfo object_info =
+ {
+ sizeof (GdkDeviceClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_device_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkDevicePrivate),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) NULL,
+ };
+
+ object_type = g_type_register_static (G_TYPE_OBJECT,
+ g_intern_static_string ("GdkDevice"),
+ &object_info, 0);
+ }
-GdkInputVTable gdk_input_vtable;
-/* information about network port and host for gxid daemon */
-gchar *gdk_input_gxid_host;
-gint gdk_input_gxid_port;
-gint gdk_input_ignore_core;
+ return object_type;
+}
-/* Local variables */
+static void
+gdk_device_class_init (GdkDeviceClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
-static GList *gdk_input_devices;
-static GList *gdk_input_windows;
+ gdk_device_parent_class = g_type_class_peek_parent (klass);
-#include "gdkinputnone.h"
-#include "gdkinputcommon.h"
-#include "gdkinputxfree.h"
-#include "gdkinputgxi.h"
+ object_class->dispose = gdk_device_dispose;
+}
+
+static void
+gdk_device_dispose (GObject *object)
+{
+ GdkDevicePrivate *gdkdev = (GdkDevicePrivate *) object;
+
+ if (gdkdev->display && !GDK_IS_CORE (gdkdev))
+ {
+#ifndef XINPUT_NONE
+ if (gdkdev->xdevice)
+ {
+ XCloseDevice (GDK_DISPLAY_XDISPLAY (gdkdev->display), gdkdev->xdevice);
+ gdkdev->xdevice = NULL;
+ }
+ g_free (gdkdev->axes);
+ g_free (gdkdev->axis_data);
+ gdkdev->axes = NULL;
+ gdkdev->axis_data = NULL;
+#endif /* !XINPUT_NONE */
+
+ g_free (gdkdev->info.name);
+ g_free (gdkdev->info.keys);
+ g_free (gdkdev->info.axes);
+
+ gdkdev->info.name = NULL;
+ gdkdev->info.keys = NULL;
+ gdkdev->info.axes = NULL;
+ }
+
+ G_OBJECT_CLASS (gdk_device_parent_class)->dispose (object);
+}
+
+/**
+ * gdk_devices_list:
+ *
+ * Returns the list of available input devices for the default display.
+ * The list is statically allocated and should not be freed.
+ *
+ * Return value: a list of #GdkDevice
+ **/
+GList *
+gdk_devices_list (void)
+{
+ return gdk_display_list_devices (gdk_display_get_default ());
+}
+/**
+ * gdk_display_list_devices:
+ * @display: a #GdkDisplay
+ *
+ * Returns the list of available input devices attached to @display.
+ * The list is statically allocated and should not be freed.
+ *
+ * Return value: a list of #GdkDevice
+ *
+ * Since: 2.2
+ **/
GList *
-gdk_input_list_devices (void)
+gdk_display_list_devices (GdkDisplay *display)
{
- return gdk_input_devices;
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+ return GDK_DISPLAY_X11 (display)->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;
}
-gint
-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);
+
+ 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;
+ }
}
-void gdk_input_set_key (guint32 deviceid,
- guint index,
- guint keyval,
- GdkModifierType modifiers)
+static gboolean
+impl_coord_in_window (GdkWindow *window,
+ int impl_x,
+ int impl_y)
{
- if (deviceid != GDK_CORE_POINTER && gdk_input_vtable.set_key)
- gdk_input_vtable.set_key (deviceid, index, keyval, modifiers);
+ GdkWindowObject *priv = (GdkWindowObject *)window;
+
+ if (impl_x < priv->abs_x ||
+ impl_x > priv->abs_x + priv->width)
+ return FALSE;
+ if (impl_y < priv->abs_y ||
+ impl_y > priv->abs_y + priv->height)
+ return FALSE;
+ return TRUE;
}
-GdkTimeCoord *
-gdk_input_motion_events (GdkWindow *window,
- guint32 deviceid,
- guint32 start,
- guint32 stop,
- gint *nevents_return)
+/**
+ * gdk_device_get_history:
+ * @device: a #GdkDevice
+ * @window: the window with respect to which which the event coordinates will be reported
+ * @start: starting timestamp for range of events to return
+ * @stop: ending timestamp for the range of events to return
+ * @events: (array length=n_events) (out) (transfer none): location to store a newly-allocated array of #GdkTimeCoord, or %NULL
+ * @n_events: location to store the length of @events, or %NULL
+ *
+ * Obtains the motion history for a device; given a starting and
+ * ending timestamp, return all events in the motion history for
+ * the device in the given range of time. Some windowing systems
+ * do not support motion history, in which case, %FALSE will
+ * be returned. (This is not distinguishable from the case where
+ * motion history is supported and no events were found.)
+ *
+ * Return value: %TRUE if the windowing system supports motion history and
+ * at least one event was found.
+ **/
+gboolean
+gdk_device_get_history (GdkDevice *device,
+ GdkWindow *window,
+ guint32 start,
+ guint32 stop,
+ GdkTimeCoord ***events,
+ gint *n_events)
{
- XTimeCoord *xcoords;
- GdkTimeCoord *coords;
- int i;
+ GdkTimeCoord **coords = NULL;
+ GdkWindow *impl_window;
+ gboolean result = FALSE;
+ int tmp_n_events = 0;
- g_return_val_if_fail (window != NULL, NULL);
- g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-
- if (GDK_DRAWABLE_DESTROYED (window))
- return NULL;
+ g_return_val_if_fail (GDK_WINDOW_IS_X11 (window), FALSE);
- if (deviceid == GDK_CORE_POINTER)
+ impl_window = _gdk_window_get_impl_window (window);
+
+ if (GDK_WINDOW_DESTROYED (window))
+ /* Nothing */ ;
+ else if (GDK_IS_CORE (device))
{
+ XTimeCoord *xcoords;
+
xcoords = XGetMotionEvents (GDK_DRAWABLE_XDISPLAY (window),
- GDK_DRAWABLE_XID (window),
- start, stop, nevents_return);
+ GDK_DRAWABLE_XID (impl_window),
+ start, stop, &tmp_n_events);
if (xcoords)
{
- coords = g_new (GdkTimeCoord, *nevents_return);
- for (i=0; i<*nevents_return; i++)
+ GdkWindowObject *priv = (GdkWindowObject *)window;
+ int i, j;
+
+ coords = _gdk_device_allocate_history (device, tmp_n_events);
+ j = 0;
+
+ for (i = 0; i < tmp_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;
+ if (impl_coord_in_window (window, xcoords[i].x, xcoords[i].y))
+ {
+ coords[j]->time = xcoords[i].time;
+ coords[j]->axes[0] = xcoords[i].x - priv->abs_x;
+ coords[j]->axes[1] = xcoords[i].y - priv->abs_y;
+ j++;
+ }
}
XFree (xcoords);
- return coords;
+ /* free the events we allocated too much */
+ for (i = j; i < tmp_n_events; i++)
+ {
+ g_free (coords[i]);
+ coords[i] = NULL;
+ }
+
+ tmp_n_events = j;
+
+ if (tmp_n_events > 0)
+ {
+ result = TRUE;
+ }
+ else
+ {
+ gdk_device_free_history (coords, tmp_n_events);
+ coords = NULL;
+ }
}
- else
- return NULL;
}
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;
- }
- }
+ result = _gdk_device_get_history (device, window, start, stop, &coords, &tmp_n_events);
+
+ if (n_events)
+ *n_events = tmp_n_events;
+
+ if (events)
+ *events = coords;
+ else if (coords)
+ gdk_device_free_history (coords, tmp_n_events);
+
+ return result;
}
-static 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;
}
-static gint
-gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
+/**
+ * gdk_device_free_history:
+ * @events: (inout) (transfer none): an array of #GdkTimeCoord.
+ * @n_events: the length of the array.
+ *
+ * Frees an array of #GdkTimeCoord that was returned by gdk_device_get_history().
+ */
+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]);
-static GdkInputWindow *
-gdk_input_window_find(GdkWindow *window)
+ g_free (events);
+}
+
+static void
+unset_extension_events (GdkWindow *window)
{
- GList *tmp_list;
+ GdkWindowObject *window_private;
+ GdkWindowObject *impl_window;
+ GdkDisplayX11 *display_x11;
+ GdkInputWindow *iw;
- for (tmp_list=gdk_input_windows; tmp_list; tmp_list=tmp_list->next)
- if (((GdkInputWindow *)(tmp_list->data))->window == window)
- return (GdkInputWindow *)(tmp_list->data);
+ window_private = (GdkWindowObject*) window;
+ impl_window = (GdkWindowObject *)_gdk_window_get_impl_window (window);
+ iw = impl_window->input_window;
- return NULL; /* Not found */
-}
+ display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (window));
+
+ if (window_private->extension_events != 0)
+ {
+ g_assert (iw != NULL);
+ g_assert (g_list_find (iw->windows, window) != NULL);
+
+ iw->windows = g_list_remove (iw->windows, window);
+ if (iw->windows == NULL)
+ {
+ impl_window->input_window = NULL;
+ display_x11->input_windows = g_list_remove (display_x11->input_windows, iw);
+ g_free (iw);
+ }
+ }
-/* FIXME: this routine currently needs to be called between creation
- and the corresponding configure event (because it doesn't get the
- root_relative_geometry). This should work with
- gtk_window_set_extension_events, but will likely fail in other
- cases */
+ window_private->extension_events = 0;
+}
void
gdk_input_set_extension_events (GdkWindow *window, gint mask,
GdkExtensionMode mode)
{
- GdkWindowPrivate *window_private;
- GList *tmp_list;
+ GdkWindowObject *window_private;
+ GdkWindowObject *impl_window;
GdkInputWindow *iw;
+ GdkDisplayX11 *display_x11;
+#ifndef XINPUT_NONE
+ GList *tmp_list;
+#endif
g_return_if_fail (window != NULL);
- g_return_if_fail (GDK_IS_WINDOW (window));
+ g_return_if_fail (GDK_WINDOW_IS_X11 (window));
- window_private = (GdkWindowPrivate*) window;
- if (GDK_DRAWABLE_DESTROYED (window))
+ window_private = (GdkWindowObject*) window;
+ display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (window));
+ if (GDK_WINDOW_DESTROYED (window))
return;
+ impl_window = (GdkWindowObject *)_gdk_window_get_impl_window (window);
+
+ if (mode == GDK_EXTENSION_EVENTS_ALL && mask != 0)
+ mask |= GDK_ALL_DEVICES_MASK;
+
if (mode == GDK_EXTENSION_EVENTS_NONE)
mask = 0;
+ iw = impl_window->input_window;
+
if (mask != 0)
{
- iw = g_new(GdkInputWindow,1);
+ if (!iw)
+ {
+ iw = g_new0 (GdkInputWindow,1);
- iw->window = window;
- iw->mode = mode;
+ iw->impl_window = (GdkWindow *)impl_window;
- iw->obscuring = NULL;
- iw->num_obscuring = 0;
- iw->grabbed = FALSE;
+ iw->windows = NULL;
+ iw->grabbed = FALSE;
- gdk_input_windows = g_list_append(gdk_input_windows,iw);
- window_private->extension_events = mask;
+ display_x11->input_windows = g_list_append (display_x11->input_windows, iw);
+
+#ifndef XINPUT_NONE
+ /* we might not receive ConfigureNotify so get the root_relative_geometry
+ * now, just in case */
+ _gdk_input_get_root_relative_geometry (window, &iw->root_x, &iw->root_y);
+#endif /* !XINPUT_NONE */
+ impl_window->input_window = iw;
+ }
- /* Add enter window events to the event mask */
- /* FIXME, this is not needed for XINPUT_NONE */
- gdk_window_set_events (window,
- gdk_window_get_events (window) |
- GDK_ENTER_NOTIFY_MASK);
+ if (window_private->extension_events == 0)
+ iw->windows = g_list_append (iw->windows, window);
+ window_private->extension_events = mask;
}
else
{
- iw = gdk_input_window_find (window);
- if (iw)
- {
- gdk_input_windows = g_list_remove(gdk_input_windows,iw);
- g_free(iw);
- }
-
- window_private->extension_events = 0;
+ unset_extension_events (window);
}
- for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
+#ifndef XINPUT_NONE
+ for (tmp_list = display_x11->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 (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED
- && (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL))
- gdk_input_enable_window(window,gdkdev);
- else
- gdk_input_disable_window(window,gdkdev);
- }
+ if (!GDK_IS_CORE (gdkdev))
+ _gdk_input_select_events ((GdkWindow *)impl_window, gdkdev);
}
+#endif /* !XINPUT_NONE */
}
void
-gdk_input_window_destroy (GdkWindow *window)
+_gdk_input_window_destroy (GdkWindow *window)
{
- GdkInputWindow *input_window;
-
- input_window = gdk_input_window_find (window);
- g_return_if_fail (input_window != NULL);
-
- gdk_input_windows = g_list_remove (gdk_input_windows,input_window);
- g_free(input_window);
+ unset_extension_events (window);
}
-void
-gdk_input_exit (void)
+/**
+ * gdk_device_get_axis:
+ * @device: 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, otherwise %FALSE
+ **/
+gboolean
+gdk_device_get_axis (GdkDevice *device,
+ gdouble *axes,
+ GdkAxisUse use,
+ gdouble *value)
{
- GList *tmp_list;
- GdkDevicePrivate *gdkdev;
+ gint i;
- 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)
- {
- gdk_input_set_mode(gdkdev->info.deviceid,GDK_MODE_DISABLED);
-
- g_free(gdkdev->info.name);
-#ifndef XINPUT_NONE
- g_free(gdkdev->axes);
-#endif
- g_free(gdkdev->info.axes);
- g_free(gdkdev->info.keys);
- g_free(gdkdev);
- }
- }
+ g_return_val_if_fail (device != NULL, FALSE);
- g_list_free(gdk_input_devices);
+ if (axes == NULL)
+ return FALSE;
- for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
- {
- g_free(tmp_list->data);
- }
- g_list_free(gdk_input_windows);
-}
+ for (i=0; i<device->num_axes; i++)
+ if (device->axes[i].use == use)
+ {
+ if (value)
+ *value = axes[i];
+ return TRUE;
+ }
-static 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->info.deviceid == id)
- return gdkdev;
- tmp_list = tmp_list->next;
- }
- return NULL;
+ return 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);
-}
+#define __GDK_INPUT_C__
+#include "gdkaliasdef.c"
projects / ~andy / gtk / blobdiff