mirror of
https://github.com/brl/mutter.git
synced 2024-11-13 01:36:10 -05:00
1b1e77b469
This is a lump commit that is fairly difficult to break down without
either breaking bisecting or breaking the test cases.
The new design for handling X11 event translation works this way:
- ClutterBackend::translate_event() has been added as the central
point used by a ClutterBackend implementation to translate a
native event into a ClutterEvent;
- ClutterEventTranslator is a private interface that should be
implemented by backend-specific objects, like stage
implementations and ClutterDeviceManager sub-classes, and
allows dealing with class-specific event translation;
- ClutterStageX11 implements EventTranslator, and deals with the
stage-relative X11 events coming from the X11 event source;
- ClutterStageGLX overrides EventTranslator, in order to
deal with the INTEL_GLX_swap_event extension, and it chains up
to the X11 default implementation;
- ClutterDeviceManagerX11 has been split into two separate classes,
one that deals with core and (optionally) XI1 events, and the
other that deals with XI2 events; the selection is done at run-time,
since the core+XI1 and XI2 mechanisms are mutually exclusive.
All the other backends we officially support still use their own
custom event source and translation function, but the end goal is to
migrate them to the translate_event() virtual function, and have the
event source be a shared part of Clutter core.
415 lines
12 KiB
C
415 lines
12 KiB
C
#include "config.h"
|
|
|
|
#include "clutter-input-device-core-x11.h"
|
|
|
|
#include "clutter-debug.h"
|
|
#include "clutter-device-manager-private.h"
|
|
#include "clutter-private.h"
|
|
#include "clutter-stage-private.h"
|
|
|
|
#include "clutter-backend-x11.h"
|
|
#include "clutter-stage-x11.h"
|
|
|
|
#ifdef HAVE_XINPUT
|
|
#include <X11/extensions/XInput.h>
|
|
#endif
|
|
|
|
#define MAX_DEVICE_CLASSES 13
|
|
|
|
typedef struct _ClutterInputDeviceClass ClutterInputDeviceX11Class;
|
|
|
|
/* a specific X11 input device */
|
|
struct _ClutterInputDeviceX11
|
|
{
|
|
ClutterInputDevice device;
|
|
|
|
#ifdef HAVE_XINPUT
|
|
XDevice *xdevice;
|
|
|
|
XEventClass event_classes[MAX_DEVICE_CLASSES];
|
|
int num_classes;
|
|
|
|
int button_press_type;
|
|
int button_release_type;
|
|
int motion_notify_type;
|
|
int state_notify_type;
|
|
int key_press_type;
|
|
int key_release_type;
|
|
#endif /* HAVE_XINPUT */
|
|
|
|
gint *axis_data;
|
|
};
|
|
|
|
#define clutter_input_device_x11_get_type _clutter_input_device_x11_get_type
|
|
|
|
G_DEFINE_TYPE (ClutterInputDeviceX11,
|
|
clutter_input_device_x11,
|
|
CLUTTER_TYPE_INPUT_DEVICE);
|
|
|
|
static void
|
|
clutter_input_device_x11_select_stage_events (ClutterInputDevice *device,
|
|
ClutterStage *stage,
|
|
gint event_mask)
|
|
{
|
|
#if HAVE_XINPUT
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (device->backend);
|
|
ClutterInputDeviceX11 *device_x11;
|
|
ClutterStageX11 *stage_x11;
|
|
XEventClass class;
|
|
gint i;
|
|
|
|
device_x11 = CLUTTER_INPUT_DEVICE_X11 (device);
|
|
|
|
stage_x11 = CLUTTER_STAGE_X11 (_clutter_stage_get_window (stage));
|
|
|
|
i = 0;
|
|
|
|
if (event_mask & ButtonPressMask)
|
|
{
|
|
DeviceButtonPress (device_x11->xdevice,
|
|
device_x11->button_press_type,
|
|
class);
|
|
if (class != 0)
|
|
device_x11->event_classes[i++] = class;
|
|
|
|
DeviceButtonPressGrab (device_x11->xdevice, 0, class);
|
|
if (class != 0)
|
|
device_x11->event_classes[i++] = class;
|
|
}
|
|
|
|
if (event_mask & ButtonReleaseMask)
|
|
{
|
|
DeviceButtonRelease (device_x11->xdevice,
|
|
device_x11->button_release_type,
|
|
class);
|
|
if (class != 0)
|
|
device_x11->event_classes[i++] = class;
|
|
}
|
|
|
|
if (event_mask & PointerMotionMask)
|
|
{
|
|
DeviceMotionNotify (device_x11->xdevice,
|
|
device_x11->motion_notify_type,
|
|
class);
|
|
if (class != 0)
|
|
device_x11->event_classes[i++] = class;
|
|
|
|
DeviceStateNotify (device_x11->xdevice,
|
|
device_x11->state_notify_type,
|
|
class);
|
|
if (class != 0)
|
|
device_x11->event_classes[i++] = class;
|
|
}
|
|
|
|
if (event_mask & KeyPressMask)
|
|
{
|
|
DeviceKeyPress (device_x11->xdevice,
|
|
device_x11->key_press_type,
|
|
class);
|
|
if (class != 0)
|
|
device_x11->event_classes[i++] = class;
|
|
}
|
|
|
|
if (event_mask & KeyReleaseMask)
|
|
{
|
|
DeviceKeyRelease (device_x11->xdevice,
|
|
device_x11->key_release_type,
|
|
class);
|
|
if (class != 0)
|
|
device_x11->event_classes[i++] = class;
|
|
}
|
|
|
|
device_x11->num_classes = i;
|
|
|
|
XSelectExtensionEvent (backend_x11->xdpy,
|
|
stage_x11->xwin,
|
|
device_x11->event_classes,
|
|
device_x11->num_classes);
|
|
#endif /* HAVE_XINPUT */
|
|
}
|
|
|
|
static void
|
|
clutter_input_device_x11_dispose (GObject *gobject)
|
|
{
|
|
ClutterInputDeviceX11 *device_x11 = CLUTTER_INPUT_DEVICE_X11 (gobject);
|
|
|
|
#ifdef HAVE_XINPUT
|
|
if (device_x11->xdevice)
|
|
{
|
|
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (gobject);
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (device->backend);
|
|
|
|
XCloseDevice (backend_x11->xdpy, device_x11->xdevice);
|
|
device_x11->xdevice = NULL;
|
|
}
|
|
#endif /* HAVE_XINPUT */
|
|
|
|
g_free (device_x11->axis_data);
|
|
|
|
G_OBJECT_CLASS (clutter_input_device_x11_parent_class)->dispose (gobject);
|
|
}
|
|
|
|
static void
|
|
clutter_input_device_x11_constructed (GObject *gobject)
|
|
{
|
|
#ifdef HAVE_XINPUT
|
|
ClutterInputDeviceX11 *device_x11 = CLUTTER_INPUT_DEVICE_X11 (gobject);
|
|
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (gobject);
|
|
ClutterBackendX11 *backend_x11;
|
|
|
|
backend_x11 = CLUTTER_BACKEND_X11 (device->backend);
|
|
|
|
clutter_x11_trap_x_errors ();
|
|
|
|
device_x11->xdevice = XOpenDevice (backend_x11->xdpy, device->id);
|
|
|
|
if (clutter_x11_untrap_x_errors ())
|
|
{
|
|
g_warning ("Device '%s' cannot be opened",
|
|
clutter_input_device_get_device_name (device));
|
|
}
|
|
#endif /* HAVE_XINPUT */
|
|
|
|
if (G_OBJECT_CLASS (clutter_input_device_x11_parent_class)->constructed)
|
|
G_OBJECT_CLASS (clutter_input_device_x11_parent_class)->constructed (gobject);
|
|
}
|
|
|
|
static void
|
|
clutter_input_device_x11_class_init (ClutterInputDeviceX11Class *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
gobject_class->constructed = clutter_input_device_x11_constructed;
|
|
gobject_class->dispose = clutter_input_device_x11_dispose;
|
|
|
|
g_signal_override_class_handler ("select-stage-events",
|
|
CLUTTER_TYPE_INPUT_DEVICE_X11,
|
|
G_CALLBACK (clutter_input_device_x11_select_stage_events));
|
|
}
|
|
|
|
static void
|
|
clutter_input_device_x11_init (ClutterInputDeviceX11 *self)
|
|
{
|
|
}
|
|
|
|
#ifdef HAVE_XINPUT
|
|
static void
|
|
update_axes (ClutterInputDeviceX11 *device_x11,
|
|
guint n_axes,
|
|
gint first_axis,
|
|
gint *axes_data)
|
|
{
|
|
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_x11);
|
|
gint i;
|
|
|
|
if (device_x11->axis_data == NULL)
|
|
{
|
|
device_x11->axis_data =
|
|
g_new0 (gint, clutter_input_device_get_n_axes (device));
|
|
}
|
|
|
|
for (i = 0; i < n_axes; i++)
|
|
device_x11->axis_data[first_axis + i] = axes_data[i];
|
|
}
|
|
|
|
static void
|
|
translate_axes (ClutterInputDeviceX11 *device_x11,
|
|
ClutterStageX11 *stage_x11,
|
|
gdouble *event_axes,
|
|
gfloat *event_x,
|
|
gfloat *event_y)
|
|
{
|
|
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_x11);
|
|
gint root_x, root_y;
|
|
gint n_axes, i;
|
|
gfloat x, y;
|
|
|
|
if (!_clutter_stage_x11_get_root_coords (stage_x11, &root_x, &root_y))
|
|
return;
|
|
|
|
x = y = 0.0f;
|
|
n_axes = clutter_input_device_get_n_axes (device);
|
|
|
|
for (i = 0; i < n_axes; i++)
|
|
{
|
|
ClutterInputAxis axis;
|
|
|
|
axis = _clutter_input_device_get_axis (device, i);
|
|
|
|
switch (axis)
|
|
{
|
|
case CLUTTER_INPUT_AXIS_X:
|
|
case CLUTTER_INPUT_AXIS_Y:
|
|
_clutter_x11_input_device_translate_screen_coord (device,
|
|
root_x, root_y,
|
|
i,
|
|
device_x11->axis_data[i],
|
|
&event_axes[i]);
|
|
if (axis == CLUTTER_INPUT_AXIS_X)
|
|
x = event_axes[i];
|
|
else if (axis == CLUTTER_INPUT_AXIS_Y)
|
|
y = event_axes[i];
|
|
break;
|
|
|
|
default:
|
|
_clutter_input_device_translate_axis (device, i,
|
|
device_x11->axis_data[i],
|
|
&event_axes[i]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (event_x)
|
|
*event_x = x;
|
|
|
|
if (event_y)
|
|
*event_y = y;
|
|
}
|
|
|
|
/*
|
|
* translate_state:
|
|
* @state: the keyboard state of the core device
|
|
* @device_state: the button state of the device
|
|
*
|
|
* Trivially translates the state and the device state into a
|
|
* single bitmask.
|
|
*/
|
|
static guint
|
|
translate_state (guint state,
|
|
guint device_state)
|
|
{
|
|
return device_state | (state & 0xff);
|
|
}
|
|
#endif /* HAVE_XINPUT */
|
|
|
|
gboolean
|
|
_clutter_input_device_x11_translate_xi_event (ClutterInputDeviceX11 *device_x11,
|
|
ClutterStageX11 *stage_x11,
|
|
XEvent *xevent,
|
|
ClutterEvent *event)
|
|
{
|
|
#ifdef HAVE_XINPUT
|
|
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_x11);
|
|
|
|
if ((xevent->type == device_x11->button_press_type) ||
|
|
(xevent->type == device_x11->button_release_type))
|
|
{
|
|
XDeviceButtonEvent *xdbe = (XDeviceButtonEvent *) xevent;
|
|
|
|
event->button.type = event->type =
|
|
(xdbe->type == device_x11->button_press_type) ? CLUTTER_BUTTON_PRESS
|
|
: CLUTTER_BUTTON_RELEASE;
|
|
event->button.device = device;
|
|
event->button.time = xdbe->time;
|
|
event->button.button = xdbe->button;
|
|
event->button.modifier_state =
|
|
translate_state (xdbe->state, xdbe->device_state);
|
|
|
|
event->button.axes =
|
|
g_new0 (gdouble, clutter_input_device_get_n_axes (device));
|
|
|
|
update_axes (device_x11,
|
|
xdbe->axes_count,
|
|
xdbe->first_axis,
|
|
xdbe->axis_data);
|
|
translate_axes (device_x11, stage_x11,
|
|
event->button.axes,
|
|
&event->button.x,
|
|
&event->button.y);
|
|
|
|
_clutter_stage_x11_set_user_time (stage_x11, event->button.time);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if ((xevent->type == device_x11->key_press_type) ||
|
|
(xevent->type == device_x11->key_release_type))
|
|
{
|
|
XDeviceKeyEvent *xdke = (XDeviceKeyEvent *) xevent;
|
|
|
|
if (xdke->keycode < device->min_keycode ||
|
|
xdke->keycode >= device->max_keycode)
|
|
{
|
|
g_warning ("Invalid device key code received: %d", xdke->keycode);
|
|
return FALSE;
|
|
}
|
|
|
|
clutter_input_device_get_key (device,
|
|
xdke->keycode - device->min_keycode,
|
|
&event->key.keyval,
|
|
&event->key.modifier_state);
|
|
if (event->key.keyval == 0)
|
|
return FALSE;
|
|
|
|
event->key.type = event->type =
|
|
(xdke->type == device_x11->key_press_type) ? CLUTTER_KEY_PRESS
|
|
: CLUTTER_KEY_RELEASE;
|
|
event->key.time = xdke->time;
|
|
event->key.modifier_state |=
|
|
translate_state (xdke->state, xdke->device_state);
|
|
event->key.device = device;
|
|
|
|
#if 0
|
|
if ((event->key.keyval >= 0x20) && (event->key.keyval <= 0xff))
|
|
{
|
|
event->key.unicode = (gunichar) event->key.keyval;
|
|
}
|
|
#endif
|
|
|
|
_clutter_stage_x11_set_user_time (stage_x11, event->key.time);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (xevent->type == device_x11->motion_notify_type)
|
|
{
|
|
XDeviceMotionEvent *xdme = (XDeviceMotionEvent *) xevent;
|
|
|
|
event->motion.type = event->type = CLUTTER_MOTION;
|
|
event->motion.time = xdme->time;
|
|
event->motion.modifier_state =
|
|
translate_state (xdme->state, xdme->device_state);
|
|
event->motion.device = device;
|
|
|
|
event->motion.axes =
|
|
g_new0 (gdouble, clutter_input_device_get_n_axes (device));
|
|
|
|
update_axes (device_x11,
|
|
xdme->axes_count,
|
|
xdme->first_axis,
|
|
xdme->axis_data);
|
|
translate_axes (device_x11, stage_x11,
|
|
event->motion.axes,
|
|
&event->motion.x,
|
|
&event->motion.y);
|
|
|
|
_clutter_stage_x11_set_user_time (stage_x11, event->motion.time);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (xevent->type == device_x11->state_notify_type)
|
|
{
|
|
XDeviceStateNotifyEvent *xdse = (XDeviceStateNotifyEvent *) xevent;
|
|
XInputClass *input_class = (XInputClass *) xdse->data;
|
|
gint n_axes = clutter_input_device_get_n_axes (device);
|
|
int i;
|
|
|
|
for (i = 0; i < xdse->num_classes; i++)
|
|
{
|
|
if (input_class->class == ValuatorClass)
|
|
{
|
|
int *axis_data = ((XValuatorState *) input_class)->valuators;
|
|
|
|
update_axes (device_x11, n_axes, 0, axis_data);
|
|
}
|
|
|
|
input_class =
|
|
(XInputClass *)(((char *) input_class) + input_class->length);
|
|
}
|
|
}
|
|
#endif /* HAVE_XINPUT */
|
|
|
|
return FALSE;
|
|
}
|