diff options
Diffstat (limited to '')
| -rw-r--r-- | modules/controller-linux-input.c | 711 |
1 files changed, 711 insertions, 0 deletions
diff --git a/modules/controller-linux-input.c b/modules/controller-linux-input.c new file mode 100644 index 0000000..760ccd8 --- /dev/null +++ b/modules/controller-linux-input.c @@ -0,0 +1,711 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis + * + * controller_linux_input.c + * Copyright (C) 2004-2007 Sven Neumann <sven@gimp.org> + * Michael Natterer <mitch@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <errno.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <linux/input.h> + +#include <glib/gstdio.h> + +#include <gegl.h> +#include <gtk/gtk.h> + +#include "libgimpconfig/gimpconfig.h" +#include "libgimpmodule/gimpmodule.h" +#include "libgimpwidgets/gimpwidgets.h" + +#define GIMP_ENABLE_CONTROLLER_UNDER_CONSTRUCTION +#include "libgimpwidgets/gimpcontroller.h" + +#include "gimpinputdevicestore.h" + +#include "libgimp/libgimp-intl.h" + + +typedef struct +{ + guint16 code; + const gchar *name; + const gchar *blurb; +} LinuxInputEvent; + +static const LinuxInputEvent key_events[] = +{ + { BTN_0, "button-0", N_("Button 0") }, + { BTN_1, "button-1", N_("Button 1") }, + { BTN_2, "button-2", N_("Button 2") }, + { BTN_3, "button-3", N_("Button 3") }, + { BTN_4, "button-4", N_("Button 4") }, + { BTN_5, "button-5", N_("Button 5") }, + { BTN_6, "button-6", N_("Button 6") }, + { BTN_7, "button-7", N_("Button 7") }, + { BTN_8, "button-8", N_("Button 8") }, + { BTN_9, "button-9", N_("Button 9") }, + { BTN_MOUSE, "button-mouse", N_("Button Mouse") }, + { BTN_LEFT, "button-left", N_("Button Left") }, + { BTN_RIGHT, "button-right", N_("Button Right") }, + { BTN_MIDDLE, "button-middle", N_("Button Middle") }, + { BTN_SIDE, "button-side", N_("Button Side") }, + { BTN_EXTRA, "button-extra", N_("Button Extra") }, + { BTN_FORWARD, "button-forward", N_("Button Forward") }, + { BTN_BACK, "button-back", N_("Button Back") }, + { BTN_TASK, "button-task", N_("Button Task") }, +#ifdef BTN_WHEEL + { BTN_WHEEL, "button-wheel", N_("Button Wheel") }, +#endif +#ifdef BTN_GEAR_DOWN + { BTN_GEAR_DOWN, "button-gear-down", N_("Button Gear Down") }, +#endif +#ifdef BTN_GEAR_UP + { BTN_GEAR_UP, "button-gear-up", N_("Button Gear Up") } +#endif +}; + +static const LinuxInputEvent rel_events[] = +{ + { REL_X, "x-move-left", N_("X Move Left") }, + { REL_X, "x-move-right", N_("X Move Right") }, + { REL_Y, "y-move-forward", N_("Y Move Forward") }, + { REL_Y, "y-move-back", N_("Y Move Back") }, + { REL_Z, "z-move-up", N_("Z Move Up") }, + { REL_Z, "z-move-down", N_("Z Move Down") }, +#ifdef REL_RX + { REL_RX, "x-axis-tilt-forward", N_("X Axis Tilt Forward") }, + { REL_RX, "x-axis-tilt-back", N_("X Axis Tilt Back") }, + { REL_RY, "y-axis-tilt-right", N_("Y Axis Tilt Right") }, + { REL_RY, "y-axis-tilt-left", N_("Y Axis Tilt Left") }, + { REL_RZ, "z-axis-turn-left", N_("Z Axis Turn Left") }, + { REL_RZ, "z-axis-turn-right", N_("Z Axis Turn Right") }, +#endif /* REL_RX */ + { REL_HWHEEL, "horizontal-wheel-turn-back", N_("Horiz. Wheel Turn Back") }, + { REL_HWHEEL, "horizontal-wheel-turn-forward", N_("Horiz. Wheel Turn Forward") }, + { REL_DIAL, "dial-turn-left", N_("Dial Turn Left") }, + { REL_DIAL, "dial-turn-right", N_("Dial Turn Right") }, + { REL_WHEEL, "wheel-turn-left", N_("Wheel Turn Left") }, + { REL_WHEEL, "wheel-turn-right", N_("Wheel Turn Right") }, +}; + + +enum +{ + PROP_0, + PROP_DEVICE, + PROP_DEVICE_STORE +}; + + +#define CONTROLLER_TYPE_LINUX_INPUT (controller_linux_input_get_type ()) +#define CONTROLLER_LINUX_INPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CONTROLLER_TYPE_LINUX_INPUT, ControllerLinuxInput)) +#define CONTROLLER_LINUX_INPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CONTROLLER_TYPE_LINUX_INPUT, ControllerLinuxInputClass)) +#define CONTROLLER_IS_LINUX_INPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CONTROLLER_TYPE_LINUX_INPUT)) +#define CONTROLLER_IS_LINUX_INPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CONTROLLER_TYPE_LINUX_INPUT)) + + +typedef struct _ControllerLinuxInput ControllerLinuxInput; +typedef struct _ControllerLinuxInputClass ControllerLinuxInputClass; + +struct _ControllerLinuxInput +{ + GimpController parent_instance; + + GimpInputDeviceStore *store; + gchar *device; + GIOChannel *io; + guint io_id; +}; + +struct _ControllerLinuxInputClass +{ + GimpControllerClass parent_class; +}; + + +static GType controller_linux_input_get_type (void); + +static void linux_input_dispose (GObject *object); +static void linux_input_finalize (GObject *object); +static void linux_input_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void linux_input_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + +static gint linux_input_get_n_events (GimpController *controller); +static const gchar * linux_input_get_event_name (GimpController *controller, + gint event_id); +static const gchar * linux_input_get_event_blurb (GimpController *controller, + gint event_id); + +static void linux_input_device_changed (ControllerLinuxInput *controller, + const gchar *udi); +static gboolean linux_input_set_device (ControllerLinuxInput *controller, + const gchar *device); +static gboolean linux_input_read_event (GIOChannel *io, + GIOCondition cond, + gpointer data); + + +static const GimpModuleInfo linux_input_info = +{ + GIMP_MODULE_ABI_VERSION, + N_("Linux input event controller"), + "Sven Neumann <sven@gimp.org>, Michael Natterer <mitch@gimp.org>", + "v0.2", + "(c) 2004-2007, released under the GPL", + "2004-2007" +}; + + +G_DEFINE_DYNAMIC_TYPE (ControllerLinuxInput, controller_linux_input, + GIMP_TYPE_CONTROLLER) + + +G_MODULE_EXPORT const GimpModuleInfo * +gimp_module_query (GTypeModule *module) +{ + return &linux_input_info; +} + +G_MODULE_EXPORT gboolean +gimp_module_register (GTypeModule *module) +{ + gimp_input_device_store_register_types (module); + controller_linux_input_register_type (module); + + return TRUE; +} + +static void +controller_linux_input_class_init (ControllerLinuxInputClass *klass) +{ + GimpControllerClass *controller_class = GIMP_CONTROLLER_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->dispose = linux_input_dispose; + object_class->finalize = linux_input_finalize; + object_class->get_property = linux_input_get_property; + object_class->set_property = linux_input_set_property; + + g_object_class_install_property (object_class, PROP_DEVICE, + g_param_spec_string ("device", + _("Device:"), + _("The name of the device to read Linux Input events from."), + NULL, + GIMP_CONFIG_PARAM_FLAGS)); +#ifdef HAVE_LIBGUDEV + g_object_class_install_property (object_class, PROP_DEVICE_STORE, + g_param_spec_object ("device-values", + NULL, NULL, + GIMP_TYPE_INPUT_DEVICE_STORE, + G_PARAM_READABLE)); +#endif + + controller_class->name = _("Linux Input"); + controller_class->help_id = "gimp-controller-linux-input"; + controller_class->icon_name = GIMP_ICON_CONTROLLER_LINUX_INPUT; + + controller_class->get_n_events = linux_input_get_n_events; + controller_class->get_event_name = linux_input_get_event_name; + controller_class->get_event_blurb = linux_input_get_event_blurb; +} + +static void +controller_linux_input_class_finalize (ControllerLinuxInputClass *klass) +{ +} + +static void +controller_linux_input_init (ControllerLinuxInput *controller) +{ + controller->store = gimp_input_device_store_new (); + + if (controller->store) + { + g_signal_connect_swapped (controller->store, "device-added", + G_CALLBACK (linux_input_device_changed), + controller); + g_signal_connect_swapped (controller->store, "device-removed", + G_CALLBACK (linux_input_device_changed), + controller); + } +} + +static void +linux_input_dispose (GObject *object) +{ + ControllerLinuxInput *controller = CONTROLLER_LINUX_INPUT (object); + + linux_input_set_device (controller, NULL); + + G_OBJECT_CLASS (controller_linux_input_parent_class)->dispose (object); +} + +static void +linux_input_finalize (GObject *object) +{ + ControllerLinuxInput *controller = CONTROLLER_LINUX_INPUT (object); + + if (controller->store) + { + g_object_unref (controller->store); + controller->store = NULL; + } + + G_OBJECT_CLASS (controller_linux_input_parent_class)->finalize (object); +} + +static void +linux_input_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + ControllerLinuxInput *controller = CONTROLLER_LINUX_INPUT (object); + + switch (property_id) + { + case PROP_DEVICE: + linux_input_set_device (controller, g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +linux_input_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + ControllerLinuxInput *controller = CONTROLLER_LINUX_INPUT (object); + + switch (property_id) + { + case PROP_DEVICE: + g_value_set_string (value, controller->device); + break; + case PROP_DEVICE_STORE: + g_value_set_object (value, controller->store); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static gint +linux_input_get_n_events (GimpController *controller) +{ + return G_N_ELEMENTS (key_events) + G_N_ELEMENTS (rel_events); +} + +static const gchar * +linux_input_get_event_name (GimpController *controller, + gint event_id) +{ + if (event_id < 0) + { + return NULL; + } + else if (event_id < G_N_ELEMENTS (key_events)) + { + return key_events[event_id].name; + } + else if (event_id < linux_input_get_n_events (controller)) + { + return rel_events[event_id - G_N_ELEMENTS (key_events)].name; + } + else + { + return NULL; + } +} + +static const gchar * +linux_input_get_event_blurb (GimpController *controller, + gint event_id) +{ + if (event_id < 0) + { + return NULL; + } + else if (event_id < G_N_ELEMENTS (key_events)) + { + return gettext (key_events[event_id].blurb); + } + else if (event_id < linux_input_get_n_events (controller)) + { + return gettext (rel_events[event_id - G_N_ELEMENTS (key_events)].blurb); + } + else + { + return NULL; + } +} + +#define BITS_PER_LONG (sizeof(long) * 8) +#define NBITS(x) ((((x)-1)/BITS_PER_LONG)+1) +#define OFF(x) ((x)%BITS_PER_LONG) +#define BIT(x) (1UL<<OFF(x)) +#define LONG(x) ((x)/BITS_PER_LONG) +#define test_bit(bit, array) ((array[LONG(bit)] >> OFF(bit)) & 1) + +static void +linux_input_get_device_info (ControllerLinuxInput *controller, + int fd) +{ + unsigned long evbit[NBITS (EV_MAX)]; + unsigned long keybit[NBITS (KEY_MAX)]; + unsigned long relbit[NBITS (REL_MAX)]; + unsigned long absbit[NBITS (ABS_MAX)]; + + gint num_keys = 0; + gint num_ext_keys = 0; + gint num_buttons = 0; + gint num_rels = 0; + gint num_abs = 0; + + /* get event type bits */ + ioctl (fd, EVIOCGBIT (0, EV_MAX), evbit); + + if (test_bit (EV_KEY, evbit)) + { + gint i; + + /* get keyboard bits */ + ioctl (fd, EVIOCGBIT (EV_KEY, KEY_MAX), keybit); + + /** count typical keyboard keys only */ + for (i = KEY_Q; i < KEY_M; i++) + if (test_bit (i, keybit)) + { + num_keys++; + + g_print ("%s: key 0x%02x present\n", G_STRFUNC, i); + } + + g_print ("%s: #keys = %d\n", G_STRFUNC, num_keys); + + for (i = KEY_OK; i < KEY_MAX; i++) + if (test_bit (i, keybit)) + { + num_ext_keys++; + + g_print ("%s: ext key 0x%02x present\n", G_STRFUNC, i); + } + + g_print ("%s: #ext_keys = %d\n", G_STRFUNC, num_ext_keys); + + for (i = BTN_MISC; i < KEY_OK; i++) + if (test_bit (i, keybit)) + { + num_buttons++; + + g_print ("%s: button 0x%02x present\n", G_STRFUNC, i); + } + + g_print ("%s: #buttons = %d\n", G_STRFUNC, num_buttons); + } + + if (test_bit (EV_REL, evbit)) + { + gint i; + + /* get bits for relative axes */ + ioctl (fd, EVIOCGBIT (EV_REL, REL_MAX), relbit); + + for (i = 0; i < REL_MAX; i++) + if (test_bit (i, relbit)) + { + num_rels++; + + g_print ("%s: rel 0x%02x present\n", G_STRFUNC, i); + } + + g_print ("%s: #rels = %d\n", G_STRFUNC, num_rels); + } + + if (test_bit (EV_ABS, evbit)) + { + gint i; + + /* get bits for absolute axes */ + ioctl (fd, EVIOCGBIT (EV_ABS, ABS_MAX), absbit); + + for (i = 0; i < ABS_MAX; i++) + if (test_bit (i, absbit)) + { + struct input_absinfo absinfo; + + num_abs++; + + /* get info for the absolute axis */ + ioctl (fd, EVIOCGABS (i), &absinfo); + + g_print ("%s: abs 0x%02x present [%d..%d]\n", G_STRFUNC, i, + absinfo.minimum, absinfo.maximum); + } + + g_print ("%s: #abs = %d\n", G_STRFUNC, num_abs); + } +} + +static void +linux_input_device_changed (ControllerLinuxInput *controller, + const gchar *identifier) +{ + if (controller->device && strcmp (identifier, controller->device) == 0) + { + linux_input_set_device (controller, identifier); + g_object_notify (G_OBJECT (controller), "device"); + } +} + +static gboolean +linux_input_set_device (ControllerLinuxInput *controller, + const gchar *device) +{ + gchar *filename; + + if (controller->io) + { + g_source_remove (controller->io_id); + controller->io_id = 0; + + g_io_channel_unref (controller->io); + controller->io = NULL; + } + + if (controller->device) + g_free (controller->device); + + controller->device = g_strdup (device); + + g_object_set (controller, "name", _("Linux Input Events"), NULL); + + if (controller->device && strlen (controller->device)) + { + if (controller->store) + filename = gimp_input_device_store_get_device_file (controller->store, + controller->device); + else + filename = g_strdup (controller->device); + } + else + { + g_object_set (controller, "state", _("No device configured"), NULL); + + return FALSE; + } + + if (filename) + { + gchar *state; + gint fd; + + fd = g_open (filename, O_RDONLY, 0); + + if (fd >= 0) + { + gchar name[256]; + + name[0] = '\0'; + if (ioctl (fd, EVIOCGNAME (sizeof (name)), name) >= 0 && + strlen (name) > 0 && + g_utf8_validate (name, -1, NULL)) + { + g_object_set (controller, "name", name, NULL); + } + + linux_input_get_device_info (controller, fd); + + state = g_strdup_printf (_("Reading from %s"), filename); + g_object_set (controller, "state", state, NULL); + g_free (state); + + g_free (filename); + + controller->io = g_io_channel_unix_new (fd); + g_io_channel_set_close_on_unref (controller->io, TRUE); + g_io_channel_set_encoding (controller->io, NULL, NULL); + + controller->io_id = g_io_add_watch (controller->io, + G_IO_IN, + linux_input_read_event, + controller); + return TRUE; + } + else + { + state = g_strdup_printf (_("Device not available: %s"), + g_strerror (errno)); + g_object_set (controller, "state", state, NULL); + g_free (state); + } + + g_free (filename); + } + else if (controller->store) + { + GError *error = gimp_input_device_store_get_error (controller->store); + + if (error) + { + g_object_set (controller, "state", error->message, NULL); + g_error_free (error); + } + else + { + g_object_set (controller, "state", _("Device not available"), NULL); + } + } + + return FALSE; +} + +static gboolean +linux_input_read_event (GIOChannel *io, + GIOCondition cond, + gpointer data) +{ + ControllerLinuxInput *input = CONTROLLER_LINUX_INPUT (data); + GIOStatus status; + GError *error = NULL; + struct input_event ev; + gsize n_bytes; + + status = g_io_channel_read_chars (io, + (gchar *) &ev, + sizeof (struct input_event), &n_bytes, + &error); + + switch (status) + { + case G_IO_STATUS_ERROR: + case G_IO_STATUS_EOF: + g_source_remove (input->io_id); + input->io_id = 0; + + g_io_channel_unref (input->io); + input->io = NULL; + + if (error) + { + gchar *state = g_strdup_printf (_("Device not available: %s"), + error->message); + g_object_set (input, "state", state, NULL); + g_free (state); + + g_clear_error (&error); + } + else + { + g_object_set (input, "state", _("End of file"), NULL); + } + return FALSE; + break; + + case G_IO_STATUS_AGAIN: + return TRUE; + + default: + break; + } + + if (n_bytes == sizeof (struct input_event)) + { + GimpController *controller = GIMP_CONTROLLER (data); + GimpControllerEvent cevent = { 0, }; + gint i; + + switch (ev.type) + { + case EV_KEY: + g_print ("%s: EV_KEY code = 0x%02x\n", G_STRFUNC, ev.code); + + for (i = 0; i < G_N_ELEMENTS (key_events); i++) + if (ev.code == key_events[i].code) + { + cevent.any.type = GIMP_CONTROLLER_EVENT_TRIGGER; + cevent.any.source = controller; + cevent.any.event_id = i; + + gimp_controller_event (controller, &cevent); + + break; + } + break; + + case EV_REL: + g_print ("%s: EV_REL code = 0x%02x (value = %d)\n", G_STRFUNC, + ev.code, ev.value); + + for (i = 0; i < G_N_ELEMENTS (rel_events); i++) + if (ev.code == rel_events[i].code) + { + cevent.any.type = GIMP_CONTROLLER_EVENT_VALUE; + cevent.any.source = controller; + cevent.any.event_id = G_N_ELEMENTS (key_events) + i; + + g_value_init (&cevent.value.value, G_TYPE_DOUBLE); + + if (ev.value < 0) + { + g_value_set_double (&cevent.value.value, -ev.value); + } + else + { + cevent.any.event_id++; + + g_value_set_double (&cevent.value.value, ev.value); + } + + gimp_controller_event (controller, &cevent); + + g_value_unset (&cevent.value.value); + + break; + } + break; + + case EV_ABS: + g_print ("%s: EV_ABS code = 0x%02x (value = %d)\n", G_STRFUNC, + ev.code, ev.value); + break; + + default: + break; + } + } + + return TRUE; +} |