isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-27 13:22:15 +00:00
Code Issues Packages Projects Releases Wiki Activity
9b5b432533
mutter/clutter/evdev/clutter-device-manager-evdev.c

1591 lines
46 KiB
C
Raw Normal View History

evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corp.
*
* 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>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
#include <math.h>
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
#include <linux/input.h>
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <glib.h>
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
#include <gudev/gudev.h>
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
#include <libevdev/libevdev.h>
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
#include "clutter-backend.h"
#include "clutter-debug.h"
#include "clutter-device-manager.h"
#include "clutter-device-manager-private.h"
Add private header for event-related API
2011-02-18 16:27:49 +00:00
#include "clutter-event-private.h"
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
#include "clutter-input-device-evdev.h"
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
#include "clutter-main.h"
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
#include "clutter-private.h"
evdev: don't even process events without a default stage The evdev system is a bit different from other input systems in Clutter because it's completly decorrelated from anything graphic. In the case of embedded devices with no proper windowing system, you might want to not implicitly create a default stage when you're receiving the first input event. This patch changes this behavior by not forwarding any event if you don't have a default stage. Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> https://bugzilla.gnome.org/show_bug.cgi?id=651718
2011-06-17 10:31:34 +00:00
#include "clutter-stage-manager.h"
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
#include "clutter-xkb-utils.h"
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
#include "clutter-backend-private.h"
wayland: Fix some missing includes The commit 90e5088 added some extra compiler warning options that were triggering warnings when enabling the wayland build due to missing header includes. This adds those header includes in. Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-03-09 18:24:14 +00:00
#include "clutter-evdev.h"
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
#include "clutter-device-manager-evdev.h"
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
/* These are the same as the XInput2 IDs */
#define CORE_POINTER_ID 2
#define CORE_KEYBOARD_ID 3
#define FIRST_SLAVE_ID 4
#define INVALID_SLAVE_ID 255
evdev: don't update xkb state for autorepeated keys xkb_state_update_key() needs to be called only on state transitions, otherwise the state tracking gets confused and locks certain modifiers forever. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:07:52 +00:00
#define AUTOREPEAT_VALUE 2
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
/* Taken from weston/src/evdev-touchpad.c
In the future, we may want to make this configurable, or
delegate everything to loadable input drivers.
*/
#define DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR 700.0
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
struct _ClutterDeviceManagerEvdevPrivate
{
GUdevClient *udev_client;
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
ClutterStage *stage;
gboolean released;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
GSList *devices; /* list of ClutterInputDeviceEvdevs */
GSList *event_sources; /* list of the event sources */
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
ClutterInputDevice *core_pointer;
ClutterInputDevice *core_keyboard;
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
evdev: add callback to constrain the pointer position Add a new callback that is called prior to emitting pointer motion events and that can modify the new pointer position. The main purpose is allowing multiscreen apps to prevent the pointer for entering the dead area that exists when the screens are not the same size, but it could also used to implement pointer barriers. A callback is needed to make sure that the hook is called early enough and the Clutter state is always consistent. https://bugzilla.gnome.org/show_bug.cgi?id=706652
2013-08-23 10:15:40 +00:00
ClutterPointerConstrainCallback constrain_callback;
gpointer constrain_data;
GDestroyNotify constrain_data_notify;
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
ClutterStageManager *stage_manager;
guint stage_added_handler;
guint stage_removed_handler;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
evdev: allow hooking directly into libxkbcommon A wayland compositor needs to have more keyboard state than ClutterModifierState exposes, so it makes sense for it to use xkb_state directly. Also, it makes sense for it to provide it's own keymap, to ensure a consistent view between the compositor and the wayland clients. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:06:39 +00:00
GArray *keys;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
struct xkb_state *xkb; /* XKB state object */
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
xkb_led_index_t caps_lock_led;
xkb_led_index_t num_lock_led;
xkb_led_index_t scroll_lock_led;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
uint32_t button_state;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
};
Use the new macros for adding private data
2013-07-03 13:14:01 +00:00
G_DEFINE_TYPE_WITH_PRIVATE (ClutterDeviceManagerEvdev,
clutter_device_manager_evdev,
CLUTTER_TYPE_DEVICE_MANAGER)
evdev: add a way for applications to tweak how devices are opened In some cases, applications (or actually, wayland compositors) don't have the required permissions to access evdev directly, but can do so with an external helper like weston-launch. Allow them to do so with a custom callback that replaces the regular open() path. https://bugzilla.gnome.org/show_bug.cgi?id=704269
2013-07-15 16:24:35 +00:00
static ClutterOpenDeviceCallback open_callback;
static gpointer open_callback_data;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
static const gchar *subsystems[] = { "input", NULL };
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/*
* ClutterEventSource management
*
* The device manager is responsible for managing the GSource when devices
evdev: Add a comment to revisit the GSource management with glib 2.28 With glib 2.28, we'll be able to have one GSource per device manager with child sources for earch device. Make a note to update the code in a few months.
2010-11-30 14:50:13 +00:00
* appear and disappear from the system.
*
* FIXME: For now, we associate a GSource with every single device. Starting
* from glib 2.28 we can use g_source_add_child_source() to have a single
* GSource for the device manager, each device becoming a child source. Revisit
* this once we depend on glib >= 2.28.
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
*/
build: make internal option_xkb_* symbols static This makes the option_xkb_* symbols declared for the evdev device manager and the wayland device manager private so we don't get symbol collisions if both of these backends are enabled. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-06 21:49:15 +00:00
static const char *option_xkb_layout = "us";
static const char *option_xkb_variant = "";
static const char *option_xkb_options = "";
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/*
* ClutterEventSource for reading input devices
*/
typedef struct _ClutterEventSource ClutterEventSource;
struct _ClutterEventSource
{
GSource source;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ClutterInputDeviceEvdev *device; /* back pointer to the slave evdev device */
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
GPollFD event_poll_fd; /* file descriptor of the /dev node */
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
struct libevdev *dev;
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
/* For mice (and emulated for touchpads) */
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
int dx, dy;
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
/* For touchpads */
gboolean touching;
int margin;
int last_x, last_y;
int cur_x, cur_y;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
};
static gboolean
clutter_event_prepare (GSource *source,
gint *timeout)
{
gboolean retval;
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_acquire_lock ();
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
*timeout = -1;
retval = clutter_events_pending ();
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_release_lock ();
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
return retval;
}
static gboolean
clutter_event_check (GSource *source)
{
ClutterEventSource *event_source = (ClutterEventSource *) source;
gboolean retval;
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_acquire_lock ();
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
retval = ((event_source->event_poll_fd.revents & G_IO_IN) ||
clutter_events_pending ());
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_release_lock ();
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
return retval;
}
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
static void
queue_event (ClutterEvent *event)
{
*/event: Never manipulate the event queue directly Always use _clutter_event_push() instead.
2011-01-19 16:34:49 +00:00
_clutter_event_push (event, FALSE);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
}
evdev: allow hooking directly into libxkbcommon A wayland compositor needs to have more keyboard state than ClutterModifierState exposes, so it makes sense for it to use xkb_state directly. Also, it makes sense for it to provide it's own keymap, to ensure a consistent view between the compositor and the wayland clients. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:06:39 +00:00
static void
add_key (GArray *keys,
guint32 key)
{
g_array_append_val (keys, key);
}
static void
remove_key (GArray *keys,
guint32 key)
{
unsigned int i;
for (i = 0; i < keys->len; i++)
{
if (g_array_index (keys, guint32, i) == key)
{
g_array_remove_index_fast (keys, i);
return;
}
}
}
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
static void
sync_leds (ClutterDeviceManagerEvdev *manager_evdev)
{
ClutterDeviceManagerEvdevPrivate *priv = manager_evdev->priv;
GSList *iter;
int caps_lock, num_lock, scroll_lock;
caps_lock = xkb_state_led_index_is_active (priv->xkb, priv->caps_lock_led);
num_lock = xkb_state_led_index_is_active (priv->xkb, priv->num_lock_led);
scroll_lock = xkb_state_led_index_is_active (priv->xkb, priv->scroll_lock_led);
for (iter = priv->event_sources; iter; iter = iter->next)
{
ClutterEventSource *source = iter->data;
if (libevdev_has_event_type (source->dev, EV_LED))
libevdev_kernel_set_led_values (source->dev,
LED_CAPSL, caps_lock == 1 ? LIBEVDEV_LED_ON : LIBEVDEV_LED_OFF,
LED_NUML, num_lock == 1 ? LIBEVDEV_LED_ON : LIBEVDEV_LED_OFF,
LED_SCROLLL, scroll_lock == 1 ? LIBEVDEV_LED_ON : LIBEVDEV_LED_OFF,
-1);
}
}
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
static void
evdev: sync the keyboard state when releasing and reclaiming devices When we release a device, we lose all the events after that point, so our state can become stale. Similarly, we need to sync the state with the effectively pressed keys when we reclaim. This ensures that modifier keys don't get stuck when switching VTs using a keybinding. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 13:59:21 +00:00
notify_key_device (ClutterInputDevice *input_device,
guint32 time_,
guint32 key,
guint32 state,
gboolean update_keys)
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
{
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ClutterDeviceManagerEvdev *manager_evdev;
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
ClutterStage *stage;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
ClutterEvent *event = NULL;
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
enum xkb_state_component changed_state;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
/* We can drop the event on the floor if no stage has been
* associated with the device yet. */
stage = _clutter_input_device_get_stage (input_device);
if (!stage)
return;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (input_device->device_manager);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
event = _clutter_key_event_new_from_evdev (input_device,
manager_evdev->priv->core_keyboard,
stage,
manager_evdev->priv->xkb,
manager_evdev->priv->button_state,
time_, key, state);
/* We must be careful and not pass multiple releases to xkb, otherwise it gets
confused and locks the modifiers */
if (state != AUTOREPEAT_VALUE)
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
{
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
changed_state = xkb_state_update_key (manager_evdev->priv->xkb, event->key.hardware_keycode, state ? XKB_KEY_DOWN : XKB_KEY_UP);
if (update_keys)
evdev: don't update xkb state for autorepeated keys xkb_state_update_key() needs to be called only on state transitions, otherwise the state tracking gets confused and locks certain modifiers forever. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:07:52 +00:00
{
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
if (state)
add_key (manager_evdev->priv->keys, event->key.hardware_keycode);
else
remove_key (manager_evdev->priv->keys, event->key.hardware_keycode);
evdev: don't update xkb state for autorepeated keys xkb_state_update_key() needs to be called only on state transitions, otherwise the state tracking gets confused and locks certain modifiers forever. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:07:52 +00:00
}
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
}
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
else
changed_state = 0;
queue_event (event);
if (update_keys && (changed_state & XKB_STATE_LEDS))
sync_leds (manager_evdev);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
}
evdev: sync the keyboard state when releasing and reclaiming devices When we release a device, we lose all the events after that point, so our state can become stale. Similarly, we need to sync the state with the effectively pressed keys when we reclaim. This ensures that modifier keys don't get stuck when switching VTs using a keybinding. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 13:59:21 +00:00
static void
notify_key (ClutterEventSource *source,
guint32 time_,
guint32 key,
guint32 state)
{
ClutterInputDevice *input_device = (ClutterInputDevice *) source->device;
notify_key_device (input_device, time_, key, state, TRUE);
}
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
static void
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
notify_relative_motion (ClutterEventSource *source,
guint32 time_,
gint dx,
gint dy)
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
{
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
ClutterInputDevice *input_device = (ClutterInputDevice *) source->device;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
gfloat stage_width, stage_height, new_x, new_y;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ClutterDeviceManagerEvdev *manager_evdev;
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
ClutterStage *stage;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ClutterEvent *event = NULL;
ClutterPoint point;
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
/* We can drop the event on the floor if no stage has been
* associated with the device yet. */
stage = _clutter_input_device_get_stage (input_device);
if (!stage)
return;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (input_device->device_manager);
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
stage_width = clutter_actor_get_width (CLUTTER_ACTOR (stage));
stage_height = clutter_actor_get_height (CLUTTER_ACTOR (stage));
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
event = clutter_event_new (CLUTTER_MOTION);
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
clutter_input_device_get_coords (manager_evdev->priv->core_pointer, NULL, &point);
new_x = point.x + dx;
new_y = point.y + dy;
evdev: add callback to constrain the pointer position Add a new callback that is called prior to emitting pointer motion events and that can modify the new pointer position. The main purpose is allowing multiscreen apps to prevent the pointer for entering the dead area that exists when the screens are not the same size, but it could also used to implement pointer barriers. A callback is needed to make sure that the hook is called early enough and the Clutter state is always consistent. https://bugzilla.gnome.org/show_bug.cgi?id=706652
2013-08-23 10:15:40 +00:00
if (manager_evdev->priv->constrain_callback)
{
manager_evdev->priv->constrain_callback (manager_evdev->priv->core_pointer, time_, &new_x, &new_y,
manager_evdev->priv->constrain_data);
}
else
{
new_x = CLAMP (new_x, 0.f, stage_width - 1);
new_y = CLAMP (new_y, 0.f, stage_height - 1);
}
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
event->motion.time = time_;
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
event->motion.stage = stage;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
event->motion.device = manager_evdev->priv->core_pointer;
ClutterEvent: add API to query the full keyboard state when the event was generated When talking to other applications or serializing the modifier state (and in particular when implementing a wayland compositor), the effective modifier state alone is not sufficient, one needs to know the base, latched and locked modifiers. Previously one could do with backend specific functionality such as clutter_device_manager_evdev_get_xkb_state(), but the problem is that the internal data structures are updated as soon as the events are fetched from the upstream source, but the events are reported to the application some time later, and thus the two can get out of sync. This way, on the other hand, the information is cached in the event, and provided to the application with the value that was current when the event was generated. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-04 12:42:56 +00:00
_clutter_xkb_translate_state (event, manager_evdev->priv->xkb, manager_evdev->priv->button_state);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
event->motion.x = new_x;
event->motion.y = new_y;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
clutter_event_set_source_device (event, input_device);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
queue_event (event);
}
evdev: implement wheel events Mouse wheel events come as EV_REL/REL_WHEEL, and we can convert them to clutter events on the assumption that scrolling with the wheel is always vertical. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 16:43:19 +00:00
static void
evdev: implement horizontal scrolling If the kernel reports REL_HWHELL, convert it to horizontal scroll events. Also reorganize a bit the recognition for the other event enums. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 15:54:59 +00:00
notify_scroll (ClutterEventSource *source,
guint32 time_,
gint32 value,
ClutterOrientation orientation)
evdev: implement wheel events Mouse wheel events come as EV_REL/REL_WHEEL, and we can convert them to clutter events on the assumption that scrolling with the wheel is always vertical. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 16:43:19 +00:00
{
ClutterInputDevice *input_device = (ClutterInputDevice *) source->device;
ClutterDeviceManagerEvdev *manager_evdev;
ClutterStage *stage;
ClutterEvent *event = NULL;
ClutterPoint point;
/* We can drop the event on the floor if no stage has been
* associated with the device yet. */
stage = _clutter_input_device_get_stage (input_device);
if (!stage)
return;
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (input_device->device_manager);
event = clutter_event_new (CLUTTER_SCROLL);
event->scroll.time = time_;
event->scroll.stage = CLUTTER_STAGE (stage);
event->scroll.device = manager_evdev->priv->core_pointer;
ClutterEvent: add API to query the full keyboard state when the event was generated When talking to other applications or serializing the modifier state (and in particular when implementing a wayland compositor), the effective modifier state alone is not sufficient, one needs to know the base, latched and locked modifiers. Previously one could do with backend specific functionality such as clutter_device_manager_evdev_get_xkb_state(), but the problem is that the internal data structures are updated as soon as the events are fetched from the upstream source, but the events are reported to the application some time later, and thus the two can get out of sync. This way, on the other hand, the information is cached in the event, and provided to the application with the value that was current when the event was generated. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-04 12:42:56 +00:00
_clutter_xkb_translate_state (event, manager_evdev->priv->xkb, manager_evdev->priv->button_state);
evdev: implement horizontal scrolling If the kernel reports REL_HWHELL, convert it to horizontal scroll events. Also reorganize a bit the recognition for the other event enums. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 15:54:59 +00:00
if (orientation == CLUTTER_ORIENTATION_VERTICAL)
event->scroll.direction = value < 0 ? CLUTTER_SCROLL_DOWN : CLUTTER_SCROLL_UP;
else
event->scroll.direction = value < 0 ? CLUTTER_SCROLL_LEFT : CLUTTER_SCROLL_RIGHT;
evdev: implement wheel events Mouse wheel events come as EV_REL/REL_WHEEL, and we can convert them to clutter events on the assumption that scrolling with the wheel is always vertical. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 16:43:19 +00:00
clutter_input_device_get_coords (manager_evdev->priv->core_pointer, NULL, &point);
event->scroll.x = point.x;
event->scroll.y = point.y;
clutter_event_set_source_device (event, (ClutterInputDevice*) source->device);
queue_event (event);
}
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
static void
notify_button (ClutterEventSource *source,
guint32 time_,
guint32 button,
guint32 state)
{
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
ClutterInputDevice *input_device = (ClutterInputDevice *) source->device;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ClutterDeviceManagerEvdev *manager_evdev;
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
ClutterStage *stage;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ClutterEvent *event = NULL;
ClutterPoint point;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
gint button_nr;
evdev: Don't oveflow when translating buttons to masks An array is used to translate the button to its mask. Clutter defines the masks for button 1 to 5 but we report BTN_LEFT..BTN_TASK ie 0x110..0x117. We need to pad the array for the translation not to access random data for buttons between 0x115 and 0x117.
2010-11-19 19:19:52 +00:00
static gint maskmap[8] =
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
{
evdev: Swap the numbers for the middle and right buttons The ordering of the evdev button numbers is the opposite of the order in Clutter (the middle button is 3 instead of 2) so we need to manually map the button numbers when creating a ClutterButtonEvent. https://bugzilla.gnome.org/show_bug.cgi?id=680255
2012-07-19 14:20:42 +00:00
CLUTTER_BUTTON1_MASK, CLUTTER_BUTTON3_MASK, CLUTTER_BUTTON2_MASK,
evdev: Don't oveflow when translating buttons to masks An array is used to translate the button to its mask. Clutter defines the masks for button 1 to 5 but we report BTN_LEFT..BTN_TASK ie 0x110..0x117. We need to pad the array for the translation not to access random data for buttons between 0x115 and 0x117.
2010-11-19 19:19:52 +00:00
CLUTTER_BUTTON4_MASK, CLUTTER_BUTTON5_MASK, 0, 0, 0
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
};
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
/* We can drop the event on the floor if no stage has been
* associated with the device yet. */
stage = _clutter_input_device_get_stage (input_device);
if (!stage)
return;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (input_device->device_manager);
evdev: Swap the numbers for the middle and right buttons The ordering of the evdev button numbers is the opposite of the order in Clutter (the middle button is 3 instead of 2) so we need to manually map the button numbers when creating a ClutterButtonEvent. https://bugzilla.gnome.org/show_bug.cgi?id=680255
2012-07-19 14:20:42 +00:00
/* The evdev button numbers don't map sequentially to clutter button
* numbers (the right and middle mouse buttons are in the opposite
* order) so we'll map them directly with a switch statement */
switch (button)
{
case BTN_LEFT:
button_nr = CLUTTER_BUTTON_PRIMARY;
break;
case BTN_RIGHT:
button_nr = CLUTTER_BUTTON_SECONDARY;
break;
case BTN_MIDDLE:
button_nr = CLUTTER_BUTTON_MIDDLE;
break;
default:
button_nr = button - BTN_MOUSE + 1;
break;
}
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
if (G_UNLIKELY (button_nr < 1 || button_nr > 8))
{
g_warning ("Unhandled button event 0x%x", button);
return;
}
if (state)
event = clutter_event_new (CLUTTER_BUTTON_PRESS);
else
event = clutter_event_new (CLUTTER_BUTTON_RELEASE);
evdev: Fix missing ClutterEventSource member https://bugzilla.gnome.org/show_bug.cgi?id=686692
2012-12-18 00:45:00 +00:00
/* Update the modifiers */
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
if (state)
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
manager_evdev->priv->button_state |= maskmap[button - BTN_LEFT];
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
else
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
manager_evdev->priv->button_state &= ~maskmap[button - BTN_LEFT];
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
event->button.time = time_;
event->button.stage = CLUTTER_STAGE (stage);
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
event->button.device = manager_evdev->priv->core_pointer;
ClutterEvent: add API to query the full keyboard state when the event was generated When talking to other applications or serializing the modifier state (and in particular when implementing a wayland compositor), the effective modifier state alone is not sufficient, one needs to know the base, latched and locked modifiers. Previously one could do with backend specific functionality such as clutter_device_manager_evdev_get_xkb_state(), but the problem is that the internal data structures are updated as soon as the events are fetched from the upstream source, but the events are reported to the application some time later, and thus the two can get out of sync. This way, on the other hand, the information is cached in the event, and provided to the application with the value that was current when the event was generated. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-04 12:42:56 +00:00
_clutter_xkb_translate_state (event, manager_evdev->priv->xkb, manager_evdev->priv->button_state);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
event->button.button = button_nr;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
clutter_input_device_get_coords (manager_evdev->priv->core_pointer, NULL, &point);
event->button.x = point.x;
event->button.y = point.y;
clutter_event_set_source_device (event, (ClutterInputDevice*) source->device);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
queue_event (event);
}
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
static void
process_absolute_motion (ClutterEventSource *source)
{
/* Compute deltas and update absolute positions */
if (source->touching)
{
source->dx = source->cur_x - source->last_x;
source->dy = source->cur_y - source->last_y;
source->last_x = source->cur_x;
source->last_y = source->cur_y;
}
}
static void
process_relative_motion (ClutterEventSource *source,
guint32 _time)
{
/* Flush accumulated motion deltas */
if (source->dx != 0 || source->dy != 0)
{
notify_relative_motion (source, _time, source->dx, source->dy);
source->dx = 0;
source->dy = 0;
}
}
static inline int
hysteresis (int in, int center, int margin)
{
int diff = in - center;
if (ABS (diff) <= margin)
return center;
if (diff > margin)
return center + diff - margin;
else if (diff < -margin)
return center + diff + margin;
return center + diff;
}
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
static void
dispatch_one_event (ClutterEventSource *source,
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
struct input_event *e)
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
{
guint32 _time;
_time = e->time.tv_sec * 1000 + e->time.tv_usec / 1000;
switch (e->type)
{
case EV_KEY:
evdev: implement horizontal scrolling If the kernel reports REL_HWHELL, convert it to horizontal scroll events. Also reorganize a bit the recognition for the other event enums. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 15:54:59 +00:00
if (e->code < BTN_MISC || (e->code >= KEY_OK && e->code < BTN_TRIGGER_HAPPY))
notify_key (source, _time, e->code, e->value);
else if (e->code >= BTN_MOUSE && e->code < BTN_JOYSTICK)
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
{
evdev: implement horizontal scrolling If the kernel reports REL_HWHELL, convert it to horizontal scroll events. Also reorganize a bit the recognition for the other event enums. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 15:54:59 +00:00
/* don't repeat mouse buttons */
if (e->value != AUTOREPEAT_VALUE)
notify_button (source, _time, e->code, e->value);
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
}
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
else if (e->code == BTN_TOOL_FINGER && e->value != AUTOREPEAT_VALUE)
{
source->touching = e->value;
if (e->value)
{
source->last_x = source->cur_x;
source->last_y = source->cur_y;
}
}
evdev: implement horizontal scrolling If the kernel reports REL_HWHELL, convert it to horizontal scroll events. Also reorganize a bit the recognition for the other event enums. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 15:54:59 +00:00
else
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
{
/* We don't know about this code, ignore */
}
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
break;
case EV_SYN:
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
if (e->code == SYN_REPORT)
{
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
process_absolute_motion (source);
process_relative_motion (source, _time);
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
}
break;
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
case EV_MSC:
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
/* Nothing to do here */
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
break;
case EV_REL:
/* compress the EV_REL events in dx/dy */
switch (e->code)
{
case REL_X:
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
source->dx += e->value;
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
break;
case REL_Y:
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
source->dy += e->value;
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
break;
case REL_WHEEL:
evdev: implement horizontal scrolling If the kernel reports REL_HWHELL, convert it to horizontal scroll events. Also reorganize a bit the recognition for the other event enums. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 15:54:59 +00:00
notify_scroll (source, _time, e->value, CLUTTER_ORIENTATION_VERTICAL);
break;
case REL_HWHEEL:
notify_scroll (source, _time, e->value, CLUTTER_ORIENTATION_HORIZONTAL);
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
break;
}
break;
case EV_ABS:
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
switch (e->code)
{
case ABS_X:
source->cur_x = hysteresis (e->value, source->cur_x, source->margin);
break;
case ABS_Y:
source->cur_y = hysteresis (e->value, source->cur_y, source->margin);
break;
}
break;
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
default:
g_warning ("Unhandled event of type %d", e->type);
break;
}
}
static void
sync_source (ClutterEventSource *source)
{
struct input_event ev;
int err;
const gchar *device_path;
/* We read a SYN_DROPPED, ignore it and sync the device */
err = libevdev_next_event (source->dev, LIBEVDEV_READ_SYNC, &ev);
while (err == 1)
{
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
dispatch_one_event (source, &ev);
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
err = libevdev_next_event (source->dev, LIBEVDEV_READ_SYNC, &ev);
}
if (err != -EAGAIN && CLUTTER_HAS_DEBUG (EVENT))
{
device_path = _clutter_input_device_evdev_get_device_path (source->device);
CLUTTER_NOTE (EVENT, "Could not sync device (%s).", device_path);
}
}
static void
fail_source (ClutterEventSource *source,
int error)
{
ClutterDeviceManager *manager;
ClutterInputDevice *device;
const gchar *device_path;
device = CLUTTER_INPUT_DEVICE (source->device);
if (CLUTTER_HAS_DEBUG (EVENT))
{
device_path = _clutter_input_device_evdev_get_device_path (source->device);
CLUTTER_NOTE (EVENT, "Could not read device (%s): %s. Removing.",
device_path, strerror (error));
}
/* remove the faulty device */
manager = clutter_device_manager_get_default ();
_clutter_device_manager_remove_device (manager, device);
}
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
static gboolean
clutter_event_dispatch (GSource *g_source,
GSourceFunc callback,
gpointer user_data)
{
ClutterEventSource *source = (ClutterEventSource *) g_source;
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
ClutterInputDevice *input_device = (ClutterInputDevice *) source->device;
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
struct input_event ev;
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
ClutterEvent *event;
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
ClutterStage *stage;
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
int err;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_acquire_lock ();
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
evdev: fixes evdev build issues + don't ref default stage This updates the evdev input backend code to compile and also updates the code to not refer to the default stage and instead check for a stage to be associated with the input device. If no stage is currently associated with a device generating events then the events are dropped on the floor. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-12-05 13:59:12 +00:00
stage = _clutter_input_device_get_stage (input_device);
evdev: don't even process events without a default stage The evdev system is a bit different from other input systems in Clutter because it's completly decorrelated from anything graphic. In the case of embedded devices with no proper windowing system, you might want to not implicitly create a default stage when you're receiving the first input event. This patch changes this behavior by not forwarding any event if you don't have a default stage. Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> https://bugzilla.gnome.org/show_bug.cgi?id=651718
2011-06-17 10:31:34 +00:00
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/* Don't queue more events if we haven't finished handling the previous batch
*/
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
if (clutter_events_pending ())
goto queue_event;
err = libevdev_next_event (source->dev, LIBEVDEV_READ_NORMAL, &ev);
while (err != -EAGAIN)
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
{
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
if (err == 1)
sync_source (source);
else if (err == 0)
evdev: use EV_SYN/SYN_REPORT for dispatching motion events We can't dispatch a motion event for EV_REL (because we don't have yet the other half of the event), but we can't also queue them at the end of processing (because we may lose some history or have button/keys intermixed). Instead, we use EV_SYN, which means "one logical event was completed", and let the winsys-independent code do the actual motion compression. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:29:47 +00:00
dispatch_one_event (source, &ev);
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
else
{
fail_source (source, -err);
goto out;
}
err = libevdev_next_event (source->dev, LIBEVDEV_READ_NORMAL, &ev);
}
queue_event:
/* Drop events if we don't have any stage to forward them to */
if (stage == NULL)
goto out;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/* Pop an event off the queue if any */
event = clutter_event_get ();
if (event)
{
evdev: update the state of the core pointer and core keyboard for all events These two devices are logically tied togheter, and their state should always be the same. Also, we need to update them after the event is queued, as the current modifier state (as opposed to the modifier mask in the event) should include also the effect of the last key press/release. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-04 11:36:41 +00:00
ClutterModifierType event_state;
ClutterInputDevice *input_device;
ClutterDeviceManagerEvdev *manager_evdev;
input_device = CLUTTER_INPUT_DEVICE (source->device);
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (input_device->device_manager);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/* forward the event into clutter for emission etc. */
clutter_do_event (event);
clutter_event_free (event);
evdev: update the state of the core pointer and core keyboard for all events These two devices are logically tied togheter, and their state should always be the same. Also, we need to update them after the event is queued, as the current modifier state (as opposed to the modifier mask in the event) should include also the effect of the last key press/release. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-04 11:36:41 +00:00
/* update the device states *after* the event */
event_state = xkb_state_serialize_mods (manager_evdev->priv->xkb, XKB_STATE_MODS_EFFECTIVE);
_clutter_input_device_set_state (manager_evdev->priv->core_pointer, event_state);
_clutter_input_device_set_state (manager_evdev->priv->core_keyboard, event_state);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
}
out:
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_release_lock ();
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
return TRUE;
}
static GSourceFuncs event_funcs = {
clutter_event_prepare,
clutter_event_check,
clutter_event_dispatch,
NULL
};
static GSource *
clutter_event_source_new (ClutterInputDeviceEvdev *input_device)
{
GSource *source = g_source_new (&event_funcs, sizeof (ClutterEventSource));
ClutterEventSource *event_source = (ClutterEventSource *) source;
const gchar *node_path;
evdev: use monotonic times for the events The monotonic clock is what X uses too, so this way the timestamps can be compared. https://bugzilla.gnome.org/show_bug.cgi?id=706543
2013-08-21 22:19:21 +00:00
gint fd, clkid;
evdev: add a way for applications to tweak how devices are opened In some cases, applications (or actually, wayland compositors) don't have the required permissions to access evdev directly, but can do so with an external helper like weston-launch. Allow them to do so with a custom callback that replaces the regular open() path. https://bugzilla.gnome.org/show_bug.cgi?id=704269
2013-07-15 16:24:35 +00:00
GError *error;
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
ClutterInputDeviceType device_type;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/* grab the udev input device node and open it */
node_path = _clutter_input_device_evdev_get_device_path (input_device);
CLUTTER_NOTE (EVENT, "Creating GSource for device %s", node_path);
evdev: add a way for applications to tweak how devices are opened In some cases, applications (or actually, wayland compositors) don't have the required permissions to access evdev directly, but can do so with an external helper like weston-launch. Allow them to do so with a custom callback that replaces the regular open() path. https://bugzilla.gnome.org/show_bug.cgi?id=704269
2013-07-15 16:24:35 +00:00
if (open_callback)
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
{
evdev: add a way for applications to tweak how devices are opened In some cases, applications (or actually, wayland compositors) don't have the required permissions to access evdev directly, but can do so with an external helper like weston-launch. Allow them to do so with a custom callback that replaces the regular open() path. https://bugzilla.gnome.org/show_bug.cgi?id=704269
2013-07-15 16:24:35 +00:00
error = NULL;
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
fd = open_callback (node_path, O_RDWR | O_NONBLOCK, open_callback_data, &error);
evdev: add a way for applications to tweak how devices are opened In some cases, applications (or actually, wayland compositors) don't have the required permissions to access evdev directly, but can do so with an external helper like weston-launch. Allow them to do so with a custom callback that replaces the regular open() path. https://bugzilla.gnome.org/show_bug.cgi?id=704269
2013-07-15 16:24:35 +00:00
if (fd < 0)
{
g_warning ("Could not open device %s: %s", node_path, error->message);
g_error_free (error);
return NULL;
}
}
else
{
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
fd = open (node_path, O_RDWR | O_NONBLOCK);
evdev: add a way for applications to tweak how devices are opened In some cases, applications (or actually, wayland compositors) don't have the required permissions to access evdev directly, but can do so with an external helper like weston-launch. Allow them to do so with a custom callback that replaces the regular open() path. https://bugzilla.gnome.org/show_bug.cgi?id=704269
2013-07-15 16:24:35 +00:00
if (fd < 0)
{
g_warning ("Could not open device %s: %s", node_path, strerror (errno));
return NULL;
}
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
}
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
/* Tell evdev to use the monotonic clock for its timestamps */
clkid = CLOCK_MONOTONIC;
ioctl (fd, EVIOCSCLOCKID, &clkid);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/* setup the source */
event_source->device = input_device;
event_source->event_poll_fd.fd = fd;
event_source->event_poll_fd.events = G_IO_IN;
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
libevdev_new_from_fd (fd, &event_source->dev);
evdev: use monotonic times for the events The monotonic clock is what X uses too, so this way the timestamps can be compared. https://bugzilla.gnome.org/show_bug.cgi?id=706543
2013-08-21 22:19:21 +00:00
evdev: add minimal support for touchpads The added support is very very basic (single touch, motion only, no acceleration, no pressure recognition), but anything more complex requires a state machine that will be hopefully provided by libinputcommon in the future. And at least, with this patch the pointer moves, which will be useful for people testing wayland in 3.10 without a physical mouse. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-09 08:51:11 +00:00
device_type = clutter_input_device_get_device_type (CLUTTER_INPUT_DEVICE (input_device));
if (device_type == CLUTTER_TOUCHPAD_DEVICE)
{
const struct input_absinfo *info_x, *info_y;
double width, height, diagonal;
info_x = libevdev_get_abs_info (event_source->dev, ABS_X);
info_y = libevdev_get_abs_info (event_source->dev, ABS_Y);
width = ABS (info_x->maximum - info_x->minimum);
height = ABS (info_y->maximum - info_y->minimum);
diagonal = sqrt (width * width + height * height);
event_source->margin = diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
}
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/* and finally configure and attach the GSource */
g_source_set_priority (source, CLUTTER_PRIORITY_EVENTS);
g_source_add_poll (source, &event_source->event_poll_fd);
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
return source;
}
static void
clutter_event_source_free (ClutterEventSource *source)
{
GSource *g_source = (GSource *) source;
const gchar *node_path;
node_path = _clutter_input_device_evdev_get_device_path (source->device);
CLUTTER_NOTE (EVENT, "Removing GSource for device %s", node_path);
/* ignore the return value of close, it's not like we can do something
* about it */
close (source->event_poll_fd.fd);
evdev: switch to libevdev for fetching the events libevdev is a library that wraps the evdev subsystem, with the ability to synchronize the state after a SYN_DROPPED event from the kernel. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:03:29 +00:00
libevdev_free (source->dev);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
g_source_destroy (g_source);
g_source_unref (g_source);
}
static ClutterEventSource *
find_source_by_device (ClutterDeviceManagerEvdev *manager,
ClutterInputDevice *device)
{
ClutterDeviceManagerEvdevPrivate *priv = manager->priv;
GSList *l;
for (l = priv->event_sources; l; l = g_slist_next (l))
{
ClutterEventSource *source = l->data;
if (source->device == (ClutterInputDeviceEvdev *) device)
return source;
}
return NULL;
}
evdev: Make sure we only add evdev devices Let's use the sysfs path of the device to make sure we only load evdev device, not legacy mousedev ones for instance. We rely on the sysfs API/ABI guarantees and look for devices finishing by /input%d/event%d.
2010-11-08 16:38:16 +00:00
static gboolean
is_evdev (const gchar *sysfs_path)
{
GRegex *regex;
gboolean match;
regex = g_regex_new ("/input[0-9]+/event[0-9]+$", 0, 0, NULL);
match = g_regex_match (regex, sysfs_path, 0, NULL);
g_regex_unref (regex);
return match;
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
static void
evdev_add_device (ClutterDeviceManagerEvdev *manager_evdev,
GUdevDevice *udev_device)
{
ClutterDeviceManager *manager = (ClutterDeviceManager *) manager_evdev;
ClutterInputDeviceType type = CLUTTER_EXTENSION_DEVICE;
ClutterInputDevice *device;
uniquely name and enable evdev ClutterInputDevice objects on creation http://bugzilla.clutter-project.org/show_bug.cgi?id=2631
2011-04-12 15:32:43 +00:00
const gchar *device_file, *sysfs_path, *device_name;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
int id, ok;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
evdev: Make sure we only add evdev devices Let's use the sysfs path of the device to make sure we only load evdev device, not legacy mousedev ones for instance. We rely on the sysfs API/ABI guarantees and look for devices finishing by /input%d/event%d.
2010-11-08 16:38:16 +00:00
device_file = g_udev_device_get_device_file (udev_device);
sysfs_path = g_udev_device_get_sysfs_path (udev_device);
uniquely name and enable evdev ClutterInputDevice objects on creation http://bugzilla.clutter-project.org/show_bug.cgi?id=2631
2011-04-12 15:32:43 +00:00
device_name = g_udev_device_get_name (udev_device);
evdev: Make sure we only add evdev devices Let's use the sysfs path of the device to make sure we only load evdev device, not legacy mousedev ones for instance. We rely on the sysfs API/ABI guarantees and look for devices finishing by /input%d/event%d.
2010-11-08 16:38:16 +00:00
if (device_file == NULL || sysfs_path == NULL)
return;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
if (g_udev_device_get_property (udev_device, "ID_INPUT") == NULL)
evdev: Make sure we only add evdev devices Let's use the sysfs path of the device to make sure we only load evdev device, not legacy mousedev ones for instance. We rely on the sysfs API/ABI guarantees and look for devices finishing by /input%d/event%d.
2010-11-08 16:38:16 +00:00
return;
/* Make sure to only add evdev devices, ie the device with a sysfs path that
* finishes by input%d/event%d (We don't rely on the node name as this
* policy is enforced by udev rules Vs API/ABI guarantees of sysfs) */
if (!is_evdev (sysfs_path))
return;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
determine evdev device type using g_udev_device_has_property http://bugzilla.clutter-project.org/show_bug.cgi?id=2631
2011-04-12 15:33:58 +00:00
/* Clutter assumes that device types are exclusive in the
* ClutterInputDevice API */
if (g_udev_device_has_property (udev_device, "ID_INPUT_KEYBOARD"))
type = CLUTTER_KEYBOARD_DEVICE;
else if (g_udev_device_has_property (udev_device, "ID_INPUT_MOUSE"))
type = CLUTTER_POINTER_DEVICE;
else if (g_udev_device_has_property (udev_device, "ID_INPUT_JOYSTICK"))
type = CLUTTER_JOYSTICK_DEVICE;
else if (g_udev_device_has_property (udev_device, "ID_INPUT_TABLET"))
type = CLUTTER_TABLET_DEVICE;
else if (g_udev_device_has_property (udev_device, "ID_INPUT_TOUCHPAD"))
type = CLUTTER_TOUCHPAD_DEVICE;
else if (g_udev_device_has_property (udev_device, "ID_INPUT_TOUCHSCREEN"))
type = CLUTTER_TOUCHSCREEN_DEVICE;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ok = sscanf (device_file, "/dev/input/event%d", &id);
if (ok == 1)
id += FIRST_SLAVE_ID;
else
id = INVALID_SLAVE_ID;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_EVDEV,
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
"id", id,
uniquely name and enable evdev ClutterInputDevice objects on creation http://bugzilla.clutter-project.org/show_bug.cgi?id=2631
2011-04-12 15:32:43 +00:00
"name", device_name,
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
"device-manager", manager,
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
"device-type", type,
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
"device-mode", CLUTTER_INPUT_MODE_SLAVE,
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
"sysfs-path", sysfs_path,
"device-path", device_file,
uniquely name and enable evdev ClutterInputDevice objects on creation http://bugzilla.clutter-project.org/show_bug.cgi?id=2631
2011-04-12 15:32:43 +00:00
"enabled", TRUE,
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
NULL);
evdev: Add mouse support We know support EV_REL events comming from evdev devices. This addition is pretty straigthforward, it adds a x,y per GSource listening to a evdev device, updates from EL_REL (relative) events and craft new ClutterMotionEvents. As for buttons, BTN_LEFT..BTN_TASK are translated to ClutterButtonEvents with 1..8 as button number.
2010-11-12 00:07:35 +00:00
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
_clutter_input_device_set_stage (device, manager_evdev->priv->stage);
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
_clutter_device_manager_add_device (manager, device);
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
if (type == CLUTTER_KEYBOARD_DEVICE)
{
_clutter_input_device_set_associated_device (device, manager_evdev->priv->core_keyboard);
_clutter_input_device_add_slave (manager_evdev->priv->core_keyboard, device);
}
else
{
_clutter_input_device_set_associated_device (device, manager_evdev->priv->core_pointer);
_clutter_input_device_add_slave (manager_evdev->priv->core_pointer, device);
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
evdev: Make sure we only add evdev devices Let's use the sysfs path of the device to make sure we only load evdev device, not legacy mousedev ones for instance. We rely on the sysfs API/ABI guarantees and look for devices finishing by /input%d/event%d.
2010-11-08 16:38:16 +00:00
CLUTTER_NOTE (EVENT, "Added device %s, type %d, sysfs %s",
device_file, type, sysfs_path);
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
}
evdev: Support hotplug (addition/removal) of evdev devices Just connect to the GUdevClient "uevent" signal and deals with "add"/"remove" commands. This drives the installation/removal of GSource to listen to the device.
2010-11-09 16:56:26 +00:00
static ClutterInputDeviceEvdev *
find_device_by_udev_device (ClutterDeviceManagerEvdev *manager_evdev,
GUdevDevice *udev_device)
{
ClutterDeviceManagerEvdevPrivate *priv = manager_evdev->priv;
GSList *l;
const gchar *sysfs_path;
sysfs_path = g_udev_device_get_sysfs_path (udev_device);
if (sysfs_path == NULL)
{
g_message ("device file is NULL");
return NULL;
}
for (l = priv->devices; l; l = g_slist_next (l))
{
ClutterInputDeviceEvdev *device = l->data;
if (strcmp (sysfs_path,
_clutter_input_device_evdev_get_sysfs_path (device)) == 0)
{
return device;
}
}
return NULL;
}
static void
evdev_remove_device (ClutterDeviceManagerEvdev *manager_evdev,
GUdevDevice *device)
{
ClutterDeviceManager *manager = CLUTTER_DEVICE_MANAGER (manager_evdev);
ClutterInputDeviceEvdev *device_evdev;
ClutterInputDevice *input_device;
device_evdev = find_device_by_udev_device (manager_evdev, device);
if (device_evdev == NULL)
return;
input_device = CLUTTER_INPUT_DEVICE (device_evdev);
_clutter_device_manager_remove_device (manager, input_device);
}
static void
on_uevent (GUdevClient *client,
gchar *action,
GUdevDevice *device,
gpointer data)
{
ClutterDeviceManagerEvdev *manager = CLUTTER_DEVICE_MANAGER_EVDEV (data);
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
ClutterDeviceManagerEvdevPrivate *priv = manager->priv;
if (priv->released)
return;
evdev: Support hotplug (addition/removal) of evdev devices Just connect to the GUdevClient "uevent" signal and deals with "add"/"remove" commands. This drives the installation/removal of GSource to listen to the device.
2010-11-09 16:56:26 +00:00
if (g_strcmp0 (action, "add") == 0)
evdev_add_device (manager, device);
else if (g_strcmp0 (action, "remove") == 0)
evdev_remove_device (manager, device);
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
/*
* ClutterDeviceManager implementation
*/
static void
clutter_device_manager_evdev_add_device (ClutterDeviceManager *manager,
ClutterInputDevice *device)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
ClutterInputDeviceEvdev *device_evdev;
GSource *source;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
priv = manager_evdev->priv;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
device_evdev = CLUTTER_INPUT_DEVICE_EVDEV (device);
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
priv->devices = g_slist_prepend (priv->devices, device);
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
if (clutter_input_device_get_device_mode (device) == CLUTTER_INPUT_MODE_SLAVE)
{
/* Install the GSource for this device */
source = clutter_event_source_new (device_evdev);
g_assert (source != NULL);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
priv->event_sources = g_slist_prepend (priv->event_sources, source);
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
}
static void
clutter_device_manager_evdev_remove_device (ClutterDeviceManager *manager,
ClutterInputDevice *device)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
ClutterEventSource *source;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
priv = manager_evdev->priv;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
/* Remove the device */
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
priv->devices = g_slist_remove (priv->devices, device);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
if (clutter_input_device_get_device_mode (device) == CLUTTER_INPUT_MODE_SLAVE)
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
{
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
/* Remove the source */
source = find_source_by_device (manager_evdev, device);
if (G_UNLIKELY (source == NULL))
{
g_warning ("Trying to remove a device without a source installed ?!");
return;
}
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
clutter_event_source_free (source);
priv->event_sources = g_slist_remove (priv->event_sources, source);
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
}
static const GSList *
clutter_device_manager_evdev_get_devices (ClutterDeviceManager *manager)
{
return CLUTTER_DEVICE_MANAGER_EVDEV (manager)->priv->devices;
}
static ClutterInputDevice *
clutter_device_manager_evdev_get_core_device (ClutterDeviceManager *manager,
ClutterInputDeviceType type)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
priv = manager_evdev->priv;
switch (type)
{
case CLUTTER_POINTER_DEVICE:
return priv->core_pointer;
case CLUTTER_KEYBOARD_DEVICE:
return priv->core_keyboard;
case CLUTTER_EXTENSION_DEVICE:
default:
return NULL;
}
return NULL;
}
static ClutterInputDevice *
clutter_device_manager_evdev_get_device (ClutterDeviceManager *manager,
gint id)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
GSList *l;
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
priv = manager_evdev->priv;
for (l = priv->devices; l; l = l->next)
{
ClutterInputDevice *device = l->data;
if (clutter_input_device_get_device_id (device) == id)
return device;
}
return NULL;
}
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
static void
clutter_device_manager_evdev_probe_devices (ClutterDeviceManagerEvdev *self)
{
ClutterDeviceManagerEvdevPrivate *priv = self->priv;
GList *devices, *l;
devices = g_udev_client_query_by_subsystem (priv->udev_client, subsystems[0]);
for (l = devices; l; l = g_list_next (l))
{
GUdevDevice *device = l->data;
evdev_add_device (self, device);
g_object_unref (device);
}
g_list_free (devices);
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
/*
* GObject implementation
*/
static void
clutter_device_manager_evdev_constructed (GObject *gobject)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
ClutterInputDevice *device;
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
struct xkb_context *ctx;
struct xkb_keymap *keymap;
struct xkb_rule_names names;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (gobject);
priv = manager_evdev->priv;
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_EVDEV,
"id", CORE_POINTER_ID,
"name", "input/core_pointer",
"device-manager", manager_evdev,
"device-type", CLUTTER_POINTER_DEVICE,
"device-mode", CLUTTER_INPUT_MODE_MASTER,
"enabled", TRUE,
NULL);
_clutter_input_device_set_stage (device, priv->stage);
_clutter_device_manager_add_device (CLUTTER_DEVICE_MANAGER (manager_evdev), device);
priv->core_pointer = device;
device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_EVDEV,
"id", CORE_KEYBOARD_ID,
"name", "input/core_keyboard",
"device-manager", manager_evdev,
"device-type", CLUTTER_KEYBOARD_DEVICE,
"device-mode", CLUTTER_INPUT_MODE_MASTER,
"enabled", TRUE,
NULL);
_clutter_input_device_set_stage (device, priv->stage);
_clutter_device_manager_add_device (CLUTTER_DEVICE_MANAGER (manager_evdev), device);
priv->core_keyboard = device;
evdev: allow hooking directly into libxkbcommon A wayland compositor needs to have more keyboard state than ClutterModifierState exposes, so it makes sense for it to use xkb_state directly. Also, it makes sense for it to provide it's own keymap, to ensure a consistent view between the compositor and the wayland clients. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:06:39 +00:00
priv->keys = g_array_new (FALSE, FALSE, sizeof (guint32));
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
ctx = xkb_context_new(0);
g_assert (ctx);
names.rules = "evdev";
names.model = "pc105";
names.layout = option_xkb_layout;
names.variant = option_xkb_variant;
names.options = option_xkb_options;
keymap = xkb_keymap_new_from_names (ctx, &names, 0);
xkb_context_unref(ctx);
if (keymap)
{
priv->xkb = xkb_state_new (keymap);
priv->caps_lock_led = xkb_keymap_led_get_index (keymap, XKB_LED_NAME_CAPS);
priv->num_lock_led = xkb_keymap_led_get_index (keymap, XKB_LED_NAME_NUM);
priv->scroll_lock_led = xkb_keymap_led_get_index (keymap, XKB_LED_NAME_SCROLL);
xkb_keymap_unref (keymap);
}
evdev: add master / slave device handling All evdev devices are slave devices, which means that xkb state and pointer position must be shared by emulating a core keyboard and a core pointer. Also, we must make sure to add all modifier state (keyboard and button) to our events. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 09:53:46 +00:00
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
priv->udev_client = g_udev_client_new (subsystems);
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
clutter_device_manager_evdev_probe_devices (manager_evdev);
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
/* subcribe for events on input devices */
g_signal_connect (priv->udev_client, "uevent",
G_CALLBACK (on_uevent), manager_evdev);
}
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
static void
clutter_device_manager_evdev_dispose (GObject *object)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (object);
priv = manager_evdev->priv;
if (priv->stage_added_handler)
{
g_signal_handler_disconnect (priv->stage_manager,
priv->stage_added_handler);
priv->stage_added_handler = 0;
}
if (priv->stage_removed_handler)
{
g_signal_handler_disconnect (priv->stage_manager,
priv->stage_removed_handler);
priv->stage_removed_handler = 0;
}
if (priv->stage_manager)
{
g_object_unref (priv->stage_manager);
priv->stage_manager = NULL;
}
G_OBJECT_CLASS (clutter_device_manager_evdev_parent_class)->dispose (object);
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
static void
clutter_device_manager_evdev_finalize (GObject *object)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
GSList *l;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (object);
priv = manager_evdev->priv;
g_object_unref (priv->udev_client);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
for (l = priv->devices; l; l = g_slist_next (l))
{
ClutterInputDevice *device = l->data;
g_object_unref (device);
}
g_slist_free (priv->devices);
for (l = priv->event_sources; l; l = g_slist_next (l))
{
ClutterEventSource *source = l->data;
clutter_event_source_free (source);
}
g_slist_free (priv->event_sources);
evdev: add callback to constrain the pointer position Add a new callback that is called prior to emitting pointer motion events and that can modify the new pointer position. The main purpose is allowing multiscreen apps to prevent the pointer for entering the dead area that exists when the screens are not the same size, but it could also used to implement pointer barriers. A callback is needed to make sure that the hook is called early enough and the Clutter state is always consistent. https://bugzilla.gnome.org/show_bug.cgi?id=706652
2013-08-23 10:15:40 +00:00
if (priv->constrain_data_notify)
priv->constrain_data_notify (priv->constrain_data);
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
G_OBJECT_CLASS (clutter_device_manager_evdev_parent_class)->finalize (object);
}
static void
clutter_device_manager_evdev_class_init (ClutterDeviceManagerEvdevClass *klass)
{
Use the new macros for adding private data
2013-07-03 13:14:01 +00:00
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
ClutterDeviceManagerClass *manager_class;
gobject_class->constructed = clutter_device_manager_evdev_constructed;
gobject_class->finalize = clutter_device_manager_evdev_finalize;
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
gobject_class->dispose = clutter_device_manager_evdev_dispose;
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
manager_class = CLUTTER_DEVICE_MANAGER_CLASS (klass);
manager_class->add_device = clutter_device_manager_evdev_add_device;
manager_class->remove_device = clutter_device_manager_evdev_remove_device;
manager_class->get_devices = clutter_device_manager_evdev_get_devices;
manager_class->get_core_device = clutter_device_manager_evdev_get_core_device;
manager_class->get_device = clutter_device_manager_evdev_get_device;
}
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
static void
clutter_device_manager_evdev_stage_added_cb (ClutterStageManager *manager,
ClutterStage *stage,
ClutterDeviceManagerEvdev *self)
{
ClutterDeviceManagerEvdevPrivate *priv = self->priv;
GSList *l;
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
/* NB: Currently we can only associate a single stage with all evdev
* devices.
*
* We save a pointer to the stage so if we release/reclaim input
* devices due to switching virtual terminals then we know what
* stage to re associate the devices with.
*/
priv->stage = stage;
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
/* Set the stage of any devices that don't already have a stage */
for (l = priv->devices; l; l = l->next)
{
ClutterInputDevice *device = l->data;
if (_clutter_input_device_get_stage (device) == NULL)
_clutter_input_device_set_stage (device, stage);
}
/* We only want to do this once so we can catch the default
stage. If the application has multiple stages then it will need
to manage the stage of the input devices itself */
g_signal_handler_disconnect (priv->stage_manager,
priv->stage_added_handler);
priv->stage_added_handler = 0;
}
static void
clutter_device_manager_evdev_stage_removed_cb (ClutterStageManager *manager,
ClutterStage *stage,
ClutterDeviceManagerEvdev *self)
{
ClutterDeviceManagerEvdevPrivate *priv = self->priv;
GSList *l;
/* Remove the stage of any input devices that were pointing to this
stage so we don't send events to invalid stages */
for (l = priv->devices; l; l = l->next)
{
ClutterInputDevice *device = l->data;
if (_clutter_input_device_get_stage (device) == stage)
_clutter_input_device_set_stage (device, NULL);
}
}
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
static void
clutter_device_manager_evdev_init (ClutterDeviceManagerEvdev *self)
{
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
ClutterDeviceManagerEvdevPrivate *priv;
Use the new macros for adding private data
2013-07-03 13:14:01 +00:00
priv = self->priv = clutter_device_manager_evdev_get_instance_private (self);
evdev: Associate devices with the first created stage Because evdev isn't associated with the display system, it doesn't have any easy way to associate an input device with a stage. Previously Clutter would never set a stage for an input device and leave it up to the application to set it. To make it easier for applications which just have a single fullscreen stage (which is probably the most common use case for evdev) the device manager now associates all input devices with the first stage that is created unless something has already set a stage. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-17 13:37:26 +00:00
priv->stage_manager = clutter_stage_manager_get_default ();
g_object_ref (priv->stage_manager);
/* evdev doesn't have any way to link an event to a particular stage
so we'll have to leave it up to applications to set the
corresponding stage for an input device. However to make it
easier for applications that are only using one fullscreen stage
(which is probably the most frequent use-case for the evdev
backend) we'll associate any input devices that don't have a
stage with the first stage created. */
priv->stage_added_handler =
g_signal_connect (priv->stage_manager,
"stage-added",
G_CALLBACK (clutter_device_manager_evdev_stage_added_cb),
self);
priv->stage_removed_handler =
g_signal_connect (priv->stage_manager,
"stage-removed",
G_CALLBACK (clutter_device_manager_evdev_stage_removed_cb),
self);
evdev: First stab at an evdev backend This backend is a event backend that can be enabled for EGL (for now). It uses udev (gudev) to query input devices on a linux system, listens to keyboard events from input devices and xkbcommon to translate raw key codes into key keysyms. This commit only supports key events, more to follow.
2010-11-04 14:38:32 +00:00
}
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
void
_clutter_events_evdev_init (ClutterBackend *backend)
{
CLUTTER_NOTE (EVENT, "Initializing evdev backend");
backend: Clean up the device manager creation Create the device manager during the event initialization, where it makes sense. This allows us to get rid of the per-backend get_device_manager() virtual function, and just store the DeviceManager pointer into the ClutterBackend structure.
2011-11-04 19:25:54 +00:00
backend->device_manager = g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_EVDEV,
"backend", backend,
NULL);
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
}
void
_clutter_events_evdev_uninit (ClutterBackend *backend)
{
egl: First attempt at cleaning up the EGL native backend At least, let's make it compile when built along with the other backends. In reality, it still needs to be verified as working.
2011-10-03 11:25:53 +00:00
CLUTTER_NOTE (EVENT, "Uninitializing evdev backend");
evdev: Merge clutter-event-evdev.[ch] into the device manager The device manager now fully owns the GSources corresponding to the devices it manages. This will allow not only to remove the source when udev signals a device removal but also handle read() errors gracefully by removing the faulty device from the manager.
2010-11-09 17:50:23 +00:00
}
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
/**
* clutter_evdev_release_devices:
*
* Releases all the evdev devices that Clutter is currently managing. This api
* is typically used when switching away from the Clutter application when
* switching tty. The devices can be reclaimed later with a call to
* clutter_evdev_reclaim_devices().
*
* This function should only be called after clutter has been initialized.
*
* Since: 1.10
* Stability: unstable
*/
void
clutter_evdev_release_devices (void)
{
ClutterDeviceManager *manager = clutter_device_manager_get_default ();
ClutterDeviceManagerEvdev *evdev_manager;
ClutterDeviceManagerEvdevPrivate *priv;
GSList *l, *next;
evdev: sync the keyboard state when releasing and reclaiming devices When we release a device, we lose all the events after that point, so our state can become stale. Similarly, we need to sync the state with the effectively pressed keys when we reclaim. This ensures that modifier keys don't get stuck when switching VTs using a keybinding. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 13:59:21 +00:00
uint32_t time_;
unsigned i;
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
if (!manager)
{
g_warning ("clutter_evdev_release_devices shouldn't be called "
"before clutter_init()");
return;
}
g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER_EVDEV (manager));
evdev_manager = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
priv = evdev_manager->priv;
if (priv->released)
{
g_warning ("clutter_evdev_release_devices() shouldn't be called "
"multiple times without a corresponding call to "
"clutter_evdev_reclaim_devices() first");
return;
}
evdev: sync the keyboard state when releasing and reclaiming devices When we release a device, we lose all the events after that point, so our state can become stale. Similarly, we need to sync the state with the effectively pressed keys when we reclaim. This ensures that modifier keys don't get stuck when switching VTs using a keybinding. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 13:59:21 +00:00
/* Fake release events for all currently pressed keys */
time_ = g_get_monotonic_time () / 1000;
for (i = 0; i < priv->keys->len; i++)
notify_key_device (priv->core_keyboard, time_,
g_array_index (priv->keys, uint32_t, i) - 8, 0, FALSE);
g_array_set_size (priv->keys, 0);
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
for (l = priv->devices; l; l = next)
{
ClutterInputDevice *device = l->data;
/* Be careful about the list we're iterating being modified... */
next = l->next;
_clutter_device_manager_remove_device (manager, device);
}
priv->released = TRUE;
}
/**
* clutter_evdev_reclaim_devices:
*
* This causes Clutter to re-probe for evdev devices. This is must only be
* called after a corresponding call to clutter_evdev_release_devices()
* was previously used to release all evdev devices. This API is typically
* used when a clutter application using evdev has regained focus due to
* switching ttys.
*
* This function should only be called after clutter has been initialized.
*
* Since: 1.10
* Stability: unstable
*/
void
clutter_evdev_reclaim_devices (void)
{
ClutterDeviceManager *manager = clutter_device_manager_get_default ();
ClutterDeviceManagerEvdev *evdev_manager;
ClutterDeviceManagerEvdevPrivate *priv;
evdev: sync the keyboard state when releasing and reclaiming devices When we release a device, we lose all the events after that point, so our state can become stale. Similarly, we need to sync the state with the effectively pressed keys when we reclaim. This ensures that modifier keys don't get stuck when switching VTs using a keybinding. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 13:59:21 +00:00
#define LONG_BITS (sizeof(long) * 8)
#define NLONGS(x) (((x) + LONG_BITS - 1) / LONG_BITS)
unsigned long key_bits[NLONGS(KEY_CNT)];
unsigned long source_key_bits[NLONGS(KEY_CNT)];
GSList *iter;
int i, j, rc;
guint32 time_;
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
if (!manager)
{
g_warning ("clutter_evdev_reclaim_devices shouldn't be called "
"before clutter_init()");
return;
}
g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER_EVDEV (manager));
evdev_manager = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
priv = evdev_manager->priv;
if (!priv->released)
{
g_warning ("Spurious call to clutter_evdev_reclaim_devices() without "
"previous call to clutter_evdev_release_devices");
return;
}
priv->released = FALSE;
clutter_device_manager_evdev_probe_devices (evdev_manager);
evdev: sync the keyboard state when releasing and reclaiming devices When we release a device, we lose all the events after that point, so our state can become stale. Similarly, we need to sync the state with the effectively pressed keys when we reclaim. This ensures that modifier keys don't get stuck when switching VTs using a keybinding. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 13:59:21 +00:00
memset (key_bits, 0, sizeof (key_bits));
for (iter = priv->event_sources; iter; iter++)
{
ClutterEventSource *source = iter->data;
ClutterInputDevice *slave = CLUTTER_INPUT_DEVICE (source->device);
if (clutter_input_device_get_device_type (slave) == CLUTTER_KEYBOARD_DEVICE)
{
rc = ioctl (source->event_poll_fd.fd, EVIOCGBIT(EV_KEY, sizeof (source_key_bits)), source_key_bits);
if (rc < 0)
continue;
for (i = 0; i < NLONGS(KEY_CNT); i++)
key_bits[i] |= source_key_bits[i];
}
}
/* Fake press events for all currently pressed keys */
time_ = g_get_monotonic_time () / 1000;
for (i = 0; i < NLONGS(KEY_CNT); i++)
{
for (j = 0; j < 8; j++)
{
if (key_bits[i] & (1 << j))
notify_key_device (priv->core_keyboard, time_, i * 8 + j, 1, TRUE);
}
}
#undef LONG_BITS
#undef NLONGS
evdev: Adds api to release/reclaim the evdev devices Clutter applications using evdev are typically fullscreen applications associated with a single virtual termainal. When switching away from the applications associated tty then Clutter should stop managing all evdev devices and re-probe for devices when the application regains focus by switching back to the tty. To facilitate this, this patch adds clutter_evdev_release_devices() and clutter_evdev_reclaim_devices() functions. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-01-22 15:36:17 +00:00
}
evdev: add a way for applications to tweak how devices are opened In some cases, applications (or actually, wayland compositors) don't have the required permissions to access evdev directly, but can do so with an external helper like weston-launch. Allow them to do so with a custom callback that replaces the regular open() path. https://bugzilla.gnome.org/show_bug.cgi?id=704269
2013-07-15 16:24:35 +00:00
/**
* clutter_evdev_set_open_callback: (skip)
* @callback: the user replacement for open()
* @user_data: user data for @callback
*
* Through this function, the application can set a custom callback
* to invoked when Clutter is about to open an evdev device. It can do
* so if special handling is needed, for example to circumvent permission
* problems.
*
* Setting @callback to %NULL will reset the default behavior.
*
* For reliable effects, this function must be called before clutter_init().
*/
void
clutter_evdev_set_open_callback (ClutterOpenDeviceCallback callback,
gpointer user_data)
{
open_callback = callback;
open_callback_data = user_data;
}
evdev: allow hooking directly into libxkbcommon A wayland compositor needs to have more keyboard state than ClutterModifierState exposes, so it makes sense for it to use xkb_state directly. Also, it makes sense for it to provide it's own keymap, to ensure a consistent view between the compositor and the wayland clients. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:06:39 +00:00
/**
* clutter_evdev_set_keyboard_map: (skip)
* @evdev: the #ClutterDeviceManager created by the evdev backend
* @keymap: the new keymap
*
* Instructs @evdev to use the speficied keyboard map. This will cause
* the backend to drop the state and create a new one with the new map.
*/
void
clutter_evdev_set_keyboard_map (ClutterDeviceManager *evdev,
struct xkb_keymap *keymap)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
unsigned int i;
g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER_EVDEV (evdev));
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (evdev);
priv = manager_evdev->priv;
xkb_state_unref (priv->xkb);
priv->xkb = xkb_state_new (keymap);
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
priv->caps_lock_led = xkb_keymap_led_get_index (keymap, XKB_LED_NAME_CAPS);
priv->num_lock_led = xkb_keymap_led_get_index (keymap, XKB_LED_NAME_NUM);
priv->scroll_lock_led = xkb_keymap_led_get_index (keymap, XKB_LED_NAME_SCROLL);
evdev: allow hooking directly into libxkbcommon A wayland compositor needs to have more keyboard state than ClutterModifierState exposes, so it makes sense for it to use xkb_state directly. Also, it makes sense for it to provide it's own keymap, to ensure a consistent view between the compositor and the wayland clients. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:06:39 +00:00
for (i = 0; i < priv->keys->len; i++)
xkb_state_update_key (priv->xkb, g_array_index (priv->keys, guint32, i), XKB_KEY_DOWN);
evdev: implement setting leds When the leds are changed in the keyboard state, propagate the change to the actual devices. https://bugzilla.gnome.org/show_bug.cgi?id=706494
2013-09-06 14:56:55 +00:00
sync_leds (manager_evdev);
evdev: allow hooking directly into libxkbcommon A wayland compositor needs to have more keyboard state than ClutterModifierState exposes, so it makes sense for it to use xkb_state directly. Also, it makes sense for it to provide it's own keymap, to ensure a consistent view between the compositor and the wayland clients. https://bugzilla.gnome.org/show_bug.cgi?id=705710
2013-08-09 15:06:39 +00:00
}
evdev: add callback to constrain the pointer position Add a new callback that is called prior to emitting pointer motion events and that can modify the new pointer position. The main purpose is allowing multiscreen apps to prevent the pointer for entering the dead area that exists when the screens are not the same size, but it could also used to implement pointer barriers. A callback is needed to make sure that the hook is called early enough and the Clutter state is always consistent. https://bugzilla.gnome.org/show_bug.cgi?id=706652
2013-08-23 10:15:40 +00:00
/**
* clutter_evdev_set_pointer_constrain_callback:
* @evdev: the #ClutterDeviceManager created by the evdev backend
* @callback: the callback
* @user_data:
* @user_data_notify:
*
* Sets a callback to be invoked for every pointer motion. The callback
* can then modify the new pointer coordinates to constrain movement within
* a specific region.
*/
void
clutter_evdev_set_pointer_constrain_callback (ClutterDeviceManager *evdev,
ClutterPointerConstrainCallback callback,
gpointer user_data,
GDestroyNotify user_data_notify)
{
ClutterDeviceManagerEvdev *manager_evdev;
ClutterDeviceManagerEvdevPrivate *priv;
g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER_EVDEV (evdev));
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (evdev);
priv = manager_evdev->priv;
if (priv->constrain_data_notify)
priv->constrain_data_notify (priv->constrain_data);
priv->constrain_callback = callback;
priv->constrain_data = user_data;
priv->constrain_data_notify = user_data_notify;
}
Reference in New Issue Copy Permalink