From 3c57dd931145d43f2b0aef96c4d178135956bf91 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 05:13:10 +0200 Subject: Adding upstream version 2.10.36. Signed-off-by: Daniel Baumann --- app/widgets/gimpdevicemanager.c | 547 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 547 insertions(+) create mode 100644 app/widgets/gimpdevicemanager.c (limited to 'app/widgets/gimpdevicemanager.c') diff --git a/app/widgets/gimpdevicemanager.c b/app/widgets/gimpdevicemanager.c new file mode 100644 index 0000000..7051de7 --- /dev/null +++ b/app/widgets/gimpdevicemanager.c @@ -0,0 +1,547 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpdevicemanager.c + * Copyright (C) 2011 Michael Natterer + * + * 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 . + */ + +#include "config.h" + +#undef GSEAL_ENABLE + +#include +#include + +#include "widgets-types.h" + +#include "config/gimpconfig-utils.h" +#include "config/gimpguiconfig.h" + +#include "core/gimp.h" +#include "core/gimpcontext.h" +#include "core/gimpmarshal.h" +#include "core/gimptoolinfo.h" + +#include "gimpdeviceinfo.h" +#include "gimpdevicemanager.h" + + +enum +{ + PROP_0, + PROP_GIMP, + PROP_CURRENT_DEVICE +}; + + + +struct _GimpDeviceManagerPrivate +{ + Gimp *gimp; + GHashTable *displays; + GimpDeviceInfo *current_device; + GimpToolInfo *active_tool; +}; + +#define GET_PRIVATE(obj) (((GimpDeviceManager *) (obj))->priv) + + +static void gimp_device_manager_constructed (GObject *object); +static void gimp_device_manager_dispose (GObject *object); +static void gimp_device_manager_finalize (GObject *object); +static void gimp_device_manager_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_device_manager_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + +static void gimp_device_manager_display_opened (GdkDisplayManager *disp_manager, + GdkDisplay *display, + GimpDeviceManager *manager); +static void gimp_device_manager_display_closed (GdkDisplay *display, + gboolean is_error, + GimpDeviceManager *manager); + +static void gimp_device_manager_device_added (GdkDisplay *gdk_display, + GdkDevice *device, + GimpDeviceManager *manager); +static void gimp_device_manager_device_removed (GdkDisplay *gdk_display, + GdkDevice *device, + GimpDeviceManager *manager); + +static void gimp_device_manager_config_notify (GimpGuiConfig *config, + const GParamSpec *pspec, + GimpDeviceManager *manager); + +static void gimp_device_manager_tool_changed (GimpContext *user_context, + GimpToolInfo *tool_info, + GimpDeviceManager *manager); + +static void gimp_device_manager_connect_tool (GimpDeviceManager *manager); +static void gimp_device_manager_disconnect_tool (GimpDeviceManager *manager); + + +G_DEFINE_TYPE_WITH_PRIVATE (GimpDeviceManager, gimp_device_manager, + GIMP_TYPE_LIST) + +#define parent_class gimp_device_manager_parent_class + + +static void +gimp_device_manager_class_init (GimpDeviceManagerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->constructed = gimp_device_manager_constructed; + object_class->dispose = gimp_device_manager_dispose; + object_class->finalize = gimp_device_manager_finalize; + object_class->set_property = gimp_device_manager_set_property; + object_class->get_property = gimp_device_manager_get_property; + + g_object_class_install_property (object_class, PROP_GIMP, + g_param_spec_object ("gimp", + NULL, NULL, + GIMP_TYPE_GIMP, + GIMP_PARAM_STATIC_STRINGS | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + + g_object_class_install_property (object_class, PROP_CURRENT_DEVICE, + g_param_spec_object ("current-device", + NULL, NULL, + GIMP_TYPE_DEVICE_INFO, + GIMP_PARAM_STATIC_STRINGS | + G_PARAM_READABLE)); +} + +static void +gimp_device_manager_init (GimpDeviceManager *manager) +{ + manager->priv = gimp_device_manager_get_instance_private (manager); + + manager->priv->displays = g_hash_table_new_full (g_str_hash, + g_str_equal, + g_free, NULL); +} + +static void +gimp_device_manager_constructed (GObject *object) +{ + GimpDeviceManager *manager = GIMP_DEVICE_MANAGER (object); + GimpDeviceManagerPrivate *private = GET_PRIVATE (object); + GdkDisplayManager *disp_manager; + GSList *displays; + GSList *list; + GdkDisplay *display; + GimpDeviceInfo *device_info; + GimpContext *user_context; + + G_OBJECT_CLASS (parent_class)->constructed (object); + + gimp_assert (GIMP_IS_GIMP (private->gimp)); + + disp_manager = gdk_display_manager_get (); + + displays = gdk_display_manager_list_displays (disp_manager); + + /* present displays in the order in which they were opened */ + displays = g_slist_reverse (displays); + + for (list = displays; list; list = g_slist_next (list)) + { + gimp_device_manager_display_opened (disp_manager, list->data, manager); + } + + g_slist_free (displays); + + g_signal_connect (disp_manager, "display-opened", + G_CALLBACK (gimp_device_manager_display_opened), + manager); + + display = gdk_display_get_default (); + + device_info = + gimp_device_info_get_by_device (gdk_display_get_core_pointer (display)); + + gimp_device_manager_set_current_device (manager, device_info); + + g_signal_connect_object (private->gimp->config, "notify::devices-share-tool", + G_CALLBACK (gimp_device_manager_config_notify), + manager, 0); + + user_context = gimp_get_user_context (private->gimp); + + g_signal_connect_object (user_context, "tool-changed", + G_CALLBACK (gimp_device_manager_tool_changed), + manager, 0); +} + +static void +gimp_device_manager_dispose (GObject *object) +{ + GimpDeviceManager *manager = GIMP_DEVICE_MANAGER (object); + + gimp_device_manager_disconnect_tool (manager); + + g_signal_handlers_disconnect_by_func (gdk_display_manager_get (), + gimp_device_manager_display_opened, + object); + + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static void +gimp_device_manager_finalize (GObject *object) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (object); + + g_clear_pointer (&private->displays, g_hash_table_unref); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_device_manager_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (object); + + switch (property_id) + { + case PROP_GIMP: + private->gimp = g_value_get_object (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_device_manager_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (object); + + switch (property_id) + { + case PROP_GIMP: + g_value_set_object (value, private->gimp); + break; + + case PROP_CURRENT_DEVICE: + g_value_set_object (value, private->current_device); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + +/* public functions */ + +GimpDeviceManager * +gimp_device_manager_new (Gimp *gimp) +{ + g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); + + return g_object_new (GIMP_TYPE_DEVICE_MANAGER, + "gimp", gimp, + "children-type", GIMP_TYPE_DEVICE_INFO, + "policy", GIMP_CONTAINER_POLICY_STRONG, + "unique-names", TRUE, + "sort-func", gimp_device_info_compare, + NULL); +} + +GimpDeviceInfo * +gimp_device_manager_get_current_device (GimpDeviceManager *manager) +{ + g_return_val_if_fail (GIMP_IS_DEVICE_MANAGER (manager), NULL); + + return GET_PRIVATE (manager)->current_device; +} + +void +gimp_device_manager_set_current_device (GimpDeviceManager *manager, + GimpDeviceInfo *info) +{ + GimpDeviceManagerPrivate *private; + GimpGuiConfig *config; + + g_return_if_fail (GIMP_IS_DEVICE_MANAGER (manager)); + g_return_if_fail (GIMP_IS_DEVICE_INFO (info)); + + private = GET_PRIVATE (manager); + + config = GIMP_GUI_CONFIG (private->gimp->config); + + if (! config->devices_share_tool && private->current_device) + { + gimp_device_manager_disconnect_tool (manager); + } + + private->current_device = info; + + if (! config->devices_share_tool && private->current_device) + { + GimpContext *user_context = gimp_get_user_context (private->gimp); + + g_signal_handlers_block_by_func (user_context, + gimp_device_manager_tool_changed, + manager); + + gimp_device_info_restore_tool (private->current_device); + + g_signal_handlers_unblock_by_func (user_context, + gimp_device_manager_tool_changed, + manager); + + private->active_tool = gimp_context_get_tool (user_context); + gimp_device_manager_connect_tool (manager); + } + + g_object_notify (G_OBJECT (manager), "current-device"); +} + + +/* private functions */ + +static void +gimp_device_manager_display_opened (GdkDisplayManager *disp_manager, + GdkDisplay *gdk_display, + GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GList *list; + const gchar *display_name; + gint count; + + display_name = gdk_display_get_name (gdk_display); + + count = GPOINTER_TO_INT (g_hash_table_lookup (private->displays, + display_name)); + + g_hash_table_insert (private->displays, g_strdup (display_name), + GINT_TO_POINTER (count + 1)); + + /* don't add the same display twice */ + if (count > 0) + return; + + /* create device info structures for present devices */ + for (list = gdk_display_list_devices (gdk_display); list; list = list->next) + { + GdkDevice *device = list->data; + + gimp_device_manager_device_added (gdk_display, device, manager); + } + + g_signal_connect (gdk_display, "closed", + G_CALLBACK (gimp_device_manager_display_closed), + manager); +} + +static void +gimp_device_manager_display_closed (GdkDisplay *gdk_display, + gboolean is_error, + GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GList *list; + const gchar *display_name; + gint count; + + display_name = gdk_display_get_name (gdk_display); + + count = GPOINTER_TO_INT (g_hash_table_lookup (private->displays, + display_name)); + + /* don't remove the same display twice */ + if (count > 1) + { + g_hash_table_insert (private->displays, g_strdup (display_name), + GINT_TO_POINTER (count - 1)); + return; + } + + g_hash_table_remove (private->displays, display_name); + + for (list = gdk_display_list_devices (gdk_display); list; list = list->next) + { + GdkDevice *device = list->data; + + gimp_device_manager_device_removed (gdk_display, device, manager); + } +} + +static void +gimp_device_manager_device_added (GdkDisplay *gdk_display, + GdkDevice *device, + GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GimpDeviceInfo *device_info; + + device_info = + GIMP_DEVICE_INFO (gimp_container_get_child_by_name (GIMP_CONTAINER (manager), + device->name)); + + if (device_info) + { + gimp_device_info_set_device (device_info, device, gdk_display); + } + else + { + device_info = gimp_device_info_new (private->gimp, device, gdk_display); + + gimp_device_info_set_default_tool (device_info); + + gimp_container_add (GIMP_CONTAINER (manager), GIMP_OBJECT (device_info)); + g_object_unref (device_info); + } +} + +static void +gimp_device_manager_device_removed (GdkDisplay *gdk_display, + GdkDevice *device, + GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GimpDeviceInfo *device_info; + + device_info = + GIMP_DEVICE_INFO (gimp_container_get_child_by_name (GIMP_CONTAINER (manager), + device->name)); + + if (device_info) + { + gimp_device_info_set_device (device_info, NULL, NULL); + + if (device_info == private->current_device) + { + device = gdk_display_get_core_pointer (gdk_display); + device_info = gimp_device_info_get_by_device (device); + + gimp_device_manager_set_current_device (manager, device_info); + } + } +} + +static void +gimp_device_manager_config_notify (GimpGuiConfig *config, + const GParamSpec *pspec, + GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GimpDeviceInfo *current_device; + + current_device = gimp_device_manager_get_current_device (manager); + + if (config->devices_share_tool) + { + gimp_device_manager_disconnect_tool (manager); + gimp_device_info_save_tool (current_device); + } + else + { + GimpContext *user_context = gimp_get_user_context (private->gimp); + + g_signal_handlers_block_by_func (user_context, + gimp_device_manager_tool_changed, + manager); + + gimp_device_info_restore_tool (private->current_device); + + g_signal_handlers_unblock_by_func (user_context, + gimp_device_manager_tool_changed, + manager); + + private->active_tool = gimp_context_get_tool (user_context); + gimp_device_manager_connect_tool (manager); + } +} + +static void +gimp_device_manager_tool_changed (GimpContext *user_context, + GimpToolInfo *tool_info, + GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GimpGuiConfig *config; + + config = GIMP_GUI_CONFIG (private->gimp->config); + + if (! config->devices_share_tool) + { + gimp_device_manager_disconnect_tool (manager); + } + + private->active_tool = tool_info; + + if (! config->devices_share_tool) + { + gimp_device_info_save_tool (private->current_device); + gimp_device_manager_connect_tool (manager); + } +} + +static void +gimp_device_manager_connect_tool (GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GimpGuiConfig *config; + + config = GIMP_GUI_CONFIG (private->gimp->config); + + if (! config->devices_share_tool && + private->active_tool && private->current_device) + { + GimpToolPreset *preset = GIMP_TOOL_PRESET (private->current_device); + + gimp_config_connect (G_OBJECT (private->active_tool->tool_options), + G_OBJECT (preset->tool_options), + NULL); + } +} + +static void +gimp_device_manager_disconnect_tool (GimpDeviceManager *manager) +{ + GimpDeviceManagerPrivate *private = GET_PRIVATE (manager); + GimpGuiConfig *config; + + config = GIMP_GUI_CONFIG (private->gimp->config); + + if (! config->devices_share_tool && + private->active_tool && private->current_device) + { + GimpToolPreset *preset = GIMP_TOOL_PRESET (private->current_device); + + gimp_config_disconnect (G_OBJECT (private->active_tool->tool_options), + G_OBJECT (preset->tool_options)); + } +} -- cgit v1.2.3