diff options
Diffstat (limited to 'app/widgets/gimpdeviceinfo.c')
| -rw-r--r-- | app/widgets/gimpdeviceinfo.c | 945 |
1 files changed, 945 insertions, 0 deletions
diff --git a/app/widgets/gimpdeviceinfo.c b/app/widgets/gimpdeviceinfo.c new file mode 100644 index 0000000..594dd90 --- /dev/null +++ b/app/widgets/gimpdeviceinfo.c @@ -0,0 +1,945 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 <string.h> + +#undef GSEAL_ENABLE + +#include <gegl.h> +#include <gtk/gtk.h> + +#include "libgimpbase/gimpbase.h" +#include "libgimpconfig/gimpconfig.h" +#include "libgimpwidgets/gimpwidgets.h" + +#include "widgets-types.h" + +#include "core/gimp.h" +#include "core/gimpcontext.h" +#include "core/gimpcontainer.h" +#include "core/gimpcurve.h" +#include "core/gimpcurve-map.h" +#include "core/gimpdatafactory.h" +#include "core/gimpmarshal.h" +#include "core/gimpparamspecs.h" +#include "core/gimptoolinfo.h" + +#include "gimpdeviceinfo.h" + +#include "gimp-intl.h" + + +#define GIMP_DEVICE_INFO_DATA_KEY "gimp-device-info" + + +enum +{ + PROP_0, + PROP_DEVICE, + PROP_DISPLAY, + PROP_MODE, + PROP_AXES, + PROP_KEYS, + PROP_PRESSURE_CURVE +}; + + +/* local function prototypes */ + +static void gimp_device_info_constructed (GObject *object); +static void gimp_device_info_finalize (GObject *object); +static void gimp_device_info_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_device_info_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + +static void gimp_device_info_guess_icon (GimpDeviceInfo *info); + + +G_DEFINE_TYPE (GimpDeviceInfo, gimp_device_info, GIMP_TYPE_TOOL_PRESET) + +#define parent_class gimp_device_info_parent_class + + +static void +gimp_device_info_class_init (GimpDeviceInfoClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpViewableClass *viewable_class = GIMP_VIEWABLE_CLASS (klass); + GParamSpec *param_spec; + + object_class->constructed = gimp_device_info_constructed; + object_class->finalize = gimp_device_info_finalize; + object_class->set_property = gimp_device_info_set_property; + object_class->get_property = gimp_device_info_get_property; + + viewable_class->default_icon_name = GIMP_ICON_INPUT_DEVICE; + + g_object_class_install_property (object_class, PROP_DEVICE, + g_param_spec_object ("device", + NULL, NULL, + GDK_TYPE_DEVICE, + GIMP_PARAM_STATIC_STRINGS | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + + g_object_class_install_property (object_class, PROP_DISPLAY, + g_param_spec_object ("display", + NULL, NULL, + GDK_TYPE_DISPLAY, + GIMP_PARAM_STATIC_STRINGS | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + + GIMP_CONFIG_PROP_ENUM (object_class, PROP_MODE, + "mode", + _("Mode"), + NULL, + GDK_TYPE_INPUT_MODE, + GDK_MODE_DISABLED, + GIMP_PARAM_STATIC_STRINGS); + + param_spec = g_param_spec_enum ("axis", + NULL, NULL, + GDK_TYPE_AXIS_USE, + GDK_AXIS_IGNORE, + GIMP_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_AXES, + gimp_param_spec_value_array ("axes", + NULL, NULL, + param_spec, + GIMP_PARAM_STATIC_STRINGS | + GIMP_CONFIG_PARAM_FLAGS)); + + param_spec = g_param_spec_string ("key", + NULL, NULL, + NULL, + GIMP_PARAM_READWRITE); + g_object_class_install_property (object_class, PROP_KEYS, + gimp_param_spec_value_array ("keys", + NULL, NULL, + param_spec, + GIMP_PARAM_STATIC_STRINGS | + GIMP_CONFIG_PARAM_FLAGS)); + + GIMP_CONFIG_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE, + "pressure-curve", + _("Pressure curve"), + NULL, + GIMP_TYPE_CURVE, + GIMP_CONFIG_PARAM_AGGREGATE); +} + +static void +gimp_device_info_init (GimpDeviceInfo *info) +{ + gimp_data_make_internal (GIMP_DATA (info), NULL); + + info->mode = GDK_MODE_DISABLED; + info->pressure_curve = GIMP_CURVE (gimp_curve_new ("pressure curve")); + + g_signal_connect (info, "notify::name", + G_CALLBACK (gimp_device_info_guess_icon), + NULL); +} + +static void +gimp_device_info_constructed (GObject *object) +{ + GimpDeviceInfo *info = GIMP_DEVICE_INFO (object); + + G_OBJECT_CLASS (parent_class)->constructed (object); + + gimp_assert ((info->device == NULL && info->display == NULL) || + (GDK_IS_DEVICE (info->device) && GDK_IS_DISPLAY (info->display))); + + if (info->device) + { + gint i; + + g_object_set_data (G_OBJECT (info->device), GIMP_DEVICE_INFO_DATA_KEY, + info); + + gimp_object_set_name (GIMP_OBJECT (info), info->device->name); + + info->mode = gdk_device_get_mode (info->device); + + info->n_axes = gdk_device_get_n_axes (info->device); + info->axes = g_new0 (GdkAxisUse, info->n_axes); + for (i = 0; i < info->n_axes; i++) + info->axes[i] = gdk_device_get_axis_use (info->device, i); + + info->n_keys = gdk_device_get_n_keys (info->device); + info->keys = g_new0 (GdkDeviceKey, info->n_keys); + for (i = 0; i < info->n_keys; i++) + gdk_device_get_key (info->device, i, + &info->keys[i].keyval, + &info->keys[i].modifiers); + } +} + +static void +gimp_device_info_finalize (GObject *object) +{ + GimpDeviceInfo *info = GIMP_DEVICE_INFO (object); + + g_clear_pointer (&info->axes, g_free); + g_clear_pointer (&info->keys, g_free); + + g_clear_object (&info->pressure_curve); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_device_info_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpDeviceInfo *info = GIMP_DEVICE_INFO (object); + GdkDevice *device = info->device; + GimpCurve *src_curve = NULL; + GimpCurve *dest_curve = NULL; + + switch (property_id) + { + case PROP_DEVICE: + info->device = g_value_get_object (value); + break; + + case PROP_DISPLAY: + info->display = g_value_get_object (value); + break; + + case PROP_MODE: + gimp_device_info_set_mode (info, g_value_get_enum (value)); + break; + + case PROP_AXES: + { + GimpValueArray *array = g_value_get_boxed (value); + + if (array) + { + gint i; + gint n_device_values = gimp_value_array_length (array); + + if (device) + n_device_values = MIN (n_device_values, + gdk_device_get_n_axes (device)); + + info->n_axes = n_device_values; + info->axes = g_renew (GdkAxisUse, info->axes, info->n_axes); + memset (info->axes, 0, info->n_axes * sizeof (GdkAxisUse)); + + for (i = 0; i < n_device_values; i++) + { + GdkAxisUse axis_use; + + axis_use = g_value_get_enum (gimp_value_array_index (array, i)); + + gimp_device_info_set_axis_use (info, i, axis_use); + } + } + } + break; + + case PROP_KEYS: + { + GimpValueArray *array = g_value_get_boxed (value); + + if (array) + { + gint i; + gint n_device_values = gimp_value_array_length (array); + + if (device) + n_device_values = MIN (n_device_values, + gdk_device_get_n_keys (device)); + + info->n_keys = n_device_values; + info->keys = g_renew (GdkDeviceKey, info->keys, info->n_keys); + memset (info->keys, 0, info->n_keys * sizeof (GdkDeviceKey)); + + for (i = 0; i < n_device_values; i++) + { + const gchar *accel; + guint keyval; + GdkModifierType modifiers; + + accel = g_value_get_string (gimp_value_array_index (array, i)); + + gtk_accelerator_parse (accel, &keyval, &modifiers); + + gimp_device_info_set_key (info, i, keyval, modifiers); + } + } + } + break; + + case PROP_PRESSURE_CURVE: + src_curve = g_value_get_object (value); + dest_curve = info->pressure_curve; + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } + + if (src_curve && dest_curve) + { + gimp_config_copy (GIMP_CONFIG (src_curve), + GIMP_CONFIG (dest_curve), + GIMP_CONFIG_PARAM_SERIALIZE); + } +} + +static void +gimp_device_info_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpDeviceInfo *info = GIMP_DEVICE_INFO (object); + + switch (property_id) + { + case PROP_DEVICE: + g_value_set_object (value, info->device); + break; + + case PROP_DISPLAY: + g_value_set_object (value, info->display); + break; + + case PROP_MODE: + g_value_set_enum (value, gimp_device_info_get_mode (info)); + break; + + case PROP_AXES: + { + GimpValueArray *array; + GValue enum_value = G_VALUE_INIT; + gint n_axes; + gint i; + + array = gimp_value_array_new (6); + g_value_init (&enum_value, GDK_TYPE_AXIS_USE); + + n_axes = gimp_device_info_get_n_axes (info); + + for (i = 0; i < n_axes; i++) + { + g_value_set_enum (&enum_value, + gimp_device_info_get_axis_use (info, i)); + + gimp_value_array_append (array, &enum_value); + } + + g_value_unset (&enum_value); + + g_value_take_boxed (value, array); + } + break; + + case PROP_KEYS: + { + GimpValueArray *array; + GValue string_value = G_VALUE_INIT; + gint n_keys; + gint i; + + array = gimp_value_array_new (32); + g_value_init (&string_value, G_TYPE_STRING); + + n_keys = gimp_device_info_get_n_keys (info); + + for (i = 0; i < n_keys; i++) + { + guint keyval; + GdkModifierType modifiers; + + gimp_device_info_get_key (info, i, &keyval, &modifiers); + + if (keyval) + { + gchar *accel; + gchar *escaped; + + accel = gtk_accelerator_name (keyval, modifiers); + escaped = g_strescape (accel, NULL); + g_free (accel); + + g_value_set_string (&string_value, escaped); + g_free (escaped); + } + else + { + g_value_set_string (&string_value, ""); + } + + gimp_value_array_append (array, &string_value); + } + + g_value_unset (&string_value); + + g_value_take_boxed (value, array); + } + break; + + case PROP_PRESSURE_CURVE: + g_value_set_object (value, info->pressure_curve); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_device_info_guess_icon (GimpDeviceInfo *info) +{ + GimpViewable *viewable = GIMP_VIEWABLE (info); + + if (gimp_object_get_name (viewable) && + ! strcmp (gimp_viewable_get_icon_name (viewable), + GIMP_VIEWABLE_GET_CLASS (viewable)->default_icon_name)) + { + const gchar *icon_name = NULL; + gchar *down = g_ascii_strdown (gimp_object_get_name (viewable), + -1); + + if (strstr (down, "eraser")) + { + icon_name = GIMP_ICON_TOOL_ERASER; + } + else if (strstr (down, "pen")) + { + icon_name = GIMP_ICON_TOOL_PAINTBRUSH; + } + else if (strstr (down, "airbrush")) + { + icon_name = GIMP_ICON_TOOL_AIRBRUSH; + } + else if (strstr (down, "cursor") || + strstr (down, "mouse") || + strstr (down, "pointer") || + strstr (down, "touchpad") || + strstr (down, "trackpoint")) + { + icon_name = GIMP_ICON_CURSOR; + } + + g_free (down); + + if (icon_name) + gimp_viewable_set_icon_name (viewable, icon_name); + } +} + + +/* public functions */ + +GimpDeviceInfo * +gimp_device_info_new (Gimp *gimp, + GdkDevice *device, + GdkDisplay *display) +{ + GimpContext *context; + GimpToolInfo *tool_info; + + g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); + g_return_val_if_fail (GDK_IS_DEVICE (device), NULL); + g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); + + context = gimp_get_user_context (gimp); + tool_info = gimp_context_get_tool (context); + + g_return_val_if_fail (tool_info != NULL, NULL); + + return g_object_new (GIMP_TYPE_DEVICE_INFO, + "gimp", gimp, + "device", device, + "display", display, + "tool-options", tool_info->tool_options, + NULL); +} + +GdkDevice * +gimp_device_info_get_device (GimpDeviceInfo *info, + GdkDisplay **display) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), NULL); + + if (display) + *display = info->display; + + return info->device; +} + +gboolean +gimp_device_info_set_device (GimpDeviceInfo *info, + GdkDevice *device, + GdkDisplay *display) +{ + gint i; + + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), FALSE); + g_return_val_if_fail ((device == NULL && display == NULL) || + (GDK_IS_DEVICE (device) && GDK_IS_DISPLAY (display)), + FALSE); + + if (device && info->device) + { + g_printerr ("%s: trying to set GdkDevice '%s' on GimpDeviceInfo " + "which already has a device\n", + G_STRFUNC, gdk_device_get_name (device)); + +#ifdef G_OS_WIN32 + /* This is a very weird/dirty difference we make between Win32 and + * Linux. On Linux, we had breakage because of duplicate devices, + * fixed by overwriting the info's old device (assuming it to be + * dead) with the new one. Unfortunately doing this on Windows + * too broke a lot of devices (which used to work with the old + * way). See the regression bug #2495. + * + * NOTE that this only happens if something is wrong on the USB + * or udev or libinput or whatever side and the same device is + * present multiple times. Therefore there doesn't seem to be an + * absolute single "solution" to this problem (well there is, but + * probably not in GIMP, where we can only react). This is more + * of an experimenting-in-real-life kind of bug. + * Also we had no clear report on macOS or BSD (AFAIK) of broken + * tablets with any of the version of the code. So let's keep + * these similar to Linux for now. + */ + return FALSE; +#endif /* G_OS_WIN32 */ + } + else if (! device && ! info->device) + { + g_printerr ("%s: trying to unset GdkDevice of GimpDeviceInfo '%s'" + "which has no device\n", + G_STRFUNC, gimp_object_get_name (info)); + + /* bail out, unsetting twice makes no sense */ + return FALSE; + } + + g_return_val_if_fail (device == NULL || + strcmp (gdk_device_get_name (device), + gimp_object_get_name (info)) == 0, FALSE); + + if (device) + { + info->device = device; + info->display = display; + + g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, info); + + gimp_device_info_set_mode (info, info->mode); + + if (info->n_axes != device->num_axes) + g_printerr ("%s: stored 'num-axes' for device '%s' doesn't match " + "number of axes present in device\n", + G_STRFUNC, device->name); + + for (i = 0; i < MIN (info->n_axes, device->num_axes); i++) + gimp_device_info_set_axis_use (info, i, + info->axes[i]); + + if (info->n_keys != device->num_keys) + g_printerr ("%s: stored 'num-keys' for device '%s' doesn't match " + "number of keys present in device\n", + G_STRFUNC, device->name); + + for (i = 0; i < MIN (info->n_keys, device->num_keys); i++) + gimp_device_info_set_key (info, i, + info->keys[i].keyval, + info->keys[i].modifiers); + } + else + { + device = info->device; + display = info->display; + + info->device = NULL; + info->display = NULL; + + g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, NULL); + + gimp_device_info_set_mode (info, device->mode); + + info->n_axes = device->num_axes; + info->axes = g_renew (GdkAxisUse, info->axes, info->n_axes); + memset (info->axes, 0, info->n_axes * sizeof (GdkAxisUse)); + + for (i = 0; i < info->n_axes; i++) + gimp_device_info_set_axis_use (info, i, + device->axes[i].use); + + info->n_keys = device->num_keys; + info->keys = g_renew (GdkDeviceKey, info->keys, info->n_keys); + memset (info->keys, 0, info->n_keys * sizeof (GdkDeviceKey)); + + for (i = 0; i < MIN (info->n_keys, device->num_keys); i++) + gimp_device_info_set_key (info, i, + device->keys[i].keyval, + device->keys[i].modifiers); + } + + /* sort order depends on device presence */ + gimp_object_name_changed (GIMP_OBJECT (info)); + + g_object_notify (G_OBJECT (info), "device"); + + return TRUE; +} + +void +gimp_device_info_set_default_tool (GimpDeviceInfo *info) +{ + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + + if (info->device && + gdk_device_get_source (info->device) == GDK_SOURCE_ERASER) + { + GimpContainer *tools = GIMP_TOOL_PRESET (info)->gimp->tool_info_list; + GimpToolInfo *eraser; + + eraser = + GIMP_TOOL_INFO (gimp_container_get_child_by_name (tools, + "gimp-eraser-tool")); + + if (eraser) + g_object_set (info, + "tool-options", eraser->tool_options, + NULL); + } +} + +void +gimp_device_info_save_tool (GimpDeviceInfo *info) +{ + GimpToolPreset *preset = GIMP_TOOL_PRESET (info); + GimpContext *user_context; + GimpToolInfo *tool_info; + GimpContextPropMask serialize_props; + + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + + user_context = gimp_get_user_context (GIMP_TOOL_PRESET (info)->gimp); + + tool_info = gimp_context_get_tool (user_context); + + g_object_set (info, + "tool-options", tool_info->tool_options, + NULL); + + serialize_props = + gimp_context_get_serialize_properties (GIMP_CONTEXT (preset->tool_options)); + + g_object_set (preset, + "use-fg-bg", + (serialize_props & GIMP_CONTEXT_PROP_MASK_FOREGROUND) || + (serialize_props & GIMP_CONTEXT_PROP_MASK_BACKGROUND), + + "use-brush", + (serialize_props & GIMP_CONTEXT_PROP_MASK_BRUSH) != 0, + + "use-dynamics", + (serialize_props & GIMP_CONTEXT_PROP_MASK_DYNAMICS) != 0, + + "use-mypaint-brush", + (serialize_props & GIMP_CONTEXT_PROP_MASK_MYBRUSH) != 0, + + "use-gradient", + (serialize_props & GIMP_CONTEXT_PROP_MASK_GRADIENT) != 0, + + "use-pattern", + (serialize_props & GIMP_CONTEXT_PROP_MASK_PATTERN) != 0, + + "use-palette", + (serialize_props & GIMP_CONTEXT_PROP_MASK_PALETTE) != 0, + + "use-font", + (serialize_props & GIMP_CONTEXT_PROP_MASK_FONT) != 0, + + NULL); +} + +void +gimp_device_info_restore_tool (GimpDeviceInfo *info) +{ + GimpToolPreset *preset; + GimpContext *user_context; + + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + + preset = GIMP_TOOL_PRESET (info); + + user_context = gimp_get_user_context (GIMP_TOOL_PRESET (info)->gimp); + + if (preset->tool_options) + { + if (gimp_context_get_tool_preset (user_context) != preset) + { + gimp_context_set_tool_preset (user_context, preset); + } + else + { + gimp_context_tool_preset_changed (user_context); + } + } +} + +GdkInputMode +gimp_device_info_get_mode (GimpDeviceInfo *info) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), GDK_MODE_DISABLED); + + if (info->device) + return info->device->mode; + else + return info->mode; +} + +void +gimp_device_info_set_mode (GimpDeviceInfo *info, + GdkInputMode mode) +{ + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + + if (mode != gimp_device_info_get_mode (info)) + { + if (info->device) + gdk_device_set_mode (info->device, mode); + else + info->mode = mode; + + g_object_notify (G_OBJECT (info), "mode"); + } +} + +gboolean +gimp_device_info_has_cursor (GimpDeviceInfo *info) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), FALSE); + + if (info->device) + return info->device->has_cursor; + + return FALSE; +} + +gint +gimp_device_info_get_n_axes (GimpDeviceInfo *info) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), 0); + + if (info->device) + return info->device->num_axes; + else + return info->n_axes; +} + +GdkAxisUse +gimp_device_info_get_axis_use (GimpDeviceInfo *info, + gint axis) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), GDK_AXIS_IGNORE); + g_return_val_if_fail (axis >= 0 && axis < gimp_device_info_get_n_axes (info), + GDK_AXIS_IGNORE); + + if (info->device) + return info->device->axes[axis].use; + else + return info->axes[axis]; +} + +void +gimp_device_info_set_axis_use (GimpDeviceInfo *info, + gint axis, + GdkAxisUse use) +{ + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + g_return_if_fail (axis >= 0 && axis < gimp_device_info_get_n_axes (info)); + + if (use != gimp_device_info_get_axis_use (info, axis)) + { + if (info->device) + gdk_device_set_axis_use (info->device, axis, use); + + info->axes[axis] = use; + + g_object_notify (G_OBJECT (info), "axes"); + } +} + +gint +gimp_device_info_get_n_keys (GimpDeviceInfo *info) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), 0); + + if (info->device) + return info->device->num_keys; + else + return info->n_keys; +} + +void +gimp_device_info_get_key (GimpDeviceInfo *info, + gint key, + guint *keyval, + GdkModifierType *modifiers) +{ + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + g_return_if_fail (key >= 0 && key < gimp_device_info_get_n_keys (info)); + g_return_if_fail (keyval != NULL); + g_return_if_fail (modifiers != NULL); + + if (info->device) + { + *keyval = info->device->keys[key].keyval; + *modifiers = info->device->keys[key].modifiers; + } + else + { + *keyval = info->keys[key].keyval; + *modifiers = info->keys[key].modifiers; + } +} + +void +gimp_device_info_set_key (GimpDeviceInfo *info, + gint key, + guint keyval, + GdkModifierType modifiers) +{ + guint old_keyval; + GdkModifierType old_modifiers; + + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + g_return_if_fail (key >= 0 && key < gimp_device_info_get_n_keys (info)); + + gimp_device_info_get_key (info, key, &old_keyval, &old_modifiers); + + if (keyval != old_keyval || + modifiers != old_modifiers) + { + if (info->device) + gdk_device_set_key (info->device, key, keyval, modifiers); + + info->keys[key].keyval = keyval; + info->keys[key].modifiers = modifiers; + + g_object_notify (G_OBJECT (info), "keys"); + } +} + +GimpCurve * +gimp_device_info_get_curve (GimpDeviceInfo *info, + GdkAxisUse use) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), NULL); + + switch (use) + { + case GDK_AXIS_PRESSURE: + return info->pressure_curve; + break; + + default: + return NULL; + } +} + +gdouble +gimp_device_info_map_axis (GimpDeviceInfo *info, + GdkAxisUse use, + gdouble value) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), value); + + /* CLAMP() the return values be safe against buggy XInput drivers */ + + switch (use) + { + case GDK_AXIS_PRESSURE: + return gimp_curve_map_value (info->pressure_curve, value); + + case GDK_AXIS_XTILT: + return CLAMP (value, GIMP_COORDS_MIN_TILT, GIMP_COORDS_MAX_TILT); + + case GDK_AXIS_YTILT: + return CLAMP (value, GIMP_COORDS_MIN_TILT, GIMP_COORDS_MAX_TILT); + + case GDK_AXIS_WHEEL: + return CLAMP (value, GIMP_COORDS_MIN_WHEEL, GIMP_COORDS_MAX_WHEEL); + + default: + break; + } + + return value; +} + +GimpDeviceInfo * +gimp_device_info_get_by_device (GdkDevice *device) +{ + g_return_val_if_fail (GDK_IS_DEVICE (device), NULL); + + return g_object_get_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY); +} + +gint +gimp_device_info_compare (GimpDeviceInfo *a, + GimpDeviceInfo *b) +{ + if (a->device && a->display && + a->device == gdk_display_get_core_pointer (a->display)) + { + return -1; + } + else if (b->device && b->display && + b->device == gdk_display_get_core_pointer (b->display)) + { + return 1; + } + else if (a->device && ! b->device) + { + return -1; + } + else if (! a->device && b->device) + { + return 1; + } + else + { + return gimp_object_name_collate ((GimpObject *) a, + (GimpObject *) b); + } +} |