* 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
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * 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.
*/
-#if defined(XINPUT_GXI) || defined(XINPUT_XFREE)
+/*
+ * 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/.
+ */
+
+#include "gdkinputprivate.h"
+#include "gdkinternals.h"
+#include "gdkx.h"
+#include "gdk.h" /* For gdk_error_trap_push()/pop() */
+#include "gdkdisplay-x11.h"
+
+#include <string.h>
/* Forward declarations */
-static void gdk_input_get_root_relative_geometry (Display *dpy, Window w,
- int *x_ret, int *y_ret,
- int *width_ret,
- int *height_ret);
-static GdkDevicePrivate *gdk_input_device_new(XDeviceInfo *device,
- gint include_core);
-static void gdk_input_common_find_events(GdkWindow *window,
- GdkDevicePrivate *gdkdev,
- gint mask,
- XEventClass *classes,
- int *num_classes);
-static void gdk_input_common_select_events(GdkWindow *window,
- GdkDevicePrivate *gdkdev);
-static void gdk_input_translate_coordinates(GdkDevicePrivate *gdkdev,
- GdkInputWindow *input_window,
- gint *axis_data,
- gdouble *x, gdouble *y,
- gdouble *pressure,
- gdouble *xtilt, gdouble *ytilt);
-static guint gdk_input_translate_state(guint state, guint device_state);
-static gint gdk_input_common_init(gint include_core);
-static gint gdk_input_common_other_event (GdkEvent *event,
- XEvent *xevent,
- GdkInputWindow *input_window,
- GdkDevicePrivate *gdkdev);
-static void gdk_input_common_set_axes (guint32 deviceid, GdkAxisUse *axes);
-static GdkTimeCoord * gdk_input_common_motion_events (GdkWindow *window,
- guint32 deviceid,
- guint32 start,
- guint32 stop,
- gint *nevents_return);
-static void gdk_input_common_get_pointer (GdkWindow *window,
- guint32 deviceid,
- gdouble *x,
- gdouble *y,
- gdouble *pressure,
- gdouble *xtilt,
- gdouble *ytilt,
- GdkModifierType *mask);
-
-#define GDK_MAX_DEVICE_CLASSES 13
-
-/* Global variables */
-
-static gint gdk_input_root_width;
-static gint gdk_input_root_height;
+static GdkDevicePrivate *gdk_input_device_new (GdkDisplay *display,
+ XDeviceInfo *device,
+ gint include_core);
+static void gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
+ 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);
+
+GdkDevicePrivate *
+_gdk_input_find_device (GdkDisplay *display,
+ guint32 id)
+{
+ GList *tmp_list = GDK_DISPLAY_X11 (display)->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;
+}
-static 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_get_root_relative_geometry(Display *display, Window w, int *x_ret, int *y_ret,
+ int *width_ret, int *height_ret)
{
- Window root,parent;
+ Window root, parent, child;
Window *children;
- int nchildren;
- int x,y,width,height;
- int xc,yc,widthc,heightc,border_widthc,depthc;
+ guint nchildren;
+ gint x,y;
+ guint width, height;
+ guint border_widthc, depthc;
+
+ XQueryTree (display, 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 (display, w, &root, &x, &y, &width, &height, &border_widthc, &depthc);
+ XTranslateCoordinates (display, w, root, 0, 0, &x, &y, &child);
+
if (x_ret)
*x_ret = x;
if (y_ret)
}
static GdkDevicePrivate *
-gdk_input_device_new(XDeviceInfo *device, gint include_core)
+gdk_input_device_new (GdkDisplay *display,
+ 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 = g_object_new (GDK_TYPE_DEVICE, NULL);
+
+ gdkdev->deviceid = device->id;
+ gdkdev->display = display;
+
+ 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;
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_ascii_strdown (gdkdev->info.name, -1);
if (!strcmp (tmp_name, "pointer"))
gdkdev->info.source = GDK_SOURCE_MOUSE;
gdkdev->info.num_axes = 0;
gdkdev->info.num_keys = 0;
+ gdkdev->info.axes = NULL;
gdkdev->info.keys = NULL;
gdkdev->axes = 0;
gdkdev->info.has_cursor = 0;
{
switch (class->class) {
case ButtonClass:
- {
- break;
- }
+ break;
case KeyClass:
{
XKeyInfo *xki = (XKeyInfo *)class;
if ((xki->min_keycode == 8) && (xki->max_keycode == 32))
{
gdkdev->info.num_keys = 32;
- gdkdev->min_keycode = 0;
+ gdkdev->min_keycode = 1;
}
else
{
{
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 =
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;
}
/* 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);
- g_free(gdkdev);
- return NULL;
- }
+ goto error;
if (device->use != IsXPointer)
- gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->info.deviceid);
+ {
+ gdk_error_trap_push ();
+ gdkdev->xdevice = XOpenDevice (GDK_DISPLAY_XDISPLAY (display),
+ gdkdev->deviceid);
+
+ /* return NULL if device is not ready */
+ if (gdk_error_trap_pop ())
+ goto error;
+ }
gdkdev->buttonpress_type = 0;
gdkdev->buttonrelease_type = 0;
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_object_unref (gdkdev);
+
+ return NULL;
}
-static void
-gdk_input_common_find_events(GdkWindow *window,
- GdkDevicePrivate *gdkdev,
- gint mask,
- XEventClass *classes,
- int *num_classes)
+void
+_gdk_input_common_find_events(GdkWindow *window,
+ GdkDevicePrivate *gdkdev,
+ gint mask,
+ XEventClass *classes,
+ int *num_classes)
{
gint i;
XEventClass class;
i = 0;
- /* We have to track press and release events in pairs to keep
- track of button state correctly and implement grabbing for
- the gxi support */
if (mask & GDK_BUTTON_PRESS_MASK || mask & GDK_BUTTON_RELEASE_MASK)
{
DeviceButtonPress (gdkdev->xdevice, gdkdev->buttonpress_type,
DeviceButtonPressGrab (gdkdev->xdevice, 0, class);
if (class != 0)
classes[i++] = class;
- DeviceButtonRelease (gdkdev->xdevice, gdkdev->buttonrelease_type,
- class);
- if (class != 0)
- classes[i++] = class;
}
if (mask & GDK_POINTER_MOTION_MASK)
{
*num_classes = i;
}
-static void
-gdk_input_common_select_events(GdkWindow *window,
- GdkDevicePrivate *gdkdev)
+void
+_gdk_input_common_select_events(GdkWindow *window,
+ GdkDevicePrivate *gdkdev)
{
XEventClass classes[GDK_MAX_DEVICE_CLASSES];
gint num_classes;
if (gdkdev->info.mode == GDK_MODE_DISABLED)
- gdk_input_common_find_events(window, gdkdev, 0, classes, &num_classes);
+ _gdk_input_common_find_events(window, gdkdev, 0, classes, &num_classes);
else
- gdk_input_common_find_events(window, gdkdev,
- ((GdkWindowPrivate *)window)->extension_events,
- classes, &num_classes);
+ _gdk_input_common_find_events(window, gdkdev,
+ ((GdkWindowObject *)window)->extension_events,
+ classes, &num_classes);
- XSelectExtensionEvent (gdk_display,
- GDK_WINDOW_XWINDOW(window),
+ XSelectExtensionEvent (GDK_WINDOW_XDISPLAY (window),
+ GDK_WINDOW_XWINDOW (window),
classes, num_classes);
}
gint
-gdk_input_common_init(gint include_core)
+_gdk_input_common_init (GdkDisplay *display,
+ gint include_core)
{
char **extensions;
XDeviceInfo *devices;
int num_devices;
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);
+ GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
/* Init XInput extension */
- extensions = XListExtensions(display, &num_extensions);
+ extensions = XListExtensions(display_x11->xdisplay, &num_extensions);
for (loop = 0; loop < num_extensions &&
(strcmp(extensions[loop], "XInputExtension") != 0); loop++);
XFreeExtensionList(extensions);
- if (loop == num_extensions) /* XInput extension not found */
- return FALSE;
+ display_x11->input_devices = NULL;
+ if (loop < num_extensions)
+ {
+ /* XInput extension found */
- gdk_input_devices = 0;
- devices = XListInputDevices(display, &num_devices);
+ devices = XListInputDevices(display_x11->xdisplay, &num_devices);
- for(loop=0; loop<num_devices; loop++)
- {
- GdkDevicePrivate *gdkdev = gdk_input_device_new(&devices[loop],
- include_core);
- if (gdkdev)
- gdk_input_devices = g_list_append(gdk_input_devices, gdkdev);
+ for(loop=0; loop<num_devices; loop++)
+ {
+ GdkDevicePrivate *gdkdev = gdk_input_device_new(display,
+ &devices[loop],
+ include_core);
+ if (gdkdev)
+ display_x11->input_devices = g_list_append(display_x11->input_devices, gdkdev);
+ }
+ XFreeDeviceList(devices);
}
- XFreeDeviceList(devices);
- gdk_input_devices = g_list_append (gdk_input_devices, &gdk_input_core_info);
+ display_x11->input_devices = g_list_append (display_x11->input_devices, display->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)
{
- GdkWindowPrivate *win_priv;
-
- int x_axis, y_axis, pressure_axis, xtilt_axis, ytilt_axis;
+ GdkWindowImplX11 *impl;
+ int i;
+ int x_axis = 0;
+ int y_axis = 0;
double device_width, device_height;
double x_offset, y_offset, x_scale, y_scale;
- win_priv = (GdkWindowPrivate *) input_window->window;
-
- 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];
+ impl = GDK_WINDOW_IMPL_X11 (((GdkWindowObject *) input_window->window)->impl);
+ 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 -
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_get_width (gdk_drawable_get_screen (input_window->window)) / device_width;
+ y_scale = gdk_screen_get_height (gdk_drawable_get_screen (input_window->window)) / device_height;
x_offset = - input_window->root_x;
y_offset = - input_window->root_y;
double device_aspect = (device_height*gdkdev->axes[y_axis].resolution) /
(device_width*gdkdev->axes[x_axis].resolution);
- if (device_aspect * win_priv->width >= win_priv->height)
+ if (device_aspect * impl->width >= impl->height)
{
/* device taller than window */
- x_scale = win_priv->width / device_width;
+ x_scale = impl->width / device_width;
y_scale = (x_scale * gdkdev->axes[x_axis].resolution)
/ gdkdev->axes[y_axis].resolution;
x_offset = 0;
y_offset = -(device_height * y_scale -
- win_priv->height)/2;
+ impl->height)/2;
}
else
{
/* window taller than device */
- y_scale = win_priv->height / device_height;
+ y_scale = impl->height / device_height;
x_scale = (y_scale * gdkdev->axes[y_axis].resolution)
/ gdkdev->axes[x_axis].resolution;
y_offset = 0;
- x_offset = - (device_width * x_scale - win_priv->width)/2;
+ 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)
{
return device_state | (state & 0xFF);
}
-static gint
-gdk_input_common_other_event (GdkEvent *event,
- XEvent *xevent,
- GdkInputWindow *input_window,
- GdkDevicePrivate *gdkdev)
+
+gint
+_gdk_input_common_other_event (GdkEvent *event,
+ XEvent *xevent,
+ GdkInputWindow *input_window,
+ GdkDevicePrivate *gdkdev)
{
if ((xevent->type == gdkdev->buttonpress_type) ||
(xevent->type == gdkdev->buttonrelease_type))
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;
{
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",
{
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;
}
return -1; /* wasn't one of our event types */
}
-static 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;
-}
-
-static 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);
- input_window = gdk_input_window_find (window);
+ 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,
+ device_coords = XGetDeviceMotionEvents (GDK_WINDOW_XDISPLAY (window),
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;
+ return FALSE;
}
-static void
-gdk_input_common_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)
{
- 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);
- input_window = gdk_input_window_find (window);
-
- g_return_if_fail (gdkdev != NULL);
- g_return_if_fail (gdkdev->xdevice != NULL);
+ gdkdev = (GdkDevicePrivate *)device;
+ input_window = _gdk_input_window_find (window);
g_return_if_fail (input_window != NULL);
- state = XQueryDeviceState (gdk_display, gdkdev->xdevice);
+ state = XQueryDeviceState (GDK_WINDOW_XDISPLAY (window),
+ gdkdev->xdevice);
input_class = state->data;
for (i=0; i<state->num_classes; i++)
{
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)
{
}
input_class = (XInputClass *)(((char *)input_class)+input_class->length);
}
+ XFreeDeviceState (state);
}
}
-
-#endif
projects / ~andy / gtk / blobdiff