isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-03 21:30:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
cf45050cba
mutter/src/backends/native/meta-input-device-native.c
Carlos Garnacho cf45050cba backends/native: Surround device state queries/updates with RW lock 
Wrap all keyboard state updates, and all pointer/stylus/touch cursor
position with a write lock, and ::query_state() (The only entrypoint
to this state from other threads) with a read lock.

The principle is that query_state may be called from different threads
(UI so far, but maybe KMS too in the future), while the input thread
may (or may not) be updating it. This state is fetched "atomically"
(eg. x/y will be consistently old or new, if the input thread were
updating it at the same time).

There's other places deep in backends/native that read this state,
they all will run in the input thread, so they count as "other readers"
to the other thread. Those changes are already mutually exclusive with
updates, so they don't explicitly need the RW lock.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-11-27 15:14:33 +00:00

1530 lines
47 KiB
C
Raw Blame History

/*
* Copyright (C) 2010 Intel Corp.
* Copyright (C) 2014 Jonas Ådahl
*
* 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, see <http://www.gnu.org/licenses/>.
*
* Author: Damien Lespiau <damien.lespiau@intel.com>
* Author: Jonas Ådahl <jadahl@gmail.com>
*/
#include "config.h"
#include <math.h>
#include <cairo-gobject.h>
#include "backends/meta-backend-private.h"
#include "backends/native/meta-input-device-tool-native.h"
#include "backends/native/meta-input-device-native.h"
#include "backends/native/meta-seat-impl.h"
#include "clutter/clutter-mutter.h"
G_DEFINE_TYPE (MetaInputDeviceNative,
meta_input_device_native,
META_TYPE_INPUT_DEVICE)
enum
{
PROP_0,
PROP_DEVICE_MATRIX,
PROP_OUTPUT_ASPECT_RATIO,
N_PROPS
};
static GParamSpec *obj_props[N_PROPS] = { 0 };
typedef struct _SlowKeysEventPending
{
MetaInputDeviceNative *device;
ClutterEvent *event;
ClutterEmitInputDeviceEvent emit_event_func;
guint timer;
} SlowKeysEventPending;
static void clear_slow_keys (MetaInputDeviceNative *device);
static void stop_bounce_keys (MetaInputDeviceNative *device);
static void stop_toggle_slowkeys (MetaInputDeviceNative *device);
static void stop_mousekeys_move (MetaInputDeviceNative *device);
static void
meta_input_device_native_finalize (GObject *object)
{
MetaInputDeviceNative *device_evdev = META_INPUT_DEVICE_NATIVE (object);
if (device_evdev->libinput_device)
libinput_device_unref (device_evdev->libinput_device);
clear_slow_keys (device_evdev);
stop_bounce_keys (device_evdev);
stop_toggle_slowkeys (device_evdev);
stop_mousekeys_move (device_evdev);
G_OBJECT_CLASS (meta_input_device_native_parent_class)->finalize (object);
}
static void
meta_input_device_native_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MetaInputDeviceNative *device = META_INPUT_DEVICE_NATIVE (object);
switch (prop_id)
{
case PROP_DEVICE_MATRIX:
{
const cairo_matrix_t *matrix = g_value_get_boxed (value);
cairo_matrix_init_identity (&device->device_matrix);
cairo_matrix_multiply (&device->device_matrix,
&device->device_matrix, matrix);
break;
}
case PROP_OUTPUT_ASPECT_RATIO:
device->output_ratio = g_value_get_double (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
meta_input_device_native_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MetaInputDeviceNative *device = META_INPUT_DEVICE_NATIVE (object);
switch (prop_id)
{
case PROP_DEVICE_MATRIX:
g_value_set_boxed (value, &device->device_matrix);
break;
case PROP_OUTPUT_ASPECT_RATIO:
g_value_set_double (value, device->output_ratio);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static gboolean
meta_input_device_native_keycode_to_evdev (ClutterInputDevice *device,
uint32_t hardware_keycode,
uint32_t *evdev_keycode)
{
/* The hardware keycodes from the evdev backend are almost evdev
keycodes: we use the evdev keycode file, but xkb rules have an
offset by 8. See the comment in _clutter_key_event_new_from_evdev()
*/
*evdev_keycode = hardware_keycode - 8;
return TRUE;
}
static void
meta_input_device_native_update_from_tool (ClutterInputDevice *device,
ClutterInputDeviceTool *tool)
{
MetaInputDeviceToolNative *evdev_tool;
evdev_tool = META_INPUT_DEVICE_TOOL_NATIVE (tool);
g_object_freeze_notify (G_OBJECT (device));
_clutter_input_device_reset_axes (device);
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_X, 0, 0, 0);
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_Y, 0, 0, 0);
if (libinput_tablet_tool_has_distance (evdev_tool->tool))
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_DISTANCE, 0, 1, 0);
if (libinput_tablet_tool_has_pressure (evdev_tool->tool))
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_PRESSURE, 0, 1, 0);
if (libinput_tablet_tool_has_tilt (evdev_tool->tool))
{
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_XTILT, -90, 90, 0);
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_YTILT, -90, 90, 0);
}
if (libinput_tablet_tool_has_rotation (evdev_tool->tool))
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_ROTATION, 0, 360, 0);
if (libinput_tablet_tool_has_slider (evdev_tool->tool))
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_SLIDER, -1, 1, 0);
if (libinput_tablet_tool_has_wheel (evdev_tool->tool))
_clutter_input_device_add_axis (device, CLUTTER_INPUT_AXIS_WHEEL, -180, 180, 0);
g_object_thaw_notify (G_OBJECT (device));
}
static gboolean
meta_input_device_native_is_mode_switch_button (ClutterInputDevice *device,
uint32_t group,
uint32_t button)
{
struct libinput_device *libinput_device;
struct libinput_tablet_pad_mode_group *mode_group;
libinput_device = meta_input_device_native_get_libinput_device (device);
mode_group = libinput_device_tablet_pad_get_mode_group (libinput_device, group);
return libinput_tablet_pad_mode_group_button_is_toggle (mode_group, button) != 0;
}
static int
meta_input_device_native_get_group_n_modes (ClutterInputDevice *device,
int group)
{
struct libinput_device *libinput_device;
struct libinput_tablet_pad_mode_group *mode_group;
libinput_device = meta_input_device_native_get_libinput_device (device);
mode_group = libinput_device_tablet_pad_get_mode_group (libinput_device, group);
return libinput_tablet_pad_mode_group_get_num_modes (mode_group);
}
static gboolean
meta_input_device_native_is_grouped (ClutterInputDevice *device,
ClutterInputDevice *other_device)
{
struct libinput_device *libinput_device, *other_libinput_device;
libinput_device = meta_input_device_native_get_libinput_device (device);
other_libinput_device = meta_input_device_native_get_libinput_device (other_device);
return libinput_device_get_device_group (libinput_device) ==
libinput_device_get_device_group (other_libinput_device);
}
static void
meta_input_device_native_bell_notify (MetaInputDeviceNative *device)
{
meta_seat_impl_notify_bell (device->seat_impl);
}
static void
meta_input_device_native_free_pending_slow_key (gpointer data)
{
SlowKeysEventPending *slow_keys_event = data;
clutter_event_free (slow_keys_event->event);
g_clear_handle_id (&slow_keys_event->timer, g_source_remove);
g_free (slow_keys_event);
}
static void
clear_slow_keys (MetaInputDeviceNative *device)
{
g_list_free_full (device->slow_keys_list, meta_input_device_native_free_pending_slow_key);
g_list_free (device->slow_keys_list);
device->slow_keys_list = NULL;
}
static guint
get_slow_keys_delay (ClutterInputDevice *device)
{
MetaInputDeviceNative *device_native = META_INPUT_DEVICE_NATIVE (device);
MetaKbdA11ySettings a11y_settings;
MetaInputSettings *input_settings;
input_settings = meta_seat_impl_get_input_settings (device_native->seat_impl);
meta_input_settings_get_kbd_a11y_settings (input_settings, &a11y_settings);
/* Settings use int, we use uint, make sure we dont go negative */
return MAX (0, a11y_settings.slowkeys_delay);
}
static gboolean
trigger_slow_keys (gpointer data)
{
SlowKeysEventPending *slow_keys_event = data;
MetaInputDeviceNative *device = slow_keys_event->device;
ClutterKeyEvent *key_event = (ClutterKeyEvent *) slow_keys_event->event;
/* Alter timestamp and emit the event */
key_event->time = us2ms (g_get_monotonic_time ());
slow_keys_event->emit_event_func (slow_keys_event->event,
CLUTTER_INPUT_DEVICE (device));
/* Then remote the pending event */
device->slow_keys_list = g_list_remove (device->slow_keys_list, slow_keys_event);
meta_input_device_native_free_pending_slow_key (slow_keys_event);
if (device->a11y_flags & META_A11Y_SLOW_KEYS_BEEP_ACCEPT)
meta_input_device_native_bell_notify (device);
return G_SOURCE_REMOVE;
}
static int
find_pending_event_by_keycode (gconstpointer a,
gconstpointer b)
{
const SlowKeysEventPending *pa = a;
const ClutterKeyEvent *ka = (ClutterKeyEvent *) pa->event;
const ClutterKeyEvent *kb = b;
return kb->hardware_keycode - ka->hardware_keycode;
}
static void
start_slow_keys (ClutterEvent *event,
MetaInputDeviceNative *device,
ClutterEmitInputDeviceEvent emit_event_func)
{
SlowKeysEventPending *slow_keys_event;
ClutterKeyEvent *key_event = (ClutterKeyEvent *) event;
if (key_event->flags & CLUTTER_EVENT_FLAG_REPEATED)
return;
slow_keys_event = g_new0 (SlowKeysEventPending, 1);
slow_keys_event->device = device;
slow_keys_event->event = clutter_event_copy (event);
slow_keys_event->emit_event_func = emit_event_func;
slow_keys_event->timer =
clutter_threads_add_timeout (get_slow_keys_delay (CLUTTER_INPUT_DEVICE (device)),
trigger_slow_keys,
slow_keys_event);
device->slow_keys_list = g_list_append (device->slow_keys_list, slow_keys_event);
if (device->a11y_flags & META_A11Y_SLOW_KEYS_BEEP_PRESS)
meta_input_device_native_bell_notify (device);
}
static void
stop_slow_keys (ClutterEvent *event,
MetaInputDeviceNative *device,
ClutterEmitInputDeviceEvent emit_event_func)
{
GList *item;
/* Check if we have a slow key event queued for this key event */
item = g_list_find_custom (device->slow_keys_list, event, find_pending_event_by_keycode);
if (item)
{
SlowKeysEventPending *slow_keys_event = item->data;
device->slow_keys_list = g_list_delete_link (device->slow_keys_list, item);
meta_input_device_native_free_pending_slow_key (slow_keys_event);
if (device->a11y_flags & META_A11Y_SLOW_KEYS_BEEP_REJECT)
meta_input_device_native_bell_notify (device);
return;
}
/* If no key press event was pending, just emit the key release as-is */
emit_event_func (event, CLUTTER_INPUT_DEVICE (device));
}
static guint
get_debounce_delay (ClutterInputDevice *device)
{
MetaInputDeviceNative *device_native = META_INPUT_DEVICE_NATIVE (device);
MetaKbdA11ySettings a11y_settings;
MetaInputSettings *input_settings;
input_settings = meta_seat_impl_get_input_settings (device_native->seat_impl);
meta_input_settings_get_kbd_a11y_settings (input_settings, &a11y_settings);
/* Settings use int, we use uint, make sure we dont go negative */
return MAX (0, a11y_settings.debounce_delay);
}
static gboolean
clear_bounce_keys (gpointer data)
{
MetaInputDeviceNative *device = data;
device->debounce_key = 0;
device->debounce_timer = 0;
return G_SOURCE_REMOVE;
}
static void
start_bounce_keys (ClutterEvent *event,
MetaInputDeviceNative *device)
{
stop_bounce_keys (device);
device->debounce_key = ((ClutterKeyEvent *) event)->hardware_keycode;
device->debounce_timer =
clutter_threads_add_timeout (get_debounce_delay (CLUTTER_INPUT_DEVICE (device)),
clear_bounce_keys,
device);
}
static void
stop_bounce_keys (MetaInputDeviceNative *device)
{
g_clear_handle_id (&device->debounce_timer, g_source_remove);
}
static void
notify_bounce_keys_reject (MetaInputDeviceNative *device)
{
if (device->a11y_flags & META_A11Y_BOUNCE_KEYS_BEEP_REJECT)
meta_input_device_native_bell_notify (device);
}
static gboolean
debounce_key (ClutterEvent *event,
MetaInputDeviceNative *device)
{
return (device->debounce_key == ((ClutterKeyEvent *) event)->hardware_keycode);
}
static gboolean
key_event_is_modifier (ClutterEvent *event)
{
switch (event->key.keyval)
{
case XKB_KEY_Shift_L:
case XKB_KEY_Shift_R:
case XKB_KEY_Control_L:
case XKB_KEY_Control_R:
case XKB_KEY_Alt_L:
case XKB_KEY_Alt_R:
case XKB_KEY_Meta_L:
case XKB_KEY_Meta_R:
case XKB_KEY_Super_L:
case XKB_KEY_Super_R:
case XKB_KEY_Hyper_L:
case XKB_KEY_Hyper_R:
case XKB_KEY_Caps_Lock:
case XKB_KEY_Shift_Lock:
return TRUE;
default:
return FALSE;
}
}
static void
notify_stickykeys_mask (MetaInputDeviceNative *device)
{
meta_seat_impl_notify_kbd_a11y_mods_state_changed (device->seat_impl,
device->stickykeys_latched_mask,
device->stickykeys_locked_mask);
}
static void
update_internal_xkb_state (MetaInputDeviceNative *device,
xkb_mod_mask_t new_latched_mask,
xkb_mod_mask_t new_locked_mask)
{
MetaSeatImpl *seat_impl = device->seat_impl;
xkb_mod_mask_t depressed_mods;
xkb_mod_mask_t latched_mods;
xkb_mod_mask_t locked_mods;
xkb_mod_mask_t group_mods;
struct xkb_state *xkb_state;
g_rw_lock_writer_lock (&seat_impl->state_lock);
xkb_state = meta_seat_impl_get_xkb_state (seat_impl);
depressed_mods = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_DEPRESSED);
latched_mods = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_LATCHED);
locked_mods = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_LOCKED);
latched_mods &= ~device->stickykeys_latched_mask;
locked_mods &= ~device->stickykeys_locked_mask;
device->stickykeys_latched_mask = new_latched_mask;
device->stickykeys_locked_mask = new_locked_mask;
latched_mods |= device->stickykeys_latched_mask;
locked_mods |= device->stickykeys_locked_mask;
group_mods = xkb_state_serialize_layout (xkb_state, XKB_STATE_LAYOUT_EFFECTIVE);
xkb_state_update_mask (xkb_state,
depressed_mods,
latched_mods,
locked_mods,
0, 0, group_mods);
notify_stickykeys_mask (device);
g_rw_lock_writer_unlock (&seat_impl->state_lock);
}
static void
update_stickykeys_event (ClutterEvent *event,
MetaInputDeviceNative *device,
xkb_mod_mask_t new_latched_mask,
xkb_mod_mask_t new_locked_mask)
{
MetaSeatImpl *seat_impl = device->seat_impl;
xkb_mod_mask_t effective_mods;
xkb_mod_mask_t latched_mods;
xkb_mod_mask_t locked_mods;
struct xkb_state *xkb_state;
update_internal_xkb_state (device, new_latched_mask, new_locked_mask);
xkb_state = meta_seat_impl_get_xkb_state (seat_impl);
effective_mods = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_EFFECTIVE);
latched_mods = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_LATCHED);
locked_mods = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_LOCKED);
_clutter_event_set_state_full (event,
seat_impl->button_state,
device->stickykeys_depressed_mask,
latched_mods,
locked_mods,
effective_mods | seat_impl->button_state);
}
static void
notify_stickykeys_change (MetaInputDeviceNative *device)
{
/* Every time sticky keys setting is changed, clear the masks */
device->stickykeys_depressed_mask = 0;
update_internal_xkb_state (device, 0, 0);
meta_seat_impl_notify_kbd_a11y_flags_changed (device->seat_impl,
device->a11y_flags,
META_A11Y_STICKY_KEYS_ENABLED);
}
static void
set_stickykeys_off (MetaInputDeviceNative *device)
{
device->a11y_flags &= ~META_A11Y_STICKY_KEYS_ENABLED;
notify_stickykeys_change (device);
}
static void
set_stickykeys_on (MetaInputDeviceNative *device)
{
device->a11y_flags |= META_A11Y_STICKY_KEYS_ENABLED;
notify_stickykeys_change (device);
}
static void
clear_stickykeys_event (ClutterEvent *event,
MetaInputDeviceNative *device)
{
set_stickykeys_off (device);
update_stickykeys_event (event, device, 0, 0);
}
static void
set_slowkeys_off (MetaInputDeviceNative *device)
{
device->a11y_flags &= ~META_A11Y_SLOW_KEYS_ENABLED;
meta_seat_impl_notify_kbd_a11y_flags_changed (device->seat_impl,
device->a11y_flags,
META_A11Y_SLOW_KEYS_ENABLED);
}
static void
set_slowkeys_on (MetaInputDeviceNative *device)
{
device->a11y_flags |= META_A11Y_SLOW_KEYS_ENABLED;
meta_seat_impl_notify_kbd_a11y_flags_changed (device->seat_impl,
device->a11y_flags,
META_A11Y_SLOW_KEYS_ENABLED);
}
static void
handle_stickykeys_press (ClutterEvent *event,
MetaInputDeviceNative *device)
{
MetaSeatImpl *seat_impl = device->seat_impl;
xkb_mod_mask_t depressed_mods;
xkb_mod_mask_t new_latched_mask;
xkb_mod_mask_t new_locked_mask;
struct xkb_state *xkb_state;
if (!key_event_is_modifier (event))
return;
if (device->stickykeys_depressed_mask &&
(device->a11y_flags & META_A11Y_STICKY_KEYS_TWO_KEY_OFF))
{
clear_stickykeys_event (event, device);
return;
}
xkb_state = meta_seat_impl_get_xkb_state (seat_impl);
depressed_mods = xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_DEPRESSED);
/* Ignore the lock modifier mask, that one cannot be sticky, yet the
* CAPS_LOCK key itself counts as a modifier as it might be remapped
* to some other modifier which can be sticky.
*/
depressed_mods &= ~CLUTTER_LOCK_MASK;
new_latched_mask = device->stickykeys_latched_mask;
new_locked_mask = device->stickykeys_locked_mask;
device->stickykeys_depressed_mask = depressed_mods;
if (new_locked_mask & depressed_mods)
{
new_locked_mask &= ~depressed_mods;
}
else if (new_latched_mask & depressed_mods)
{
new_locked_mask |= depressed_mods;
new_latched_mask &= ~depressed_mods;
}
else
{
new_latched_mask |= depressed_mods;
}
update_stickykeys_event (event, device, new_latched_mask, new_locked_mask);
}
static void
handle_stickykeys_release (ClutterEvent *event,
MetaInputDeviceNative *device)
{
MetaSeatImpl *seat_impl = device->seat_impl;
struct xkb_state *xkb_state;
xkb_state = meta_seat_impl_get_xkb_state (seat_impl);
device->stickykeys_depressed_mask =
xkb_state_serialize_mods (xkb_state, XKB_STATE_MODS_DEPRESSED);
if (key_event_is_modifier (event))
{
if (device->a11y_flags & META_A11Y_STICKY_KEYS_BEEP)
meta_input_device_native_bell_notify (device);
return;
}
if (device->stickykeys_latched_mask == 0)
return;
update_stickykeys_event (event, device, 0, device->stickykeys_locked_mask);
}
static gboolean
trigger_toggle_slowkeys (gpointer data)
{
MetaInputDeviceNative *device = data;
device->toggle_slowkeys_timer = 0;
if (device->a11y_flags & META_A11Y_FEATURE_STATE_CHANGE_BEEP)
meta_input_device_native_bell_notify (device);
if (device->a11y_flags & META_A11Y_SLOW_KEYS_ENABLED)
set_slowkeys_off (device);
else
set_slowkeys_on (device);
return G_SOURCE_REMOVE;
}
static void
start_toggle_slowkeys (MetaInputDeviceNative *device)
{
if (device->toggle_slowkeys_timer != 0)
return;
device->toggle_slowkeys_timer =
clutter_threads_add_timeout (8 * 1000 /* 8 secs */,
trigger_toggle_slowkeys,
device);
}
static void
stop_toggle_slowkeys (MetaInputDeviceNative *device)
{
g_clear_handle_id (&device->toggle_slowkeys_timer, g_source_remove);
}
static void
handle_enablekeys_press (ClutterEvent *event,
MetaInputDeviceNative *device)
{
if (event->key.keyval == XKB_KEY_Shift_L || event->key.keyval == XKB_KEY_Shift_R)
{
start_toggle_slowkeys (device);
if (event->key.time > device->last_shift_time + 15 * 1000 /* 15 secs */)
device->shift_count = 1;
else
device->shift_count++;
device->last_shift_time = event->key.time;
}
else
{
device->shift_count = 0;
stop_toggle_slowkeys (device);
}
}
static void
handle_enablekeys_release (ClutterEvent *event,
MetaInputDeviceNative *device)
{
if (event->key.keyval == XKB_KEY_Shift_L || event->key.keyval == XKB_KEY_Shift_R)
{
stop_toggle_slowkeys (device);
if (device->shift_count >= 5)
{
device->shift_count = 0;
if (device->a11y_flags & META_A11Y_FEATURE_STATE_CHANGE_BEEP)
meta_input_device_native_bell_notify (device);
if (device->a11y_flags & META_A11Y_STICKY_KEYS_ENABLED)
set_stickykeys_off (device);
else
set_stickykeys_on (device);
}
}
}
static int
get_button_index (int button)
{
switch (button)
{
case CLUTTER_BUTTON_PRIMARY:
return 0;
case CLUTTER_BUTTON_MIDDLE:
return 1;
case CLUTTER_BUTTON_SECONDARY:
return 2;
default:
break;
}
g_warn_if_reached ();
return 0;
}
static void
emulate_button_press (MetaInputDeviceNative *device_evdev)
{
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
int btn = device_evdev->mousekeys_btn;
if (device_evdev->mousekeys_btn_states[get_button_index (btn)])
return;
clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
g_get_monotonic_time (), btn,
CLUTTER_BUTTON_STATE_PRESSED);
device_evdev->mousekeys_btn_states[get_button_index (btn)] = CLUTTER_BUTTON_STATE_PRESSED;
}
static void
emulate_button_release (MetaInputDeviceNative *device_evdev)
{
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
int btn = device_evdev->mousekeys_btn;
if (device_evdev->mousekeys_btn_states[get_button_index (btn)] == CLUTTER_BUTTON_STATE_RELEASED)
return;
clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
g_get_monotonic_time (), btn,
CLUTTER_BUTTON_STATE_RELEASED);
device_evdev->mousekeys_btn_states[get_button_index (btn)] = CLUTTER_BUTTON_STATE_RELEASED;
}
static void
emulate_button_click (MetaInputDeviceNative *device)
{
emulate_button_press (device);
emulate_button_release (device);
}
#define MOUSEKEYS_CURVE (1.0 + (((double) 50.0) * 0.001))
static void
update_mousekeys_params (MetaInputDeviceNative *device,
MetaKbdA11ySettings *settings)
{
/* Prevent us from broken settings values */
device->mousekeys_max_speed = MAX (1, settings->mousekeys_max_speed);
device->mousekeys_accel_time = MAX (1, settings->mousekeys_accel_time);
device->mousekeys_init_delay = MAX (0, settings->mousekeys_init_delay);
device->mousekeys_curve_factor =
(((double) device->mousekeys_max_speed) /
pow ((double) device->mousekeys_accel_time, MOUSEKEYS_CURVE));
}
static double
mousekeys_get_speed_factor (MetaInputDeviceNative *device,
uint64_t time_us)
{
uint32_t time;
int64_t delta_t;
int64_t init_time;
double speed;
time = us2ms (time_us);
if (device->mousekeys_first_motion_time == 0)
{
/* Start acceleration _after_ the first move, so take
* mousekeys_init_delay into account for t0
*/
device->mousekeys_first_motion_time = time + device->mousekeys_init_delay;
device->mousekeys_last_motion_time = device->mousekeys_first_motion_time;
return 1.0;
}
init_time = time - device->mousekeys_first_motion_time;
delta_t = time - device->mousekeys_last_motion_time;
if (delta_t < 0)
return 0.0;
if (init_time < device->mousekeys_accel_time)
speed = (double) (device->mousekeys_curve_factor *
pow ((double) init_time, MOUSEKEYS_CURVE) * delta_t / 1000.0);
else
speed = (double) (device->mousekeys_max_speed * delta_t / 1000.0);
device->mousekeys_last_motion_time = time;
return speed;
}
#undef MOUSEKEYS_CURVE
static void
emulate_pointer_motion (MetaInputDeviceNative *device_evdev,
int dx,
int dy)
{
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
double dx_motion;
double dy_motion;
double speed;
int64_t time_us;
time_us = g_get_monotonic_time ();
speed = mousekeys_get_speed_factor (device_evdev, time_us);
if (dx < 0)
dx_motion = floor (((double) dx) * speed);
else
dx_motion = ceil (((double) dx) * speed);
if (dy < 0)
dy_motion = floor (((double) dy) * speed);
else
dy_motion = ceil (((double) dy) * speed);
clutter_virtual_input_device_notify_relative_motion (device->accessibility_virtual_device,
time_us, dx_motion, dy_motion);
}
static gboolean
is_numlock_active (MetaInputDeviceNative *device)
{
MetaSeatImpl *seat_impl = device->seat_impl;
struct xkb_state *xkb_state;
xkb_state = meta_seat_impl_get_xkb_state (seat_impl);
return xkb_state_mod_name_is_active (xkb_state,
"Mod2",
XKB_STATE_MODS_LOCKED);
}
static void
enable_mousekeys (MetaInputDeviceNative *device_evdev)
{
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
device_evdev->mousekeys_btn = CLUTTER_BUTTON_PRIMARY;
device_evdev->move_mousekeys_timer = 0;
device_evdev->mousekeys_first_motion_time = 0;
device_evdev->mousekeys_last_motion_time = 0;
device_evdev->last_mousekeys_key = 0;
if (device->accessibility_virtual_device)
return;
device->accessibility_virtual_device =
clutter_seat_create_virtual_device (clutter_input_device_get_seat (device),
CLUTTER_POINTER_DEVICE);
}
static void
disable_mousekeys (MetaInputDeviceNative *device_evdev)
{
ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
stop_mousekeys_move (device_evdev);
/* Make sure we don't leave button pressed behind... */
if (device_evdev->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_PRIMARY)])
{
device_evdev->mousekeys_btn = CLUTTER_BUTTON_PRIMARY;
emulate_button_release (device_evdev);
}
if (device_evdev->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_MIDDLE)])
{
device_evdev->mousekeys_btn = CLUTTER_BUTTON_MIDDLE;
emulate_button_release (device_evdev);
}
if (device_evdev->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_SECONDARY)])
{
device_evdev->mousekeys_btn = CLUTTER_BUTTON_SECONDARY;
emulate_button_release (device_evdev);
}
if (device->accessibility_virtual_device)
g_clear_object (&device->accessibility_virtual_device);
}
static gboolean
trigger_mousekeys_move (gpointer data)
{
MetaInputDeviceNative *device = data;
int dx = 0;
int dy = 0;
if (device->mousekeys_first_motion_time == 0)
{
/* This is the first move, Secdule at mk_init_delay */
device->move_mousekeys_timer =
clutter_threads_add_timeout (device->mousekeys_init_delay,
trigger_mousekeys_move,
device);
}
else
{
/* More moves, reschedule at mk_interval */
device->move_mousekeys_timer =
clutter_threads_add_timeout (100, /* msec between mousekey events */
trigger_mousekeys_move,
device);
}
/* Pointer motion */
switch (device->last_mousekeys_key)
{
case XKB_KEY_KP_Home:
case XKB_KEY_KP_7:
case XKB_KEY_KP_Up:
case XKB_KEY_KP_8:
case XKB_KEY_KP_Page_Up:
case XKB_KEY_KP_9:
dy = -1;
break;
case XKB_KEY_KP_End:
case XKB_KEY_KP_1:
case XKB_KEY_KP_Down:
case XKB_KEY_KP_2:
case XKB_KEY_KP_Page_Down:
case XKB_KEY_KP_3:
dy = 1;
break;
default:
break;
}
switch (device->last_mousekeys_key)
{
case XKB_KEY_KP_Home:
case XKB_KEY_KP_7:
case XKB_KEY_KP_Left:
case XKB_KEY_KP_4:
case XKB_KEY_KP_End:
case XKB_KEY_KP_1:
dx = -1;
break;
case XKB_KEY_KP_Page_Up:
case XKB_KEY_KP_9:
case XKB_KEY_KP_Right:
case XKB_KEY_KP_6:
case XKB_KEY_KP_Page_Down:
case XKB_KEY_KP_3:
dx = 1;
break;
default:
break;
}
if (dx != 0 || dy != 0)
emulate_pointer_motion (device, dx, dy);
/* We reschedule each time */
return G_SOURCE_REMOVE;
}
static void
stop_mousekeys_move (MetaInputDeviceNative *device)
{
device->mousekeys_first_motion_time = 0;
device->mousekeys_last_motion_time = 0;
g_clear_handle_id (&device->move_mousekeys_timer, g_source_remove);
}
static void
start_mousekeys_move (ClutterEvent *event,
MetaInputDeviceNative *device)
{
device->last_mousekeys_key = event->key.keyval;
if (device->move_mousekeys_timer != 0)
return;
trigger_mousekeys_move (device);
}
static gboolean
handle_mousekeys_press (ClutterEvent *event,
MetaInputDeviceNative *device)
{
if (!(event->key.flags & CLUTTER_EVENT_FLAG_SYNTHETIC))
stop_mousekeys_move (device);
/* Do not handle mousekeys if NumLock is ON */
if (is_numlock_active (device))
return FALSE;
/* Button selection */
switch (event->key.keyval)
{
case XKB_KEY_KP_Divide:
device->mousekeys_btn = CLUTTER_BUTTON_PRIMARY;
return TRUE;
case XKB_KEY_KP_Multiply:
device->mousekeys_btn = CLUTTER_BUTTON_MIDDLE;
return TRUE;
case XKB_KEY_KP_Subtract:
device->mousekeys_btn = CLUTTER_BUTTON_SECONDARY;
return TRUE;
default:
break;
}
/* Button events */
switch (event->key.keyval)
{
case XKB_KEY_KP_Begin:
case XKB_KEY_KP_5:
emulate_button_click (device);
return TRUE;
case XKB_KEY_KP_Insert:
case XKB_KEY_KP_0:
emulate_button_press (device);
return TRUE;
case XKB_KEY_KP_Decimal:
case XKB_KEY_KP_Delete:
emulate_button_release (device);
return TRUE;
case XKB_KEY_KP_Add:
emulate_button_click (device);
emulate_button_click (device);
return TRUE;
default:
break;
}
/* Pointer motion */
switch (event->key.keyval)
{
case XKB_KEY_KP_1:
case XKB_KEY_KP_2:
case XKB_KEY_KP_3:
case XKB_KEY_KP_4:
case XKB_KEY_KP_6:
case XKB_KEY_KP_7:
case XKB_KEY_KP_8:
case XKB_KEY_KP_9:
case XKB_KEY_KP_Down:
case XKB_KEY_KP_End:
case XKB_KEY_KP_Home:
case XKB_KEY_KP_Left:
case XKB_KEY_KP_Page_Down:
case XKB_KEY_KP_Page_Up:
case XKB_KEY_KP_Right:
case XKB_KEY_KP_Up:
start_mousekeys_move (event, device);
return TRUE;
default:
break;
}
return FALSE;
}
static gboolean
handle_mousekeys_release (ClutterEvent *event,
MetaInputDeviceNative *device)
{
/* Do not handle mousekeys if NumLock is ON */
if (is_numlock_active (device))
return FALSE;
switch (event->key.keyval)
{
case XKB_KEY_KP_0:
case XKB_KEY_KP_1:
case XKB_KEY_KP_2:
case XKB_KEY_KP_3:
case XKB_KEY_KP_4:
case XKB_KEY_KP_5:
case XKB_KEY_KP_6:
case XKB_KEY_KP_7:
case XKB_KEY_KP_8:
case XKB_KEY_KP_9:
case XKB_KEY_KP_Add:
case XKB_KEY_KP_Begin:
case XKB_KEY_KP_Decimal:
case XKB_KEY_KP_Delete:
case XKB_KEY_KP_Divide:
case XKB_KEY_KP_Down:
case XKB_KEY_KP_End:
case XKB_KEY_KP_Home:
case XKB_KEY_KP_Insert:
case XKB_KEY_KP_Left:
case XKB_KEY_KP_Multiply:
case XKB_KEY_KP_Page_Down:
case XKB_KEY_KP_Page_Up:
case XKB_KEY_KP_Right:
case XKB_KEY_KP_Subtract:
case XKB_KEY_KP_Up:
stop_mousekeys_move (device);
return TRUE;
default:
break;
}
return FALSE;
}
static void
meta_input_device_native_process_kbd_a11y_event (ClutterEvent *event,
ClutterInputDevice *device,
ClutterEmitInputDeviceEvent emit_event_func)
{
MetaInputDeviceNative *device_evdev = META_INPUT_DEVICE_NATIVE (device);
/* Ignore key events injected from IM */
if (event->key.flags & CLUTTER_EVENT_FLAG_INPUT_METHOD)
goto emit_event;
if (device_evdev->a11y_flags & META_A11Y_KEYBOARD_ENABLED)
{
if (event->type == CLUTTER_KEY_PRESS)
handle_enablekeys_press (event, device_evdev);
else
handle_enablekeys_release (event, device_evdev);
}
if (device_evdev->a11y_flags & META_A11Y_MOUSE_KEYS_ENABLED)
{
if (event->type == CLUTTER_KEY_PRESS &&
handle_mousekeys_press (event, device_evdev))
return; /* swallow event */
if (event->type == CLUTTER_KEY_RELEASE &&
handle_mousekeys_release (event, device_evdev))
return; /* swallow event */
}
if ((device_evdev->a11y_flags & META_A11Y_BOUNCE_KEYS_ENABLED) &&
(get_debounce_delay (device) != 0))
{
if ((event->type == CLUTTER_KEY_PRESS) && debounce_key (event, device_evdev))
{
notify_bounce_keys_reject (device_evdev);
return;
}
else if (event->type == CLUTTER_KEY_RELEASE)
start_bounce_keys (event, device_evdev);
}
if ((device_evdev->a11y_flags & META_A11Y_SLOW_KEYS_ENABLED) &&
(get_slow_keys_delay (device) != 0))
{
if (event->type == CLUTTER_KEY_PRESS)
start_slow_keys (event, device_evdev, emit_event_func);
else if (event->type == CLUTTER_KEY_RELEASE)
stop_slow_keys (event, device_evdev, emit_event_func);
return;
}
if (device_evdev->a11y_flags & META_A11Y_STICKY_KEYS_ENABLED)
{
if (event->type == CLUTTER_KEY_PRESS)
handle_stickykeys_press (event, device_evdev);
else if (event->type == CLUTTER_KEY_RELEASE)
handle_stickykeys_release (event, device_evdev);
}
emit_event:
emit_event_func (event, device);
}
void
meta_input_device_native_apply_kbd_a11y_settings (MetaInputDeviceNative *device,
MetaKbdA11ySettings *settings)
{
MetaKeyboardA11yFlags changed_flags = (device->a11y_flags ^ settings->controls);
if (changed_flags & (META_A11Y_KEYBOARD_ENABLED | META_A11Y_SLOW_KEYS_ENABLED))
clear_slow_keys (device);
if (changed_flags & (META_A11Y_KEYBOARD_ENABLED | META_A11Y_BOUNCE_KEYS_ENABLED))
device->debounce_key = 0;
if (changed_flags & (META_A11Y_KEYBOARD_ENABLED | META_A11Y_STICKY_KEYS_ENABLED))
{
device->stickykeys_depressed_mask = 0;
update_internal_xkb_state (device, 0, 0);
}
if (changed_flags & META_A11Y_KEYBOARD_ENABLED)
{
device->toggle_slowkeys_timer = 0;
device->shift_count = 0;
device->last_shift_time = 0;
}
if (changed_flags & (META_A11Y_KEYBOARD_ENABLED | META_A11Y_MOUSE_KEYS_ENABLED))
{
if (settings->controls &
(META_A11Y_KEYBOARD_ENABLED | META_A11Y_MOUSE_KEYS_ENABLED))
enable_mousekeys (device);
else
disable_mousekeys (device);
}
update_mousekeys_params (device, settings);
/* Keep our own copy of keyboard a11y features flags to see what changes */
device->a11y_flags = settings->controls;
}
void
meta_input_device_native_a11y_maybe_notify_toggle_keys (MetaInputDeviceNative *device)
{
if (device->a11y_flags & META_A11Y_TOGGLE_KEYS_ENABLED)
meta_input_device_native_bell_notify (device);
}
static void
meta_input_device_native_class_init (MetaInputDeviceNativeClass *klass)
{
ClutterInputDeviceClass *device_manager_class = CLUTTER_INPUT_DEVICE_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = meta_input_device_native_finalize;
object_class->set_property = meta_input_device_native_set_property;
object_class->get_property = meta_input_device_native_get_property;
device_manager_class->keycode_to_evdev = meta_input_device_native_keycode_to_evdev;
device_manager_class->update_from_tool = meta_input_device_native_update_from_tool;
device_manager_class->is_mode_switch_button = meta_input_device_native_is_mode_switch_button;
device_manager_class->get_group_n_modes = meta_input_device_native_get_group_n_modes;
device_manager_class->is_grouped = meta_input_device_native_is_grouped;
device_manager_class->process_kbd_a11y_event = meta_input_device_native_process_kbd_a11y_event;
obj_props[PROP_DEVICE_MATRIX] =
g_param_spec_boxed ("device-matrix",
"Device input matrix",
"Device input matrix",
CAIRO_GOBJECT_TYPE_MATRIX,
CLUTTER_PARAM_READWRITE);
obj_props[PROP_OUTPUT_ASPECT_RATIO] =
g_param_spec_double ("output-aspect-ratio",
"Output aspect ratio",
"Output aspect ratio",
0, G_MAXDOUBLE, 0,
CLUTTER_PARAM_READWRITE);
g_object_class_install_properties (object_class, N_PROPS, obj_props);
}
static void
meta_input_device_native_init (MetaInputDeviceNative *self)
{
cairo_matrix_init_identity (&self->device_matrix);
self->device_aspect_ratio = 0;
self->output_ratio = 0;
}
/*
* meta_input_device_native_new:
* @manager: the device manager
* @seat: the seat the device will belong to
* @libinput_device: the libinput device
*
* Create a new ClutterInputDevice given a libinput device and associate
* it with the provided seat.
*/
ClutterInputDevice *
meta_input_device_native_new (MetaSeatImpl *seat_impl,
struct libinput_device *libinput_device)
{
MetaInputDeviceNative *device;
ClutterInputDeviceType type;
char *vendor, *product;
int n_rings = 0, n_strips = 0, n_groups = 1;
char *node_path;
double width, height;
type = meta_input_device_native_determine_type (libinput_device);
vendor = g_strdup_printf ("%.4x", libinput_device_get_id_vendor (libinput_device));
product = g_strdup_printf ("%.4x", libinput_device_get_id_product (libinput_device));
node_path = g_strdup_printf ("/dev/input/%s", libinput_device_get_sysname (libinput_device));
if (libinput_device_has_capability (libinput_device,
LIBINPUT_DEVICE_CAP_TABLET_PAD))
{
n_rings = libinput_device_tablet_pad_get_num_rings (libinput_device);
n_strips = libinput_device_tablet_pad_get_num_strips (libinput_device);
n_groups = libinput_device_tablet_pad_get_num_mode_groups (libinput_device);
}
device = g_object_new (META_TYPE_INPUT_DEVICE_NATIVE,
"name", libinput_device_get_name (libinput_device),
"device-type", type,
"device-mode", CLUTTER_INPUT_MODE_PHYSICAL,
"vendor-id", vendor,
"product-id", product,
"n-rings", n_rings,
"n-strips", n_strips,
"n-mode-groups", n_groups,
"device-node", node_path,
"seat", seat_impl->seat_native,
NULL);
device->seat_impl = seat_impl;
device->libinput_device = libinput_device;
libinput_device_set_user_data (libinput_device, device);
libinput_device_ref (libinput_device);
g_free (vendor);
g_free (product);
g_free (node_path);
if (libinput_device_get_size (libinput_device, &width, &height) == 0)
device->device_aspect_ratio = width / height;
return CLUTTER_INPUT_DEVICE (device);
}
/*
* meta_input_device_native_new_virtual:
* @seat: the seat the device will belong to
* @type: the input device type
*
* Create a new virtual ClutterInputDevice of the given type.
*/
ClutterInputDevice *
meta_input_device_native_new_virtual (MetaSeatImpl *seat_impl,
ClutterInputDeviceType type,
ClutterInputMode mode)
{
MetaInputDeviceNative *device;
const char *name;
switch (type)
{
case CLUTTER_KEYBOARD_DEVICE:
name = "Virtual keyboard device for seat";
break;
case CLUTTER_POINTER_DEVICE:
name = "Virtual pointer device for seat";
break;
case CLUTTER_TOUCHSCREEN_DEVICE:
name = "Virtual touchscreen device for seat";
break;
default:
name = "Virtual device for seat";
break;
};
device = g_object_new (META_TYPE_INPUT_DEVICE_NATIVE,
"name", name,
"device-type", type,
"device-mode", mode,
"seat", seat_impl->seat_native,
NULL);
device->seat_impl = seat_impl;
return CLUTTER_INPUT_DEVICE (device);
}
MetaSeatImpl *
meta_input_device_native_get_seat_impl (MetaInputDeviceNative *device)
{
return device->seat_impl;
}
void
meta_input_device_native_update_leds (MetaInputDeviceNative *device,
enum libinput_led leds)
{
if (!device->libinput_device)
return;
libinput_device_led_update (device->libinput_device, leds);
}
ClutterInputDeviceType
meta_input_device_native_determine_type (struct libinput_device *ldev)
{
/* This setting is specific to touchpads and alike, only in these
* devices there is this additional layer of touch event interpretation.
*/
if (libinput_device_config_tap_get_finger_count (ldev) > 0)
return CLUTTER_TOUCHPAD_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_TABLET_TOOL))
return CLUTTER_TABLET_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_TABLET_PAD))
return CLUTTER_PAD_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_POINTER))
return CLUTTER_POINTER_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_TOUCH))
return CLUTTER_TOUCHSCREEN_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_KEYBOARD))
return CLUTTER_KEYBOARD_DEVICE;
else
return CLUTTER_EXTENSION_DEVICE;
}
/**
* meta_input_device_native_get_libinput_device:
* @device: a #ClutterInputDevice
*
* Retrieves the libinput_device struct held in @device.
*
* Returns: The libinput_device struct
*
* Since: 1.20
* Stability: unstable
**/
struct libinput_device *
meta_input_device_native_get_libinput_device (ClutterInputDevice *device)
{
MetaInputDeviceNative *device_evdev;
g_return_val_if_fail (META_IS_INPUT_DEVICE_NATIVE (device), NULL);
device_evdev = META_INPUT_DEVICE_NATIVE (device);
return device_evdev->libinput_device;
}
void
meta_input_device_native_translate_coordinates (ClutterInputDevice *device,
MetaViewportInfo *viewports,
float *x,
float *y)
{
MetaInputDeviceNative *device_evdev = META_INPUT_DEVICE_NATIVE (device);
double min_x = 0, min_y = 0, max_x = 1, max_y = 1;
float stage_width, stage_height;
double x_d, y_d;
meta_viewport_info_get_extents (viewports, &stage_width, &stage_height);
x_d = *x / stage_width;
y_d = *y / stage_height;
/* Apply aspect ratio */
if (device_evdev->output_ratio > 0 &&
device_evdev->device_aspect_ratio > 0)
{
double ratio = device_evdev->device_aspect_ratio / device_evdev->output_ratio;
if (ratio > 1)
x_d *= ratio;
else if (ratio < 1)
y_d *= 1 / ratio;
}
cairo_matrix_transform_point (&device_evdev->device_matrix, &min_x, &min_y);
cairo_matrix_transform_point (&device_evdev->device_matrix, &max_x, &max_y);
cairo_matrix_transform_point (&device_evdev->device_matrix, &x_d, &y_d);
*x = CLAMP (x_d, MIN (min_x, max_x), MAX (min_x, max_x)) * stage_width;
*y = CLAMP (y_d, MIN (min_y, max_y), MAX (min_y, max_y)) * stage_height;
}
MetaInputDeviceMapping
meta_input_device_native_get_mapping_mode (ClutterInputDevice *device)
{
MetaInputDeviceNative *device_native = META_INPUT_DEVICE_NATIVE (device);
ClutterInputDeviceType device_type;
g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device),
META_INPUT_DEVICE_MAPPING_ABSOLUTE);
device_type = clutter_input_device_get_device_type (device);
g_return_val_if_fail (device_type == CLUTTER_TABLET_DEVICE ||
device_type == CLUTTER_PEN_DEVICE ||
device_type == CLUTTER_ERASER_DEVICE,
META_INPUT_DEVICE_MAPPING_ABSOLUTE);
return device_native->mapping_mode;
}
void
meta_input_device_native_set_mapping_mode (ClutterInputDevice *device,
MetaInputDeviceMapping mapping)
{
MetaInputDeviceNative *device_native = META_INPUT_DEVICE_NATIVE (device);
ClutterInputDeviceType device_type;
g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
device_type = clutter_input_device_get_device_type (device);
g_return_if_fail (device_type == CLUTTER_TABLET_DEVICE ||
device_type == CLUTTER_PEN_DEVICE ||
device_type == CLUTTER_ERASER_DEVICE);
device_native->mapping_mode = mapping;
}
void
meta_input_device_native_set_coords (MetaInputDeviceNative *device_native,
float x,
float y)
{
device_native->pointer_x = x;
device_native->pointer_y = y;
}
void
meta_input_device_native_get_coords (MetaInputDeviceNative *device_native,
float *x,
float *y)
{
if (x)
*x = device_native->pointer_x;
if (y)
*y = device_native->pointer_y;
}
Reference in New Issue View Git Blame Copy Permalink