AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
3494f87a10
gtk2/gdk/x11/gdkdevicemanager-xi.c

664 lines
21 KiB
C
Raw Blame History

/* GDK - The GIMP Drawing Kit
* Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
*
* This library is free software; you can redistribute it and/or
* 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
* Lesser General Public License for more details.
*
* 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.
*/
#include "config.h"
#include "gdkdevicemanager-xi.h"
#include "gdkeventtranslator.h"
#include "gdkdevice-xi.h"
#include "gdkintl.h"
#include "gdkx.h"
#include <X11/extensions/XInput.h>
struct _GdkDeviceManagerXIPrivate
{
GHashTable *id_table;
gint event_base;
GList *devices;
gboolean ignore_core_events;
};
static void gdk_device_manager_xi_constructed (GObject *object);
static void gdk_device_manager_xi_dispose (GObject *object);
static void gdk_device_manager_xi_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gdk_device_manager_xi_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gdk_device_manager_xi_event_translator_init (GdkEventTranslatorIface *iface);
static gboolean gdk_device_manager_xi_translate_event (GdkEventTranslator *translator,
GdkDisplay *display,
GdkEvent *event,
XEvent *xevent);
static GList * gdk_device_manager_xi_list_devices (GdkDeviceManager *device_manager,
GdkDeviceType type);
G_DEFINE_TYPE_WITH_CODE (GdkDeviceManagerXI, gdk_device_manager_xi, GDK_TYPE_DEVICE_MANAGER_CORE,
G_IMPLEMENT_INTERFACE (GDK_TYPE_EVENT_TRANSLATOR,
gdk_device_manager_xi_event_translator_init))
enum {
PROP_0,
PROP_EVENT_BASE
};
static void
gdk_device_manager_xi_class_init (GdkDeviceManagerXIClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
object_class->constructed = gdk_device_manager_xi_constructed;
object_class->dispose = gdk_device_manager_xi_dispose;
object_class->set_property = gdk_device_manager_xi_set_property;
object_class->get_property = gdk_device_manager_xi_get_property;
device_manager_class->list_devices = gdk_device_manager_xi_list_devices;
g_object_class_install_property (object_class,
PROP_EVENT_BASE,
g_param_spec_int ("event-base",
P_("Event base"),
P_("Event base for XInput events"),
0, G_MAXINT, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (object_class, sizeof (GdkDeviceManagerXIPrivate));
}
static GdkFilterReturn
window_input_info_filter (GdkXEvent *xevent,
GdkEvent *event,
gpointer user_data)
{
GdkDeviceManager *device_manager;
GdkDisplay *display;
GdkWindow *window;
XEvent *xev;
device_manager = user_data;
xev = (XEvent *) xevent;
display = gdk_device_manager_get_display (device_manager);
window = gdk_window_lookup_for_display (display, xev->xany.window);
if (window && xev->type == ConfigureNotify)
gdk_device_xi_update_window_info (window);
return GDK_FILTER_CONTINUE;
}
static void
gdk_device_manager_xi_init (GdkDeviceManagerXI *device_manager)
{
GdkDeviceManagerXIPrivate *priv;
device_manager->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (device_manager,
GDK_TYPE_DEVICE_MANAGER_XI,
GdkDeviceManagerXIPrivate);
priv->id_table = g_hash_table_new_full (NULL, NULL, NULL,
(GDestroyNotify) g_object_unref);
gdk_window_add_filter (NULL, window_input_info_filter, device_manager);
}
static void
translate_class_info (GdkDevice *device,
XDeviceInfo *info)
{
GdkDeviceXI *device_xi;
XAnyClassPtr class;
gint i, j;
device_xi = GDK_DEVICE_XI (device);
class = info->inputclassinfo;
for (i = 0; i < info->num_classes; i++)
{
switch (class->class) {
case ButtonClass:
break;
case KeyClass:
{
XKeyInfo *xki = (XKeyInfo *)class;
guint num_keys;
num_keys = xki->max_keycode - xki->min_keycode + 1;
_gdk_device_set_keys (device, num_keys);
device_xi->min_keycode = xki->min_keycode;
break;
}
case ValuatorClass:
{
XValuatorInfo *xvi = (XValuatorInfo *)class;
for (j = 0; j < xvi->num_axes; j++)
{
GdkAxisUse use;
switch (j)
{
case 0:
use = GDK_AXIS_X;
break;
case 1:
use = GDK_AXIS_Y;
break;
case 2:
use = GDK_AXIS_PRESSURE;
break;
case 3:
use = GDK_AXIS_XTILT;
break;
case 4:
use = GDK_AXIS_YTILT;
break;
case 5:
use = GDK_AXIS_WHEEL;
break;
default:
use = GDK_AXIS_IGNORE;
}
_gdk_device_add_axis (device,
GDK_NONE,
use,
xvi->axes[j].min_value,
xvi->axes[j].max_value,
xvi->axes[j].resolution);
}
break;
}
}
class = (XAnyClassPtr) (((char *) class) + class->length);
}
}
/* old versions of XI.h don't define these */
#ifndef IsXExtensionKeyboard
#define IsXExtensionKeyboard 3
#define IsXExtensionPointer 4
#endif
static GdkDevice *
create_device (GdkDeviceManager *device_manager,
GdkDisplay *display,
XDeviceInfo *info)
{
GdkInputSource input_source;
GdkDevice *device;
if (info->use != IsXExtensionPointer &&
info->use != IsXExtensionKeyboard)
return NULL;
if (info->use == IsXExtensionKeyboard)
input_source = GDK_SOURCE_KEYBOARD;
else
{
gchar *tmp_name;
tmp_name = g_ascii_strdown (info->name, -1);
if (strstr (tmp_name, "eraser"))
input_source = GDK_SOURCE_ERASER;
else if (strstr (tmp_name, "cursor"))
input_source = GDK_SOURCE_CURSOR;
else if (strstr (tmp_name, "wacom") ||
strstr (tmp_name, "pen"))
input_source = GDK_SOURCE_PEN;
else
input_source = GDK_SOURCE_MOUSE;
g_free (tmp_name);
}
device = g_object_new (GDK_TYPE_DEVICE_XI,
"name", info->name,
"type", GDK_DEVICE_TYPE_FLOATING,
"input-source", input_source,
"input-mode", GDK_MODE_DISABLED,
"has-cursor", FALSE,
"display", display,
"device-manager", device_manager,
"device-id", info->id,
NULL);
translate_class_info (device, info);
return device;
}
static void
gdk_device_manager_xi_constructed (GObject *object)
{
GdkDeviceManagerXIPrivate *priv;
XDeviceInfo *devices;
gint i, num_devices;
GdkDisplay *display;
priv = GDK_DEVICE_MANAGER_XI (object)->priv;
display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (object));
devices = XListInputDevices(GDK_DISPLAY_XDISPLAY (display), &num_devices);
for(i = 0; i < num_devices; i++)
{
GdkDevice *device;
device = create_device (GDK_DEVICE_MANAGER (object),
display, &devices[i]);
if (device)
{
priv->devices = g_list_prepend (priv->devices, device);
g_hash_table_insert (priv->id_table,
GINT_TO_POINTER (devices[i].id),
g_object_ref (device));
}
}
XFreeDeviceList(devices);
gdk_x11_register_standard_event_type (display,
priv->event_base,
15 /* Number of events */);
if (G_OBJECT_CLASS (gdk_device_manager_xi_parent_class)->constructed)
G_OBJECT_CLASS (gdk_device_manager_xi_parent_class)->constructed (object);
}
static void
gdk_device_manager_xi_dispose (GObject *object)
{
GdkDeviceManagerXIPrivate *priv;
priv = GDK_DEVICE_MANAGER_XI (object)->priv;
g_list_foreach (priv->devices, (GFunc) g_object_unref, NULL);
g_list_free (priv->devices);
priv->devices = NULL;
if (priv->id_table != NULL)
{
g_hash_table_destroy (priv->id_table);
priv->id_table = NULL;
}
gdk_window_remove_filter (NULL, window_input_info_filter, object);
G_OBJECT_CLASS (gdk_device_manager_xi_parent_class)->dispose (object);
}
static void
gdk_device_manager_xi_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GdkDeviceManagerXIPrivate *priv;
priv = GDK_DEVICE_MANAGER_XI (object)->priv;
switch (prop_id)
{
case PROP_EVENT_BASE:
priv->event_base = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gdk_device_manager_xi_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GdkDeviceManagerXIPrivate *priv;
priv = GDK_DEVICE_MANAGER_XI (object)->priv;
switch (prop_id)
{
case PROP_EVENT_BASE:
g_value_set_int (value, priv->event_base);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gdk_device_manager_xi_event_translator_init (GdkEventTranslatorIface *iface)
{
iface->translate_event = gdk_device_manager_xi_translate_event;
}
/* 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.
*/
static guint
translate_state (guint state, guint device_state)
{
return device_state | (state & 0xFF);
}
static GdkDevice *
lookup_device (GdkDeviceManagerXI *device_manager,
XEvent *xevent)
{
GdkDeviceManagerXIPrivate *priv;
guint32 device_id;
priv = GDK_DEVICE_MANAGER_XI (device_manager)->priv;
/* 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 */
device_id = ((XDeviceButtonEvent *)xevent)->deviceid;
return g_hash_table_lookup (priv->id_table, GINT_TO_POINTER (device_id));
}
static gboolean
gdk_device_manager_xi_translate_event (GdkEventTranslator *translator,
GdkDisplay *display,
GdkEvent *event,
XEvent *xevent)
{
GdkDeviceManagerXIPrivate *priv;
GdkDeviceManagerXI *device_manager;
GdkEventTranslatorIface *parent_iface;
GdkDeviceXI *device_xi;
GdkDevice *device;
GdkWindow *window;
parent_iface = g_type_interface_peek_parent (GDK_EVENT_TRANSLATOR_GET_IFACE (translator));
device_manager = GDK_DEVICE_MANAGER_XI (translator);
priv = device_manager->priv;
if (!priv->ignore_core_events &&
parent_iface->translate_event (translator, display, event, xevent))
return TRUE;
device = lookup_device (device_manager, xevent);
device_xi = GDK_DEVICE_XI (device);
if (!device)
return FALSE;
window = gdk_window_lookup_for_display (display, xevent->xany.window);
if (!window)
return FALSE;
if ((xevent->type == device_xi->button_press_type) ||
(xevent->type == device_xi->button_release_type))
{
XDeviceButtonEvent *xdbe = (XDeviceButtonEvent *) xevent;
event->button.type = (xdbe->type == device_xi->button_press_type) ?
GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE;
event->button.device = device;
event->button.window = g_object_ref (window);
event->button.time = xdbe->time;
event->button.x_root = (gdouble) xdbe->x_root;
event->button.y_root = (gdouble) xdbe->y_root;
event->button.axes = g_new0 (gdouble, gdk_device_get_n_axes (device));
gdk_device_xi_update_axes (device, xdbe->axes_count,
xdbe->first_axis, xdbe->axis_data);
gdk_device_xi_translate_axes (device, window,
device_xi->axis_data,
event->button.axes,
&event->button.x,
&event->button.y);
event->button.state = translate_state (xdbe->state, xdbe->device_state);
event->button.button = xdbe->button;
if (event->button.type == GDK_BUTTON_PRESS)
_gdk_event_button_generate (gdk_window_get_display (event->button.window),
event);
GDK_NOTE (EVENTS,
g_print ("button %s:\t\twindow: %ld device: %ld x,y: %f %f button: %d\n",
(event->button.type == GDK_BUTTON_PRESS) ? "press" : "release",
xdbe->window,
xdbe->deviceid,
event->button.x, event->button.y,
xdbe->button));
/* Update the timestamp of the latest user interaction, if the event has
* a valid timestamp.
*/
if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
gdk_x11_window_set_user_time (gdk_window_get_toplevel (window),
gdk_event_get_time (event));
return TRUE;
}
if ((xevent->type == device_xi->key_press_type) ||
(xevent->type == device_xi->key_release_type))
{
XDeviceKeyEvent *xdke = (XDeviceKeyEvent *) xevent;
GDK_NOTE (EVENTS,
g_print ("device key %s:\twindow: %ld device: %ld keycode: %d\n",
(event->key.type == GDK_KEY_PRESS) ? "press" : "release",
xdke->window,
xdke->deviceid,
xdke->keycode));
if (xdke->keycode < device_xi->min_keycode ||
xdke->keycode >= device_xi->min_keycode + gdk_device_get_n_keys (device))
{
g_warning ("Invalid device key code received");
return FALSE;
}
gdk_device_get_key (device, xdke->keycode - device_xi->min_keycode,
&event->key.keyval,
&event->key.state);
if (event->key.keyval == 0)
{
GDK_NOTE (EVENTS,
g_print ("\t\ttranslation - NONE\n"));
return FALSE;
}
event->key.type = (xdke->type == device_xi->key_press_type) ?
GDK_KEY_PRESS : GDK_KEY_RELEASE;
event->key.window = g_object_ref (window);
event->key.time = xdke->time;
event->key.state |= translate_state (xdke->state, xdke->device_state);
/* Add a string translation for the key event */
if ((event->key.keyval >= 0x20) && (event->key.keyval <= 0xFF))
{
event->key.length = 1;
event->key.string = g_new (gchar, 2);
event->key.string[0] = (gchar) event->key.keyval;
event->key.string[1] = 0;
}
else
{
event->key.length = 0;
event->key.string = g_new0 (gchar, 1);
}
GDK_NOTE (EVENTS,
g_print ("\t\ttranslation - keyval: %d modifiers: %#x\n",
event->key.keyval,
event->key.state));
/* Update the timestamp of the latest user interaction, if the event has
* a valid timestamp.
*/
if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
gdk_x11_window_set_user_time (gdk_window_get_toplevel (window),
gdk_event_get_time (event));
return TRUE;
}
if (xevent->type == device_xi->motion_notify_type)
{
XDeviceMotionEvent *xdme = (XDeviceMotionEvent *) xevent;
event->motion.device = device;
if (device_xi->in_proximity)
priv->ignore_core_events = TRUE;
event->motion.x_root = (gdouble) xdme->x_root;
event->motion.y_root = (gdouble) xdme->y_root;
event->motion.axes = g_new0 (gdouble, gdk_device_get_n_axes (device));
gdk_device_xi_update_axes (device, xdme->axes_count,
xdme->first_axis, xdme->axis_data);
gdk_device_xi_translate_axes (device, window,
device_xi->axis_data,
event->motion.axes,
&event->motion.x,
&event->motion.y);
event->motion.type = GDK_MOTION_NOTIFY;
event->motion.window = g_object_ref (window);
event->motion.time = xdme->time;
event->motion.state = translate_state (xdme->state,
xdme->device_state);
event->motion.is_hint = xdme->is_hint;
GDK_NOTE (EVENTS,
g_print ("motion notify:\t\twindow: %ld device: %ld x,y: %f %f state %#4x hint: %s\n",
xdme->window,
xdme->deviceid,
event->motion.x, event->motion.y,
event->motion.state,
(xdme->is_hint) ? "true" : "false"));
/* Update the timestamp of the latest user interaction, if the event has
* a valid timestamp.
*/
if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
gdk_x11_window_set_user_time (gdk_window_get_toplevel (window),
gdk_event_get_time (event));
return TRUE;
}
if (xevent->type == device_xi->proximity_in_type ||
xevent->type == device_xi->proximity_out_type)
{
XProximityNotifyEvent *xpne = (XProximityNotifyEvent *) xevent;
if (xevent->type == device_xi->proximity_in_type)
{
event->proximity.type = GDK_PROXIMITY_IN;
device_xi->in_proximity = TRUE;
priv->ignore_core_events = TRUE;
}
else
{
event->proximity.type = GDK_PROXIMITY_OUT;
device_xi->in_proximity = FALSE;
priv->ignore_core_events = FALSE;
}
event->proximity.device = device;
event->proximity.window = g_object_ref (window);
event->proximity.time = xpne->time;
/* Update the timestamp of the latest user interaction, if the event has
* a valid timestamp.
*/
if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
gdk_x11_window_set_user_time (gdk_window_get_toplevel (window),
gdk_event_get_time (event));
return TRUE;
}
if (xevent->type == device_xi->state_notify_type)
{
XDeviceStateNotifyEvent *xdse = (XDeviceStateNotifyEvent *) xevent;
XInputClass *input_class = (XInputClass *) xdse->data;
int i;
for (i = 0; i < xdse->num_classes; i++)
{
if (input_class->class == ValuatorClass)
gdk_device_xi_update_axes (device, gdk_device_get_n_axes (device), 0,
((XValuatorState *)input_class)->valuators);
input_class = (XInputClass *)(((char *)input_class)+input_class->length);
}
GDK_NOTE (EVENTS,
g_print ("device state notify:\t\twindow: %ld device: %ld\n",
xdse->window,
xdse->deviceid));
return FALSE;
}
return FALSE;
}
static GList *
gdk_device_manager_xi_list_devices (GdkDeviceManager *device_manager,
GdkDeviceType type)
{
GdkDeviceManagerXIPrivate *priv;
priv = GDK_DEVICE_MANAGER_XI (device_manager)->priv;
if (type == GDK_DEVICE_TYPE_MASTER)
return GDK_DEVICE_MANAGER_CLASS (gdk_device_manager_xi_parent_class)->list_devices (device_manager, type);
else if (type == GDK_DEVICE_TYPE_FLOATING)
{
return g_list_copy (priv->devices);
}
else
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink