dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app, po: remove GimpControllerMouse code. 

The mouse controller had many limitations:

* It was not per-device.
* It was a long hard-coded list of events, which made its evolution
  annoying and scrolling the list boring.
* It was starting at button 8, while the first buttons were supposed to
  be hardcoded interactions. And it stopped at button 12, while some
  device might have more buttons nowadays. See !386.
* The "Grab event" does not seem to work in many cases, according to
  feedbacks.

The new GimpModifiersEditor will now handle any button (except the first
button, which is reserved for tools), you can even override or change
default canvas actions (panning, rotation, etc.). It should not be
limited with a max button number either (though I haven't tested with a
device really having a lot of buttons since I don't have any such device
but I did emulate huge button numbers on my stylus with xsetwacom and it
did work well; hopefully I'll get feedbacks). And now it can even run
custom actions.
So basically it should deprecate the mouse controller as the modifiers
editor can do everything the controller could, and more (unless I missed
anything).
This commit is contained in:
Jehan 2022-08-16 21:49:23 +02:00
parent dd012d11d2
commit 76ddf4421c
9 changed files with 0 additions and 408 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
app/display/gimpdisplayshell-tool-events.c
View File

@ -41,7 +41,6 @@
#include "widgets/gimpaction.h" #include "widgets/gimpaction.h"
#include "widgets/gimpcontrollers.h" #include "widgets/gimpcontrollers.h"
#include "widgets/gimpcontrollerkeyboard.h" #include "widgets/gimpcontrollerkeyboard.h"
#include "widgets/gimpcontrollermouse.h"
#include "widgets/gimpcontrollerwheel.h" #include "widgets/gimpcontrollerwheel.h"
#include "widgets/gimpdeviceinfo.h" #include "widgets/gimpdeviceinfo.h"
#include "widgets/gimpdeviceinfo-coords.h" #include "widgets/gimpdeviceinfo-coords.h"

2
app/widgets/Makefile.am
View File

@ -133,8 +133,6 @@ libappwidgets_a_sources = \
gimpcontrollers.h \ gimpcontrollers.h \
gimpcontrollerkeyboard.c \ gimpcontrollerkeyboard.c \
gimpcontrollerkeyboard.h \ gimpcontrollerkeyboard.h \
gimpcontrollermouse.c \
gimpcontrollermouse.h \
gimpcontrollerwheel.c \ gimpcontrollerwheel.c \
gimpcontrollerwheel.h \ gimpcontrollerwheel.h \
gimpcriticaldialog.c \ gimpcriticaldialog.c \

12
app/widgets/gimpcontrollerlist.c
View File

@ -42,7 +42,6 @@
#include "gimpcontrollerlist.h" #include "gimpcontrollerlist.h"
#include "gimpcontrollerinfo.h" #include "gimpcontrollerinfo.h"
#include "gimpcontrollerkeyboard.h" #include "gimpcontrollerkeyboard.h"
#include "gimpcontrollermouse.h"
#include "gimpcontrollerwheel.h" #include "gimpcontrollerwheel.h"
#include "gimpcontrollers.h" #include "gimpcontrollers.h"
#include "gimpdialogfactory.h" #include "gimpdialogfactory.h"
@ -527,17 +526,6 @@ gimp_controller_list_add_clicked (GtkWidget *button,
"your list of active controllers.")); "your list of active controllers."));
return; return;
} }
else if (list->src_gtype == GIMP_TYPE_CONTROLLER_MOUSE &&
gimp_controllers_get_mouse (list->gimp) != NULL)
{
gimp_message_literal (list->gimp,
G_OBJECT (button), GIMP_MESSAGE_WARNING,
_("There can only be one active mouse "
"controller.\n\n"
"You already have a mouse controller in "
"your list of active controllers."));
return;
}
info = gimp_controller_info_new (list->src_gtype); info = gimp_controller_info_new (list->src_gtype);
container = gimp_controllers_get_list (list->gimp); container = gimp_controllers_get_list (list->gimp);

314
app/widgets/gimpcontrollermouse.c
View File

@ -1,314 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimpcontrollermouse.c
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
* Copyright (C) 2011 Mikael Magnusson <mikachu@src.gnome.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 <gegl.h>
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "gimpcontrollermouse.h"
#include "gimphelp-ids.h"
#include "gimpwidgets-utils.h"
#include "gimp-intl.h"
typedef struct _MouseEvent MouseEvent;
struct _MouseEvent
{
const guint button;
const gchar *modifier_string;
GdkModifierType modifiers;
const gchar *name;
const gchar *blurb;
};
static void gimp_controller_mouse_constructed (GObject *object);
static gint gimp_controller_mouse_get_n_events (GimpController *controller);
static const gchar * gimp_controller_mouse_get_event_name (GimpController *controller,
gint event_id);
static const gchar * gimp_controller_mouse_get_event_blurb (GimpController *controller,
gint event_id);
G_DEFINE_TYPE (GimpControllerMouse, gimp_controller_mouse,
GIMP_TYPE_CONTROLLER)
#define parent_class gimp_controller_mouse_parent_class
static MouseEvent mouse_events[] =
{
{ 8, NULL, 0,
"8",
N_("Button 8") },
{ 8, "<Shift>", 0,
"8-shift",
N_("Button 8") },
{ 8, "<Primary>", 0,
"8-primary",
N_("Button 8") },
{ 8, "<Alt>", 0,
"8-alt",
N_("Button 8") },
{ 8, "<Shift><Primary>", 0,
"8-shift-primary",
N_("Button 8") },
{ 8, "<Shift><Alt>", 0,
"8-shift-alt",
N_("Button 8") },
{ 8, "<Primary><Alt>", 0,
"8-primary-alt",
N_("Button 8") },
{ 8, "<Shift><Primary><Alt>", 0,
"8-shift-primary-alt",
N_("Button 8") },
{ 9, NULL, 0,
"9",
N_("Button 9") },
{ 9, "<Shift>", 0,
"9-shift",
N_("Button 9") },
{ 9, "<Primary>", 0,
"9-primary",
N_("Button 9") },
{ 9, "<Alt>", 0,
"9-alt",
N_("Button 9") },
{ 9, "<Shift><Primary>", 0,
"9-shift-primary",
N_("Button 9") },
{ 9, "<Shift><Alt>", 0,
"9-shift-alt",
N_("Button 9") },
{ 9, "<Primary><Alt>", 0,
"9-primary-alt",
N_("Button 9") },
{ 9, "<Shift><Primary><Alt>", 0,
"9-shift-primary-alt",
N_("Button 9") },
{ 10, NULL, 0,
"10",
N_("Button 10") },
{ 10, "<Shift>", 0,
"10-shift",
N_("Button 10") },
{ 10, "<Primary>", 0,
"10-primary",
N_("Button 10") },
{ 10, "<Alt>", 0,
"10-alt",
N_("Button 10") },
{ 10, "<Shift><Primary>", 0,
"10-shift-primary",
N_("Button 10") },
{ 10, "<Shift><Alt>", 0,
"10-shift-alt",
N_("Button 10") },
{ 10, "<Primary><Alt>", 0,
"10-primary-alt",
N_("Button 10") },
{ 10, "<Shift><Primary><Alt>", 0,
"10-shift-primary-alt",
N_("Button 10") },
{ 11, NULL, 0,
"11",
N_("Button 11") },
{ 11, "<Shift>", 0,
"11-shift",
N_("Button 11") },
{ 11, "<Primary>", 0,
"11-primary",
N_("Button 11") },
{ 11, "<Alt>", 0,
"11-alt",
N_("Button 11") },
{ 11, "<Shift><Primary>", 0,
"11-shift-primary",
N_("Button 11") },
{ 11, "<Shift><Alt>", 0,
"11-shift-alt",
N_("Button 11") },
{ 11, "<Primary><Alt>", 0,
"11-primary-alt",
N_("Button 11") },
{ 11, "<Shift><Primary><Alt>", 0,
"11-shift-primary-alt",
N_("Button 11") },
{ 12, NULL, 0,
"12",
N_("Button 12") },
{ 12, "<Shift>", 0,
"12-shift",
N_("Button 12") },
{ 12, "<Primary>", 0,
"12-primary",
N_("Button 12") },
{ 12, "<Alt>", 0,
"12-alt",
N_("Button 12") },
{ 12, "<Shift><Primary>", 0,
"12-shift-primary",
N_("Button 12") },
{ 12, "<Shift><Alt>", 0,
"12-shift-alt",
N_("Button 12") },
{ 12, "<Primary><Alt>", 0,
"12-primary-alt",
N_("Button 12") },
{ 12, "<Shift><Primary><Alt>", 0,
"12-shift-primary-alt",
N_("Button 12") },
};
static void
gimp_controller_mouse_class_init (GimpControllerMouseClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpControllerClass *controller_class = GIMP_CONTROLLER_CLASS (klass);
object_class->constructed = gimp_controller_mouse_constructed;
controller_class->name = _("Mouse Buttons");
controller_class->help_id = GIMP_HELP_CONTROLLER_MOUSE;
controller_class->icon_name = GIMP_ICON_CONTROLLER_MOUSE;
controller_class->get_n_events = gimp_controller_mouse_get_n_events;
controller_class->get_event_name = gimp_controller_mouse_get_event_name;
controller_class->get_event_blurb = gimp_controller_mouse_get_event_blurb;
}
static void
gimp_controller_mouse_init (GimpControllerMouse *mouse)
{
static gboolean event_names_initialized = FALSE;
if (! event_names_initialized)
{
GdkKeymap *keymap = gdk_keymap_get_for_display (gdk_display_get_default ());
gint i;
for (i = 0; i < G_N_ELEMENTS (mouse_events); i++)
{
MouseEvent *mevent = &mouse_events[i];
if (mevent->modifier_string)
{
gtk_accelerator_parse (mevent->modifier_string, NULL,
&mevent->modifiers);
gdk_keymap_map_virtual_modifiers (keymap, &mevent->modifiers);
}
if (mevent->modifiers != 0)
{
mevent->blurb =
g_strdup_printf ("%s (%s)", gettext (mevent->blurb),
gimp_get_mod_string (mevent->modifiers));
}
}
event_names_initialized = TRUE;
}
}
static void
gimp_controller_mouse_constructed (GObject *object)
{
G_OBJECT_CLASS (parent_class)->constructed (object);
g_object_set (object,
"name", _("Mouse Button Events"),
"state", _("Ready"),
NULL);
}
static gint
gimp_controller_mouse_get_n_events (GimpController *controller)
{
return G_N_ELEMENTS (mouse_events);
}
static const gchar *
gimp_controller_mouse_get_event_name (GimpController *controller,
gint event_id)
{
if (event_id < 0 || event_id >= G_N_ELEMENTS (mouse_events))
return NULL;
return mouse_events[event_id].name;
}
static const gchar *
gimp_controller_mouse_get_event_blurb (GimpController *controller,
gint event_id)
{
if (event_id < 0 || event_id >= G_N_ELEMENTS (mouse_events))
return NULL;
return mouse_events[event_id].blurb;
}
gboolean
gimp_controller_mouse_button (GimpControllerMouse *mouse,
const GdkEventButton *bevent)
{
gint i;
g_return_val_if_fail (GIMP_IS_CONTROLLER_MOUSE (mouse), FALSE);
g_return_val_if_fail (bevent != NULL, FALSE);
/* start with the last event because the last ones in the
* up,down,left,right groups have the most keyboard modifiers
*/
for (i = G_N_ELEMENTS (mouse_events) - 1; i >= 0; i--)
{
if (mouse_events[i].button == bevent->button &&
(mouse_events[i].modifiers & bevent->state) ==
mouse_events[i].modifiers)
{
GimpControllerEvent controller_event;
GimpControllerEventTrigger *trigger;
trigger = (GimpControllerEventTrigger *) &controller_event;
trigger->type = GIMP_CONTROLLER_EVENT_TRIGGER;
trigger->source = GIMP_CONTROLLER (mouse);
trigger->event_id = i;
return gimp_controller_event (GIMP_CONTROLLER (mouse),
&controller_event);
}
}
return FALSE;
}

57
app/widgets/gimpcontrollermouse.h
View File

@ -1,57 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimpcontrollermouse.h
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
* Copyright (C) 2011 Mikael Magnusson <mikachu@src.gnome.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/>.
*/
#ifndef __GIMP_CONTROLLER_MOUSE_H__
#define __GIMP_CONTROLLER_MOUSE_H__
#define GIMP_ENABLE_CONTROLLER_UNDER_CONSTRUCTION
#include "libgimpwidgets/gimpcontroller.h"
#define GIMP_TYPE_CONTROLLER_MOUSE (gimp_controller_mouse_get_type ())
#define GIMP_CONTROLLER_MOUSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CONTROLLER_MOUSE, GimpControllerMouse))
#define GIMP_CONTROLLER_MOUSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONTROLLER_MOUSE, GimpControllerMouseClass))
#define GIMP_IS_CONTROLLER_MOUSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CONTROLLER_MOUSE))
#define GIMP_IS_CONTROLLER_MOUSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTROLLER_MOUSE))
#define GIMP_CONTROLLER_MOUSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CONTROLLER_MOUSE, GimpControllerMouseClass))
typedef struct _GimpControllerMouseClass GimpControllerMouseClass;
struct _GimpControllerMouse
{
GimpController parent_instance;
};
struct _GimpControllerMouseClass
{
GimpControllerClass parent_class;
};
GType gimp_controller_mouse_get_type (void) G_GNUC_CONST;
gboolean gimp_controller_mouse_button (GimpControllerMouse *mouse,
const GdkEventButton *bevent);
#endif /* __GIMP_CONTROLLER_MOUSE_H__ */

19
app/widgets/gimpcontrollers.c
View File

