PIKApp/app/widgets/pikadevicemanager.c

727 lines
23 KiB
C
Raw Permalink Normal View History

2023-09-26 00:35:21 +02:00
/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* pikadevicemanager.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 <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <gegl.h>
#include <gtk/gtk.h>
#include "widgets-types.h"
#include "libpikabase/pikabase.h"
#include "config/pikaconfig-utils.h"
#include "config/pikaguiconfig.h"
#include "core/pika.h"
#include "core/pikacontext.h"
#include "core/pikacurve.h"
#include "core/pikatoolinfo.h"
#include "pikadeviceinfo.h"
#include "pikadevicemanager.h"
enum
{
PROP_0,
PROP_PIKA,
PROP_CURRENT_DEVICE
};
struct _PikaDeviceManagerPrivate
{
Pika *pika;
GHashTable *displays;
PikaDeviceInfo *current_device;
PikaToolInfo *active_tool;
};
#define GET_PRIVATE(obj) (((PikaDeviceManager *) (obj))->priv)
static void pika_device_manager_constructed (GObject *object);
static void pika_device_manager_dispose (GObject *object);
static void pika_device_manager_finalize (GObject *object);
static void pika_device_manager_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void pika_device_manager_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void pika_device_manager_display_opened (GdkDisplayManager *disp_manager,
GdkDisplay *display,
PikaDeviceManager *manager);
static void pika_device_manager_display_closed (GdkDisplay *display,
gboolean is_error,
PikaDeviceManager *manager);
static void pika_device_manager_device_added (GdkSeat *seat,
GdkDevice *device,
PikaDeviceManager *manager);
static void pika_device_manager_device_removed (GdkSeat *seat,
GdkDevice *device,
PikaDeviceManager *manager);
static void pika_device_manager_config_notify (PikaGuiConfig *config,
const GParamSpec *pspec,
PikaDeviceManager *manager);
static void pika_device_manager_tool_changed (PikaContext *user_context,
PikaToolInfo *tool_info,
PikaDeviceManager *manager);
static void pika_device_manager_connect_tool (PikaDeviceManager *manager);
static void pika_device_manager_disconnect_tool (PikaDeviceManager *manager);
static void pika_device_manager_device_defaults (GdkSeat *seat,
GdkDevice *device,
PikaDeviceManager *manager);
G_DEFINE_TYPE_WITH_PRIVATE (PikaDeviceManager, pika_device_manager,
PIKA_TYPE_LIST)
#define parent_class pika_device_manager_parent_class
static void
pika_device_manager_class_init (PikaDeviceManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructed = pika_device_manager_constructed;
object_class->dispose = pika_device_manager_dispose;
object_class->finalize = pika_device_manager_finalize;
object_class->set_property = pika_device_manager_set_property;
object_class->get_property = pika_device_manager_get_property;
g_object_class_install_property (object_class, PROP_PIKA,
g_param_spec_object ("pika",
NULL, NULL,
PIKA_TYPE_PIKA,
PIKA_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,
PIKA_TYPE_DEVICE_INFO,
PIKA_PARAM_STATIC_STRINGS |
G_PARAM_READABLE));
}
static void
pika_device_manager_init (PikaDeviceManager *manager)
{
manager->priv = pika_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
pika_device_manager_constructed (GObject *object)
{
PikaDeviceManager *manager = PIKA_DEVICE_MANAGER (object);
PikaDeviceManagerPrivate *private = GET_PRIVATE (object);
GdkDisplayManager *disp_manager;
GSList *displays;
GSList *list;
GdkDisplay *display;
GdkSeat *seat;
GdkDevice *pointer;
PikaDeviceInfo *device_info;
PikaContext *user_context;
G_OBJECT_CLASS (parent_class)->constructed (object);
pika_assert (PIKA_IS_PIKA (private->pika));
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))
{
pika_device_manager_display_opened (disp_manager, list->data, manager);
}
g_slist_free (displays);
g_signal_connect (disp_manager, "display-opened",
G_CALLBACK (pika_device_manager_display_opened),
manager);
display = gdk_display_get_default ();
seat = gdk_display_get_default_seat (display);
pointer = gdk_seat_get_pointer (seat);
device_info = pika_device_info_get_by_device (pointer);
pika_device_manager_set_current_device (manager, device_info);
g_signal_connect_object (private->pika->config, "notify::devices-share-tool",
G_CALLBACK (pika_device_manager_config_notify),
manager, 0);
user_context = pika_get_user_context (private->pika);
g_signal_connect_object (user_context, "tool-changed",
G_CALLBACK (pika_device_manager_tool_changed),
manager, 0);
}
static void
pika_device_manager_dispose (GObject *object)
{
PikaDeviceManager *manager = PIKA_DEVICE_MANAGER (object);
pika_device_manager_disconnect_tool (manager);
g_signal_handlers_disconnect_by_func (gdk_display_manager_get (),
pika_device_manager_display_opened,
object);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
pika_device_manager_finalize (GObject *object)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (object);
g_clear_pointer (&private->displays, g_hash_table_unref);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
pika_device_manager_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (object);
switch (property_id)
{
case PROP_PIKA:
private->pika = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_device_manager_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (object);
switch (property_id)
{
case PROP_PIKA:
g_value_set_object (value, private->pika);
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 */
PikaDeviceManager *
pika_device_manager_new (Pika *pika)
{
g_return_val_if_fail (PIKA_IS_PIKA (pika), NULL);
return g_object_new (PIKA_TYPE_DEVICE_MANAGER,
"pika", pika,
"children-type", PIKA_TYPE_DEVICE_INFO,
"policy", PIKA_CONTAINER_POLICY_STRONG,
"unique-names", TRUE,
"sort-func", pika_device_info_compare,
NULL);
}
PikaDeviceInfo *
pika_device_manager_get_current_device (PikaDeviceManager *manager)
{
g_return_val_if_fail (PIKA_IS_DEVICE_MANAGER (manager), NULL);
return GET_PRIVATE (manager)->current_device;
}
void
pika_device_manager_set_current_device (PikaDeviceManager *manager,
PikaDeviceInfo *info)
{
PikaDeviceManagerPrivate *private;
PikaGuiConfig *config;
g_return_if_fail (PIKA_IS_DEVICE_MANAGER (manager));
g_return_if_fail (PIKA_IS_DEVICE_INFO (info));
private = GET_PRIVATE (manager);
config = PIKA_GUI_CONFIG (private->pika->config);
if (! config->devices_share_tool && private->current_device)
{
pika_device_manager_disconnect_tool (manager);
}
private->current_device = info;
if (! config->devices_share_tool && private->current_device)
{
PikaContext *user_context = pika_get_user_context (private->pika);
g_signal_handlers_block_by_func (user_context,
pika_device_manager_tool_changed,
manager);
pika_device_info_restore_tool (private->current_device);
g_signal_handlers_unblock_by_func (user_context,
pika_device_manager_tool_changed,
manager);
private->active_tool = pika_context_get_tool (user_context);
pika_device_manager_connect_tool (manager);
}
g_object_notify (G_OBJECT (manager), "current-device");
}
void
pika_device_manager_reset (PikaDeviceManager *manager)
{
GdkDisplayManager *disp_manager;
GSList *displays;
GSList *list;
disp_manager = gdk_display_manager_get ();
displays = gdk_display_manager_list_displays (disp_manager);
for (list = displays; list; list = g_slist_next (list))
{
GdkDisplay *display = list->data;
GdkSeat *seat;
GList *devices;
GList *iter;
seat = gdk_display_get_default_seat (display);
devices = gdk_seat_get_slaves (seat, GDK_SEAT_CAPABILITY_ALL_POINTING);
for (iter = devices; iter; iter = g_list_next (iter))
{
GdkDevice *device = iter->data;
pika_device_manager_device_defaults (seat, device, manager);
}
}
g_slist_free (displays);
}
/* private functions */
static void
pika_device_manager_display_opened (GdkDisplayManager *disp_manager,
GdkDisplay *display,
PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
GdkSeat *seat;
GdkDevice *device;
GList *devices;
GList *list;
const gchar *display_name;
gint count;
display_name = gdk_display_get_name (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;
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
pika_device_manager_device_added (seat, device, manager);
devices = gdk_seat_get_slaves (seat, GDK_SEAT_CAPABILITY_ALL_POINTING);
/* create device info structures for present devices */
for (list = devices; list; list = g_list_next (list))
{
device = list->data;
pika_device_manager_device_added (seat, device, manager);
}
g_list_free (devices);
g_signal_connect (seat, "device-added",
G_CALLBACK (pika_device_manager_device_added),
manager);
g_signal_connect (seat, "device-removed",
G_CALLBACK (pika_device_manager_device_removed),
manager);
g_signal_connect (display, "closed",
G_CALLBACK (pika_device_manager_display_closed),
manager);
}
static void
pika_device_manager_display_closed (GdkDisplay *display,
gboolean is_error,
PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
GdkSeat *seat;
GdkDevice *device;
GList *devices;
GList *list;
const gchar *display_name;
gint count;
display_name = gdk_display_get_name (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);
seat = gdk_display_get_default_seat (display);
g_signal_handlers_disconnect_by_func (seat,
pika_device_manager_device_added,
manager);
g_signal_handlers_disconnect_by_func (seat,
pika_device_manager_device_removed,
manager);
g_signal_handlers_disconnect_by_func (display,
pika_device_manager_display_closed,
manager);
device = gdk_seat_get_pointer (seat);
pika_device_manager_device_removed (seat, device, manager);
devices = gdk_seat_get_slaves (seat, GDK_SEAT_CAPABILITY_ALL_POINTING);
for (list = devices; list; list = list->next)
{
device = list->data;
pika_device_manager_device_removed (seat, device, manager);
}
g_list_free (devices);
}
static void
pika_device_manager_device_added (GdkSeat *seat,
GdkDevice *device,
PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
GdkDisplay *display;
PikaDeviceInfo *device_info;
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
return;
pika_device_manager_device_defaults (seat, device, manager);
display = gdk_seat_get_display (seat);
device_info =
PIKA_DEVICE_INFO (pika_container_get_child_by_name (PIKA_CONTAINER (manager),
gdk_device_get_name (device)));
if (device_info)
{
pika_device_info_set_device (device_info, device, display);
}
else
{
device_info = pika_device_info_new (private->pika, device, display);
pika_device_info_set_default_tool (device_info);
pika_container_add (PIKA_CONTAINER (manager), PIKA_OBJECT (device_info));
g_object_unref (device_info);
}
}
static void
pika_device_manager_device_removed (GdkSeat *seat,
GdkDevice *device,
PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
PikaDeviceInfo *device_info;
device_info =
PIKA_DEVICE_INFO (pika_container_get_child_by_name (PIKA_CONTAINER (manager),
gdk_device_get_name (device)));
if (device_info)
{
pika_device_info_set_device (device_info, NULL, NULL);
if (device_info == private->current_device)
{
device = gdk_seat_get_pointer (seat);
device_info = pika_device_info_get_by_device (device);
pika_device_manager_set_current_device (manager, device_info);
}
}
}
static void
pika_device_manager_config_notify (PikaGuiConfig *config,
const GParamSpec *pspec,
PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
PikaDeviceInfo *current_device;
current_device = pika_device_manager_get_current_device (manager);
if (config->devices_share_tool)
{
pika_device_manager_disconnect_tool (manager);
pika_device_info_save_tool (current_device);
}
else
{
PikaContext *user_context = pika_get_user_context (private->pika);
g_signal_handlers_block_by_func (user_context,
pika_device_manager_tool_changed,
manager);
pika_device_info_restore_tool (private->current_device);
g_signal_handlers_unblock_by_func (user_context,
pika_device_manager_tool_changed,
manager);
private->active_tool = pika_context_get_tool (user_context);
pika_device_manager_connect_tool (manager);
}
}
static void
pika_device_manager_tool_changed (PikaContext *user_context,
PikaToolInfo *tool_info,
PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
PikaGuiConfig *config;
config = PIKA_GUI_CONFIG (private->pika->config);
if (! config->devices_share_tool)
{
pika_device_manager_disconnect_tool (manager);
}
private->active_tool = tool_info;
if (! config->devices_share_tool)
{
pika_device_info_save_tool (private->current_device);
pika_device_manager_connect_tool (manager);
}
}
static void
pika_device_manager_connect_tool (PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
PikaGuiConfig *config;
config = PIKA_GUI_CONFIG (private->pika->config);
if (! config->devices_share_tool &&
private->active_tool && private->current_device)
{
PikaToolPreset *preset = PIKA_TOOL_PRESET (private->current_device);
pika_config_connect (G_OBJECT (private->active_tool->tool_options),
G_OBJECT (preset->tool_options),
NULL);
}
}
static void
pika_device_manager_disconnect_tool (PikaDeviceManager *manager)
{
PikaDeviceManagerPrivate *private = GET_PRIVATE (manager);
PikaGuiConfig *config;
config = PIKA_GUI_CONFIG (private->pika->config);
if (! config->devices_share_tool &&
private->active_tool && private->current_device)
{
PikaToolPreset *preset = PIKA_TOOL_PRESET (private->current_device);
pika_config_disconnect (G_OBJECT (private->active_tool->tool_options),
G_OBJECT (preset->tool_options));
}
}
static void
pika_device_manager_device_defaults (GdkSeat *seat,
GdkDevice *device,
PikaDeviceManager *manager)
{
PikaDeviceInfo *info;
gint i;
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
return;
/* Set default mode for this device. */
if (device == gdk_seat_get_pointer (seat))
{
gdk_device_set_mode (device, GDK_MODE_SCREEN);
}
else if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER)
{
return;
}
else /* slave or floating device */
{
/* default to enabling all devices */
GdkInputMode mode = GDK_MODE_SCREEN;
switch (gdk_device_get_source (device))
{
case GDK_SOURCE_MOUSE:
mode = GDK_MODE_DISABLED;
break;
case GDK_SOURCE_PEN:
case GDK_SOURCE_ERASER:
case GDK_SOURCE_CURSOR:
break;
case GDK_SOURCE_TOUCHSCREEN:
case GDK_SOURCE_TOUCHPAD:
case GDK_SOURCE_TRACKPOINT:
mode = GDK_MODE_DISABLED;
break;
case GDK_SOURCE_TABLET_PAD:
break;
default:
break;
}
if (gdk_device_set_mode (device, mode))
{
g_printerr ("set device '%s' to mode: %s\n",
gdk_device_get_name (device),
g_enum_get_value (g_type_class_peek (GDK_TYPE_INPUT_MODE),
mode)->value_nick);
}
else
{
g_printerr ("failed to set device '%s' to mode: %s\n",
gdk_device_get_name (device),
g_enum_get_value (g_type_class_peek (GDK_TYPE_INPUT_MODE),
mode)->value_nick);
}
}
/* Reset curve for this device. */
info =
PIKA_DEVICE_INFO (pika_container_get_child_by_name (PIKA_CONTAINER (manager),
gdk_device_get_name (device)));
if (info)
{
for (i = 0; i < pika_device_info_get_n_axes (info); i++)
{
PikaCurve *curve;
GdkAxisUse use;
use = pika_device_info_get_axis_use (info, i);
curve = pika_device_info_get_curve (info, use);
if (curve)
pika_curve_reset (curve, TRUE);
}
}
}