dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Gimp/app/widgets/gimpcontrollermanager.c
Jehan 57f8e233f7 app: clean the controller manager off invalid controllers after… 
… controllerrc config file deserialization.

This is the first part to handle #13787 and not a bad idea by itself
per-se, since we remove one way to crash GIMP by creating an invalid
controllerrc file.
2025-10-24 02:24:53 +02:00

385 lines
11 KiB
C
Raw Permalink Blame History

/* 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 <gegl.h>
#include <gtk/gtk.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpconfig/gimpconfig.h"
#include "libgimpwidgets/gimpwidgets.h"
#define GIMP_ENABLE_CONTROLLER_UNDER_CONSTRUCTION
#include "libgimpwidgets/gimpcontroller.h"
#include "widgets-types.h"
#include "core/gimp.h"
#include "core/gimplist.h"
#include "gimpaction.h"
#include "gimpactiongroup.h"
#include "gimpcontrollercategory.h"
#include "gimpcontrollerinfo.h"
#include "gimpcontrollerkeyboard.h"
#include "gimpcontrollermanager.h"
#include "gimpcontrollerwheel.h"
#include "gimpenumaction.h"
#include "gimpuimanager.h"
struct _GimpControllerManager
{
GimpList parent_instance;
Gimp *gimp;
GQuark event_mapped_id;
GimpController *wheel;
GimpController *keyboard;
GimpUIManager *ui_manager;
};
/* local function prototypes */
static void gimp_controller_manager_finalize (GObject *object);
static void gimp_controller_manager_add (GimpContainer *container,
GimpObject *object);
static void gimp_controller_manager_remove (GimpContainer *container,
GimpObject *object);
static gboolean gimp_controller_manager_event_mapped (GimpControllerInfo *info,
GimpController *controller,
const GimpControllerEvent *event,
const gchar *action_name,
GimpControllerManager *manager);
static gboolean gimp_controller_search_invalid (GimpObject *object,
gpointer user_data);
G_DEFINE_TYPE (GimpControllerManager, gimp_controller_manager,
GIMP_TYPE_LIST)
#define parent_class gimp_controller_manager_parent_class
static void
gimp_controller_manager_class_init (GimpControllerManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpContainerClass *container_class = GIMP_CONTAINER_CLASS (klass);
object_class->finalize = gimp_controller_manager_finalize;
container_class->add = gimp_controller_manager_add;
container_class->remove = gimp_controller_manager_remove;
}
static void
gimp_controller_manager_init (GimpControllerManager *self)
{
g_type_class_ref (GIMP_TYPE_CONTROLLER_WHEEL);
g_type_class_ref (GIMP_TYPE_CONTROLLER_KEYBOARD);
}
static void
gimp_controller_manager_finalize (GObject *object)
{
g_type_class_unref (g_type_class_peek (GIMP_TYPE_CONTROLLER_WHEEL));
g_type_class_unref (g_type_class_peek (GIMP_TYPE_CONTROLLER_KEYBOARD));
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_controller_manager_add (GimpContainer *container,
GimpObject *object)
{
GimpControllerManager *self = GIMP_CONTROLLER_MANAGER (container);
GimpControllerInfo *info = GIMP_CONTROLLER_INFO (object);
g_signal_connect_object (info, "event-mapped",
G_CALLBACK (gimp_controller_manager_event_mapped),
G_OBJECT (self), 0);
if (GIMP_IS_CONTROLLER_WHEEL (info->controller))
self->wheel = info->controller;
else if (GIMP_IS_CONTROLLER_KEYBOARD (info->controller))
self->keyboard = info->controller;
GIMP_CONTAINER_CLASS (parent_class)->add (container, object);
}
static void
gimp_controller_manager_remove (GimpContainer *container,
GimpObject *object)
{
GimpControllerManager *self = GIMP_CONTROLLER_MANAGER (container);
GimpControllerInfo *info = GIMP_CONTROLLER_INFO (object);
if (info->controller == self->wheel)
self->wheel = NULL;
else if (info->controller == self->keyboard)
self->keyboard = NULL;
GIMP_CONTAINER_CLASS (parent_class)->remove (container, object);
}
/* public functions */
GimpControllerManager *
gimp_controller_manager_new (Gimp *gimp)
{
GimpControllerManager *self;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
self = g_object_new (GIMP_TYPE_CONTROLLER_MANAGER,
"child-type", GIMP_TYPE_CONTROLLER_INFO,
NULL);
self->gimp = gimp;
return self;
}
void
gimp_controller_manager_restore (GimpControllerManager *self,
GimpUIManager *ui_manager)
{
GFile *file;
GimpObject *found;
GError *error = NULL;
g_return_if_fail (GIMP_IS_CONTROLLER_MANAGER (self));
g_return_if_fail (GIMP_IS_UI_MANAGER (ui_manager));
g_return_if_fail (self->ui_manager == NULL);
self->ui_manager = ui_manager;
file = gimp_directory_file ("controllerrc", NULL);
if (self->gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file));
if (! gimp_config_deserialize_file (GIMP_CONFIG (self),
file, NULL, &error))
{
if (error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT)
{
g_clear_error (&error);
g_object_unref (file);
if (g_getenv ("GIMP_TESTING_ABS_TOP_SRCDIR"))
{
gchar *path;
path = g_build_filename (g_getenv ("GIMP_TESTING_ABS_TOP_SRCDIR"),
"etc", "controllerrc", NULL);
file = g_file_new_for_path (path);
g_free (path);
}
else
{
file = gimp_sysconf_directory_file ("controllerrc", NULL);
}
if (! gimp_config_deserialize_file (GIMP_CONFIG (self),
file, NULL, &error))
{
gimp_message_literal (self->gimp, NULL, GIMP_MESSAGE_ERROR,
error->message);
}
}
else
{
gimp_message_literal (self->gimp, NULL, GIMP_MESSAGE_ERROR,
error->message);
}
g_clear_error (&error);
}
gimp_list_reverse (GIMP_LIST (self));
while ((found = gimp_container_search (GIMP_CONTAINER (self),
(GimpContainerSearchFunc) gimp_controller_search_invalid,
NULL)))
/* Clean out the manager off invalid controllers. This may happen
* in particular with the removed GimpControllerMouse, which our
* migration code would translate as a deserialized
* GimpControllerInfo with NULL controller.
*/
gimp_container_remove (GIMP_CONTAINER (self), found);
g_object_unref (file);
}
void
gimp_controller_manager_save (GimpControllerManager *self)
{
const gchar *header =
"GIMP controllerrc\n"
"\n"
"This file will be entirely rewritten each time you exit.";
const gchar *footer =
"end of controllerrc";
GFile *file;
GError *error = NULL;
g_return_if_fail (GIMP_IS_CONTROLLER_MANAGER (self));
file = gimp_directory_file ("controllerrc", NULL);
if (self->gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file));
if (! gimp_config_serialize_to_file (GIMP_CONFIG (self),
file,
header, footer, NULL,
&error))
{
gimp_message_literal (self->gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_error_free (error);
}
g_object_unref (file);
}
Gimp *
gimp_controller_manager_get_gimp (GimpControllerManager *self)
{
g_return_val_if_fail (GIMP_IS_CONTROLLER_MANAGER (self), NULL);
return self->gimp;
}
GimpUIManager *
gimp_controller_manager_get_ui_manager (GimpControllerManager *self)
{
g_return_val_if_fail (GIMP_IS_CONTROLLER_MANAGER (self), NULL);
return self->ui_manager;
}
GimpController *
gimp_controller_manager_get_wheel (GimpControllerManager *self)
{
g_return_val_if_fail (GIMP_IS_CONTROLLER_MANAGER (self), NULL);
return self->wheel;
}
GimpController *
gimp_controller_manager_get_keyboard (GimpControllerManager *self)
{
g_return_val_if_fail (GIMP_IS_CONTROLLER_MANAGER (self), NULL);
return self->keyboard;
}
GListModel *
gimp_controller_manager_get_categories (GimpControllerManager *self)
{
GListStore *categories;
GType *controller_types;
guint n_controller_types;
g_return_val_if_fail (GIMP_IS_CONTROLLER_MANAGER (self), NULL);
categories = g_list_store_new (GIMP_TYPE_CONTROLLER_CATEGORY);
controller_types = g_type_children (GIMP_TYPE_CONTROLLER,
&n_controller_types);
for (guint i = 0; i < n_controller_types; i++)
{
GimpControllerCategory *category;
category = gimp_controller_category_new (controller_types[i]);
g_list_store_append (G_LIST_STORE (categories), category);
g_object_unref (category);
}
g_free (controller_types);
return G_LIST_MODEL (categories);
}
/* private functions */
static gboolean
gimp_controller_manager_event_mapped (GimpControllerInfo *info,
GimpController *controller,
const GimpControllerEvent *event,
const gchar *action_name,
GimpControllerManager *manager)
{
GList *list;
for (list = gimp_ui_manager_get_action_groups (manager->ui_manager);
list;
list = g_list_next (list))
{
GimpActionGroup *group = list->data;
GimpAction *action;
action = gimp_action_group_get_action (group, action_name);
if (action)
{
switch (event->type)
{
case GIMP_CONTROLLER_EVENT_VALUE:
if (G_VALUE_HOLDS_DOUBLE (&event->value.value) &&
GIMP_IS_ENUM_ACTION (action) &&
GIMP_ENUM_ACTION (action)->value_variable)
{
gdouble value = g_value_get_double (&event->value.value);
gimp_action_emit_activate (GIMP_ACTION (action),
g_variant_new_int32 (value * 1000));
break;
}
/* else fallthru */
case GIMP_CONTROLLER_EVENT_TRIGGER:
default:
gimp_action_activate (action);
break;
}
return TRUE;
}
}
return FALSE;
}
static gboolean
gimp_controller_search_invalid (GimpObject *object,
gpointer user_data)
{
return (GIMP_CONTROLLER_INFO (object)->controller == NULL);
}
Reference in a new issue View git blame Copy permalink