@ -37,7 +37,6 @@
#include "gimpcontrollerinfo.h" #include "gimpcontrollerinfo.h"
#include "gimpcontrollers.h" #include "gimpcontrollers.h"
#include "gimpcontrollerkeyboard.h" #include "gimpcontrollerkeyboard.h"
#include "gimpcontrollermouse.h"
#include "gimpcontrollerwheel.h" #include "gimpcontrollerwheel.h"
#include "gimpenumaction.h" #include "gimpenumaction.h"
#include "gimpuimanager.h" #include "gimpuimanager.h"
@ -54,7 +53,6 @@ struct _GimpControllerManager
{ {
GimpContainer *controllers; GimpContainer *controllers;
GQuark event_mapped_id; GQuark event_mapped_id;
GimpController *mouse;
GimpController *wheel; GimpController *wheel;
GimpController *keyboard; GimpController *keyboard;
GimpUIManager *ui_manager; GimpUIManager *ui_manager;
@ -110,7 +108,6 @@ gimp_controllers_init (Gimp *gimp)
G_CALLBACK (gimp_controllers_event_mapped), G_CALLBACK (gimp_controllers_event_mapped),
manager); manager);
g_type_class_ref (GIMP_TYPE_CONTROLLER_MOUSE);
g_type_class_ref (GIMP_TYPE_CONTROLLER_WHEEL); g_type_class_ref (GIMP_TYPE_CONTROLLER_WHEEL);
g_type_class_ref (GIMP_TYPE_CONTROLLER_KEYBOARD); g_type_class_ref (GIMP_TYPE_CONTROLLER_KEYBOARD);
} }
@ -256,20 +253,6 @@ gimp_controllers_get_ui_manager (Gimp *gimp)
return manager->ui_manager; return manager->ui_manager;
} }
GimpController *
gimp_controllers_get_mouse (Gimp *gimp)
{
GimpControllerManager *manager;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
manager = gimp_controller_manager_get (gimp);
g_return_val_if_fail (manager != NULL, NULL);
return manager->mouse;
}
GimpController * GimpController *
gimp_controllers_get_wheel (Gimp *gimp) gimp_controllers_get_wheel (Gimp *gimp)
{ {
@ -328,8 +311,6 @@ gimp_controllers_add (GimpContainer *container,
manager->wheel = info->controller; manager->wheel = info->controller;
else if (GIMP_IS_CONTROLLER_KEYBOARD (info->controller)) else if (GIMP_IS_CONTROLLER_KEYBOARD (info->controller))
manager->keyboard = info->controller; manager->keyboard = info->controller;
else if (GIMP_IS_CONTROLLER_MOUSE (info->controller))
manager->mouse = info->controller;
} }
static void static void

1
app/widgets/gimpcontrollers.h
View File

@ -31,7 +31,6 @@ void gimp_controllers_save (Gimp *gimp);
GimpContainer * gimp_controllers_get_list (Gimp *gimp); GimpContainer * gimp_controllers_get_list (Gimp *gimp);
GimpUIManager * gimp_controllers_get_ui_manager (Gimp *gimp); GimpUIManager * gimp_controllers_get_ui_manager (Gimp *gimp);
GimpController * gimp_controllers_get_mouse (Gimp *gimp);
GimpController * gimp_controllers_get_wheel (Gimp *gimp); GimpController * gimp_controllers_get_wheel (Gimp *gimp);
GimpController * gimp_controllers_get_keyboard (Gimp *gimp); GimpController * gimp_controllers_get_keyboard (Gimp *gimp);

1
app/widgets/meson.build
View File

@ -67,7 +67,6 @@ libappwidgets_sources = [
'gimpcontrollerinfo.c', 'gimpcontrollerinfo.c',
'gimpcontrollerkeyboard.c', 'gimpcontrollerkeyboard.c',
'gimpcontrollerlist.c', 'gimpcontrollerlist.c',
'gimpcontrollermouse.c',
'gimpcontrollers.c', 'gimpcontrollers.c',
'gimpcontrollerwheel.c', 'gimpcontrollerwheel.c',
'gimpcriticaldialog.c', 'gimpcriticaldialog.c',

1
po/POTFILES.in
View File

@ -550,7 +550,6 @@ app/widgets/gimpcontrollereditor.c
app/widgets/gimpcontrollerinfo.c app/widgets/gimpcontrollerinfo.c
app/widgets/gimpcontrollerkeyboard.c app/widgets/gimpcontrollerkeyboard.c
app/widgets/gimpcontrollerlist.c app/widgets/gimpcontrollerlist.c
app/widgets/gimpcontrollermouse.c
app/widgets/gimpcontrollerwheel.c app/widgets/gimpcontrollerwheel.c
app/widgets/gimpcriticaldialog.c app/widgets/gimpcriticaldialog.c
app/widgets/gimpdashboard.c app/widgets/gimpdashboard.c