summaryrefslogtreecommitdiffstats
path: root/app/tools/gimptool.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/tools/gimptool.c')
-rw-r--r--app/tools/gimptool.c1512
1 files changed, 1512 insertions, 0 deletions
diff --git a/app/tools/gimptool.c b/app/tools/gimptool.c
new file mode 100644
index 0000000..53981c1
--- /dev/null
+++ b/app/tools/gimptool.c
@@ -0,0 +1,1512 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995-2002 Spencer Kimball, Peter Mattis and others
+ *
+ * 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 "libgimpmath/gimpmath.h"
+
+#include "tools-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontainer.h"
+#include "core/gimpimage.h"
+#include "core/gimpprogress.h"
+#include "core/gimptoolinfo.h"
+
+#include "display/gimpdisplay.h"
+#include "display/gimpdisplayshell.h"
+#include "display/gimpdisplayshell-cursor.h"
+#include "display/gimpstatusbar.h"
+
+#include "gimptool.h"
+#include "gimptool-progress.h"
+#include "gimptoolcontrol.h"
+
+#include "gimp-log.h"
+#include "gimp-intl.h"
+
+
+/* #define DEBUG_ACTIVE_STATE 1 */
+
+
+enum
+{
+ PROP_0,
+ PROP_TOOL_INFO
+};
+
+
+static void gimp_tool_constructed (GObject *object);
+static void gimp_tool_dispose (GObject *object);
+static void gimp_tool_finalize (GObject *object);
+static void gimp_tool_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gimp_tool_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+static gboolean gimp_tool_real_has_display (GimpTool *tool,
+ GimpDisplay *display);
+static GimpDisplay * gimp_tool_real_has_image (GimpTool *tool,
+ GimpImage *image);
+static gboolean gimp_tool_real_initialize (GimpTool *tool,
+ GimpDisplay *display,
+ GError **error);
+static void gimp_tool_real_control (GimpTool *tool,
+ GimpToolAction action,
+ GimpDisplay *display);
+static void gimp_tool_real_button_press (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonPressType press_type,
+ GimpDisplay *display);
+static void gimp_tool_real_button_release (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonReleaseType release_type,
+ GimpDisplay *display);
+static void gimp_tool_real_motion (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpDisplay *display);
+static gboolean gimp_tool_real_key_press (GimpTool *tool,
+ GdkEventKey *kevent,
+ GimpDisplay *display);
+static gboolean gimp_tool_real_key_release (GimpTool *tool,
+ GdkEventKey *kevent,
+ GimpDisplay *display);
+static void gimp_tool_real_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display);
+static void gimp_tool_real_active_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display);
+static void gimp_tool_real_oper_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ gboolean proximity,
+ GimpDisplay *display);
+static void gimp_tool_real_cursor_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display);
+static const gchar * gimp_tool_real_can_undo (GimpTool *tool,
+ GimpDisplay *display);
+static const gchar * gimp_tool_real_can_redo (GimpTool *tool,
+ GimpDisplay *display);
+static gboolean gimp_tool_real_undo (GimpTool *tool,
+ GimpDisplay *display);
+static gboolean gimp_tool_real_redo (GimpTool *tool,
+ GimpDisplay *display);
+static GimpUIManager * gimp_tool_real_get_popup (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display,
+ const gchar **ui_path);
+static void gimp_tool_real_options_notify (GimpTool *tool,
+ GimpToolOptions *options,
+ const GParamSpec *pspec);
+
+static void gimp_tool_options_notify (GimpToolOptions *options,
+ const GParamSpec *pspec,
+ GimpTool *tool);
+static void gimp_tool_clear_status (GimpTool *tool);
+static void gimp_tool_release (GimpTool *tool);
+
+
+G_DEFINE_TYPE_WITH_CODE (GimpTool, gimp_tool, GIMP_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROGRESS,
+ gimp_tool_progress_iface_init))
+
+#define parent_class gimp_tool_parent_class
+
+static gint global_tool_ID = 1;
+
+
+static void
+gimp_tool_class_init (GimpToolClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->constructed = gimp_tool_constructed;
+ object_class->dispose = gimp_tool_dispose;
+ object_class->finalize = gimp_tool_finalize;
+ object_class->set_property = gimp_tool_set_property;
+ object_class->get_property = gimp_tool_get_property;
+
+ klass->has_display = gimp_tool_real_has_display;
+ klass->has_image = gimp_tool_real_has_image;
+ klass->initialize = gimp_tool_real_initialize;
+ klass->control = gimp_tool_real_control;
+ klass->button_press = gimp_tool_real_button_press;
+ klass->button_release = gimp_tool_real_button_release;
+ klass->motion = gimp_tool_real_motion;
+ klass->key_press = gimp_tool_real_key_press;
+ klass->key_release = gimp_tool_real_key_release;
+ klass->modifier_key = gimp_tool_real_modifier_key;
+ klass->active_modifier_key = gimp_tool_real_active_modifier_key;
+ klass->oper_update = gimp_tool_real_oper_update;
+ klass->cursor_update = gimp_tool_real_cursor_update;
+ klass->can_undo = gimp_tool_real_can_undo;
+ klass->can_redo = gimp_tool_real_can_redo;
+ klass->undo = gimp_tool_real_undo;
+ klass->redo = gimp_tool_real_redo;
+ klass->get_popup = gimp_tool_real_get_popup;
+ klass->options_notify = gimp_tool_real_options_notify;
+
+ g_object_class_install_property (object_class, PROP_TOOL_INFO,
+ g_param_spec_object ("tool-info",
+ NULL, NULL,
+ GIMP_TYPE_TOOL_INFO,
+ GIMP_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+}
+
+static void
+gimp_tool_init (GimpTool *tool)
+{
+ tool->tool_info = NULL;
+ tool->ID = global_tool_ID++;
+ tool->control = g_object_new (GIMP_TYPE_TOOL_CONTROL, NULL);
+ tool->display = NULL;
+ tool->drawable = NULL;
+ tool->focus_display = NULL;
+ tool->modifier_state = 0;
+ tool->active_modifier_state = 0;
+ tool->button_press_state = 0;
+}
+
+static void
+gimp_tool_constructed (GObject *object)
+{
+ GimpTool *tool = GIMP_TOOL (object);
+
+ G_OBJECT_CLASS (parent_class)->constructed (object);
+
+ gimp_assert (GIMP_IS_TOOL_INFO (tool->tool_info));
+
+ g_signal_connect_object (gimp_tool_get_options (tool), "notify",
+ G_CALLBACK (gimp_tool_options_notify),
+ tool, 0);
+}
+
+static void
+gimp_tool_dispose (GObject *object)
+{
+ GimpTool *tool = GIMP_TOOL (object);
+
+ gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_tool_finalize (GObject *object)
+{
+ GimpTool *tool = GIMP_TOOL (object);
+
+ g_clear_object (&tool->tool_info);
+ g_clear_object (&tool->control);
+ g_clear_pointer (&tool->label, g_free);
+ g_clear_pointer (&tool->undo_desc, g_free);
+ g_clear_pointer (&tool->icon_name, g_free);
+ g_clear_pointer (&tool->help_id, g_free);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_tool_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GimpTool *tool = GIMP_TOOL (object);
+
+ switch (property_id)
+ {
+ case PROP_TOOL_INFO:
+ tool->tool_info = g_value_dup_object (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+gimp_tool_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GimpTool *tool = GIMP_TOOL (object);
+
+ switch (property_id)
+ {
+ case PROP_TOOL_INFO:
+ g_value_set_object (value, tool->tool_info);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+
+/* standard member functions */
+
+static gboolean
+gimp_tool_real_has_display (GimpTool *tool,
+ GimpDisplay *display)
+{
+ return (display == tool->display ||
+ g_list_find (tool->status_displays, display));
+}
+
+static GimpDisplay *
+gimp_tool_real_has_image (GimpTool *tool,
+ GimpImage *image)
+{
+ if (tool->display)
+ {
+ if (image && gimp_display_get_image (tool->display) == image)
+ return tool->display;
+
+ /* NULL image means any display */
+ if (! image)
+ return tool->display;
+ }
+
+ return NULL;
+}
+
+static gboolean
+gimp_tool_real_initialize (GimpTool *tool,
+ GimpDisplay *display,
+ GError **error)
+{
+ return TRUE;
+}
+
+static void
+gimp_tool_real_control (GimpTool *tool,
+ GimpToolAction action,
+ GimpDisplay *display)
+{
+ switch (action)
+ {
+ case GIMP_TOOL_ACTION_PAUSE:
+ case GIMP_TOOL_ACTION_RESUME:
+ break;
+
+ case GIMP_TOOL_ACTION_HALT:
+ tool->display = NULL;
+ tool->drawable = NULL;
+ break;
+
+ case GIMP_TOOL_ACTION_COMMIT:
+ break;
+ }
+}
+
+static void
+gimp_tool_real_button_press (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonPressType press_type,
+ GimpDisplay *display)
+{
+ if (press_type == GIMP_BUTTON_PRESS_NORMAL)
+ {
+ GimpImage *image = gimp_display_get_image (display);
+
+ tool->display = display;
+ tool->drawable = gimp_image_get_active_drawable (image);
+
+ gimp_tool_control_activate (tool->control);
+ }
+}
+
+static void
+gimp_tool_real_button_release (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonReleaseType release_type,
+ GimpDisplay *display)
+{
+ gimp_tool_control_halt (tool->control);
+}
+
+static void
+gimp_tool_real_motion (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+}
+
+static gboolean
+gimp_tool_real_key_press (GimpTool *tool,
+ GdkEventKey *kevent,
+ GimpDisplay *display)
+{
+ return FALSE;
+}
+
+static gboolean
+gimp_tool_real_key_release (GimpTool *tool,
+ GdkEventKey *kevent,
+ GimpDisplay *display)
+{
+ return FALSE;
+}
+
+static void
+gimp_tool_real_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+}
+
+static void
+gimp_tool_real_active_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+}
+
+static void
+gimp_tool_real_oper_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ gboolean proximity,
+ GimpDisplay *display)
+{
+}
+
+static void
+gimp_tool_real_cursor_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ gimp_tool_set_cursor (tool, display,
+ gimp_tool_control_get_cursor (tool->control),
+ gimp_tool_control_get_tool_cursor (tool->control),
+ gimp_tool_control_get_cursor_modifier (tool->control));
+}
+
+static const gchar *
+gimp_tool_real_can_undo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ return NULL;
+}
+
+static const gchar *
+gimp_tool_real_can_redo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ return NULL;
+}
+
+static gboolean
+gimp_tool_real_undo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ return FALSE;
+}
+
+static gboolean
+gimp_tool_real_redo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ return FALSE;
+}
+
+static GimpUIManager *
+gimp_tool_real_get_popup (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display,
+ const gchar **ui_path)
+{
+ *ui_path = NULL;
+
+ return NULL;
+}
+
+static void
+gimp_tool_real_options_notify (GimpTool *tool,
+ GimpToolOptions *options,
+ const GParamSpec *pspec)
+{
+}
+
+
+/* public functions */
+
+GimpToolOptions *
+gimp_tool_get_options (GimpTool *tool)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+ g_return_val_if_fail (GIMP_IS_TOOL_INFO (tool->tool_info), NULL);
+
+ return tool->tool_info->tool_options;
+}
+
+void
+gimp_tool_set_label (GimpTool *tool,
+ const gchar *label)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+
+ g_free (tool->label);
+ tool->label = g_strdup (label);
+}
+
+const gchar *
+gimp_tool_get_label (GimpTool *tool)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+
+ if (tool->label)
+ return tool->label;
+
+ return tool->tool_info->label;
+}
+
+void
+gimp_tool_set_undo_desc (GimpTool *tool,
+ const gchar *undo_desc)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+
+ g_free (tool->undo_desc);
+ tool->undo_desc = g_strdup (undo_desc);
+}
+
+const gchar *
+gimp_tool_get_undo_desc (GimpTool *tool)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+
+ if (tool->undo_desc)
+ return tool->undo_desc;
+
+ return tool->tool_info->label;
+}
+
+void
+gimp_tool_set_icon_name (GimpTool *tool,
+ const gchar *icon_name)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+
+ g_free (tool->icon_name);
+ tool->icon_name = g_strdup (icon_name);
+}
+
+const gchar *
+gimp_tool_get_icon_name (GimpTool *tool)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+
+ if (tool->icon_name)
+ return tool->icon_name;
+
+ return gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool->tool_info));
+}
+
+void
+gimp_tool_set_help_id (GimpTool *tool,
+ const gchar *help_id)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+
+ g_free (tool->help_id);
+ tool->help_id = g_strdup (help_id);
+}
+
+const gchar *
+gimp_tool_get_help_id (GimpTool *tool)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+
+ if (tool->help_id)
+ return tool->help_id;
+
+ return tool->tool_info->help_id;
+}
+
+gboolean
+gimp_tool_has_display (GimpTool *tool,
+ GimpDisplay *display)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), FALSE);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
+
+ return GIMP_TOOL_GET_CLASS (tool)->has_display (tool, display);
+}
+
+GimpDisplay *
+gimp_tool_has_image (GimpTool *tool,
+ GimpImage *image)
+{
+ GimpDisplay *display;
+
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+ g_return_val_if_fail (image == NULL || GIMP_IS_IMAGE (image), NULL);
+
+ display = GIMP_TOOL_GET_CLASS (tool)->has_image (tool, image);
+
+ /* check status displays last because they don't affect the tool
+ * itself (unlike tool->display or draw_tool->display)
+ */
+ if (! display && tool->status_displays)
+ {
+ GList *list;
+
+ for (list = tool->status_displays; list; list = g_list_next (list))
+ {
+ GimpDisplay *status_display = list->data;
+
+ if (gimp_display_get_image (status_display) == image)
+ return status_display;
+ }
+
+ /* NULL image means any display */
+ if (! image)
+ return tool->status_displays->data;
+ }
+
+ return display;
+}
+
+gboolean
+gimp_tool_initialize (GimpTool *tool,
+ GimpDisplay *display)
+{
+ GError *error = NULL;
+
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), FALSE);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
+
+ if (! GIMP_TOOL_GET_CLASS (tool)->initialize (tool, display, &error))
+ {
+ if (error)
+ {
+ gimp_tool_message_literal (tool, display, error->message);
+ g_clear_error (&error);
+ }
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+void
+gimp_tool_control (GimpTool *tool,
+ GimpToolAction action,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+
+ g_object_ref (tool);
+
+ switch (action)
+ {
+ case GIMP_TOOL_ACTION_PAUSE:
+ if (! gimp_tool_control_is_paused (tool->control))
+ GIMP_TOOL_GET_CLASS (tool)->control (tool, action, display);
+
+ gimp_tool_control_pause (tool->control);
+ break;
+
+ case GIMP_TOOL_ACTION_RESUME:
+ if (gimp_tool_control_is_paused (tool->control))
+ {
+ gimp_tool_control_resume (tool->control);
+
+ if (! gimp_tool_control_is_paused (tool->control))
+ GIMP_TOOL_GET_CLASS (tool)->control (tool, action, display);
+ }
+ else
+ {
+ g_warning ("gimp_tool_control: unable to RESUME tool with "
+ "tool->control->paused_count == 0");
+ }
+ break;
+
+ case GIMP_TOOL_ACTION_COMMIT:
+ gimp_tool_release (tool);
+
+ GIMP_TOOL_GET_CLASS (tool)->control (tool, action, display);
+
+ /* always HALT after COMMIT here and not in each tool individually;
+ * some tools interact with their subclasses (e.g. filter tool
+ * and operation tool), and it's essential that COMMIT runs
+ * through the entire class hierarchy before HALT
+ */
+ action = GIMP_TOOL_ACTION_HALT;
+
+ /* pass through */
+ case GIMP_TOOL_ACTION_HALT:
+ gimp_tool_release (tool);
+
+ GIMP_TOOL_GET_CLASS (tool)->control (tool, action, display);
+
+ if (gimp_tool_control_is_active (tool->control))
+ gimp_tool_control_halt (tool->control);
+
+ gimp_tool_clear_status (tool);
+ break;
+ }
+
+ g_object_unref (tool);
+}
+
+void
+gimp_tool_button_press (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonPressType press_type,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (coords != NULL);
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+
+ GIMP_TOOL_GET_CLASS (tool)->button_press (tool, coords, time, state,
+ press_type, display);
+
+ if (press_type == GIMP_BUTTON_PRESS_NORMAL &&
+ gimp_tool_control_is_active (tool->control))
+ {
+ tool->button_press_state = state;
+ tool->active_modifier_state = state;
+
+ tool->last_pointer_coords = *coords;
+ tool->last_pointer_time = time - g_get_monotonic_time () / 1000;
+ tool->last_pointer_state = state;
+
+ if (gimp_tool_control_get_wants_click (tool->control))
+ {
+ tool->in_click_distance = TRUE;
+ tool->got_motion_event = FALSE;
+ tool->button_press_coords = *coords;
+ tool->button_press_time = time;
+ }
+ else
+ {
+ tool->in_click_distance = FALSE;
+ }
+ }
+}
+
+static gboolean
+gimp_tool_check_click_distance (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GimpDisplay *display)
+{
+ GimpDisplayShell *shell;
+ gint double_click_time;
+ gint double_click_distance;
+
+ if (! tool->in_click_distance)
+ return FALSE;
+
+ shell = gimp_display_get_shell (display);
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (shell)),
+ "gtk-double-click-time", &double_click_time,
+ "gtk-double-click-distance", &double_click_distance,
+ NULL);
+
+ if ((time - tool->button_press_time) > double_click_time)
+ {
+ tool->in_click_distance = FALSE;
+ }
+ else
+ {
+ GimpDisplayShell *shell = gimp_display_get_shell (display);
+ gdouble dx;
+ gdouble dy;
+
+ dx = SCALEX (shell, tool->button_press_coords.x - coords->x);
+ dy = SCALEY (shell, tool->button_press_coords.y - coords->y);
+
+ if ((SQR (dx) + SQR (dy)) > SQR (double_click_distance))
+ {
+ tool->in_click_distance = FALSE;
+ }
+ }
+
+ return tool->in_click_distance;
+}
+
+void
+gimp_tool_button_release (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ GimpButtonReleaseType release_type = GIMP_BUTTON_RELEASE_NORMAL;
+ GimpCoords my_coords;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (coords != NULL);
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (gimp_tool_control_is_active (tool->control) == TRUE);
+
+ g_object_ref (tool);
+
+ tool->last_pointer_state = 0;
+
+ my_coords = *coords;
+
+ if (state & GDK_BUTTON3_MASK)
+ {
+ release_type = GIMP_BUTTON_RELEASE_CANCEL;
+ }
+ else if (gimp_tool_control_get_wants_click (tool->control))
+ {
+ if (gimp_tool_check_click_distance (tool, coords, time, display))
+ {
+ release_type = GIMP_BUTTON_RELEASE_CLICK;
+ my_coords = tool->button_press_coords;
+
+ if (tool->got_motion_event)
+ {
+ /* if there has been a motion() since button_press(),
+ * synthesize a motion() back to the recorded press
+ * coordinates
+ */
+ GIMP_TOOL_GET_CLASS (tool)->motion (tool, &my_coords, time,
+ state & GDK_BUTTON1_MASK,
+ display);
+ }
+ }
+ else if (! tool->got_motion_event)
+ {
+ release_type = GIMP_BUTTON_RELEASE_NO_MOTION;
+ }
+ }
+
+ GIMP_TOOL_GET_CLASS (tool)->button_release (tool, &my_coords, time, state,
+ release_type, display);
+
+ g_warn_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
+
+ if (tool->active_modifier_state != 0 &&
+ gimp_tool_control_get_active_modifiers (tool->control) !=
+ GIMP_TOOL_ACTIVE_MODIFIERS_SAME)
+ {
+ gimp_tool_control_activate (tool->control);
+
+ gimp_tool_set_active_modifier_state (tool, 0, display);
+
+ gimp_tool_control_halt (tool->control);
+ }
+
+ tool->button_press_state = 0;
+ tool->active_modifier_state = 0;
+
+ g_object_unref (tool);
+}
+
+void
+gimp_tool_motion (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (coords != NULL);
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (gimp_tool_control_is_active (tool->control) == TRUE);
+
+ tool->got_motion_event = TRUE;
+
+ tool->last_pointer_coords = *coords;
+ tool->last_pointer_time = time - g_get_monotonic_time () / 1000;
+ tool->last_pointer_state = state;
+
+ GIMP_TOOL_GET_CLASS (tool)->motion (tool, coords, time, state, display);
+}
+
+void
+gimp_tool_set_focus_display (GimpTool *tool,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (display == NULL || GIMP_IS_DISPLAY (display));
+ g_return_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
+
+ GIMP_LOG (TOOL_FOCUS, "tool: %p focus_display: %p tool->focus_display: %p",
+ tool, display, tool->focus_display);
+
+ if (display != tool->focus_display)
+ {
+ if (tool->focus_display)
+ {
+ if (tool->active_modifier_state != 0)
+ {
+ gimp_tool_control_activate (tool->control);
+
+ gimp_tool_set_active_modifier_state (tool, 0, tool->focus_display);
+
+ gimp_tool_control_halt (tool->control);
+ }
+
+ if (tool->modifier_state != 0)
+ gimp_tool_set_modifier_state (tool, 0, tool->focus_display);
+ }
+
+ tool->focus_display = display;
+ }
+}
+
+gboolean
+gimp_tool_key_press (GimpTool *tool,
+ GdkEventKey *kevent,
+ GimpDisplay *display)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), FALSE);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
+ g_return_val_if_fail (display == tool->focus_display, FALSE);
+ g_return_val_if_fail (gimp_tool_control_is_active (tool->control) == FALSE,
+ FALSE);
+
+ return GIMP_TOOL_GET_CLASS (tool)->key_press (tool, kevent, display);
+}
+
+gboolean
+gimp_tool_key_release (GimpTool *tool,
+ GdkEventKey *kevent,
+ GimpDisplay *display)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), FALSE);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
+ g_return_val_if_fail (display == tool->focus_display, FALSE);
+ g_return_val_if_fail (gimp_tool_control_is_active (tool->control) == FALSE,
+ FALSE);
+
+ return GIMP_TOOL_GET_CLASS (tool)->key_release (tool, kevent, display);
+}
+
+static void
+gimp_tool_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (display == tool->focus_display);
+
+ GIMP_TOOL_GET_CLASS (tool)->modifier_key (tool, key, press, state, display);
+}
+
+static void
+gimp_tool_active_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (display == tool->focus_display);
+
+ GIMP_TOOL_GET_CLASS (tool)->active_modifier_key (tool, key, press, state,
+ display);
+}
+
+static gboolean
+state_changed (GdkModifierType old_state,
+ GdkModifierType new_state,
+ GdkModifierType modifier,
+ gboolean *press)
+{
+ if ((old_state & modifier) != (new_state & modifier))
+ {
+ *press = (new_state & modifier) ? TRUE : FALSE;
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+void
+gimp_tool_set_modifier_state (GimpTool *tool,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ gboolean press;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
+
+ GIMP_LOG (TOOL_FOCUS, "tool: %p display: %p tool->focus_display: %p",
+ tool, display, tool->focus_display);
+
+ g_return_if_fail (display == tool->focus_display);
+
+ if (state_changed (tool->modifier_state, state, GDK_SHIFT_MASK, &press))
+ {
+ gimp_tool_modifier_key (tool, GDK_SHIFT_MASK,
+ press, state,
+ display);
+ }
+
+ if (state_changed (tool->modifier_state, state, GDK_CONTROL_MASK, &press))
+ {
+ gimp_tool_modifier_key (tool, GDK_CONTROL_MASK,
+ press, state,
+ display);
+ }
+
+ if (state_changed (tool->modifier_state, state, GDK_MOD1_MASK, &press))
+ {
+ gimp_tool_modifier_key (tool, GDK_MOD1_MASK,
+ press, state,
+ display);
+ }
+
+ if (state_changed (tool->modifier_state, state, GDK_MOD2_MASK, &press))
+ {
+ gimp_tool_modifier_key (tool, GDK_MOD2_MASK,
+ press, state,
+ display);
+ }
+
+ tool->modifier_state = state;
+}
+
+void
+gimp_tool_set_active_modifier_state (GimpTool *tool,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ GimpToolActiveModifiers active_modifiers;
+ gboolean press;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (gimp_tool_control_is_active (tool->control) == TRUE);
+
+ GIMP_LOG (TOOL_FOCUS, "tool: %p display: %p tool->focus_display: %p",
+ tool, display, tool->focus_display);
+
+ g_return_if_fail (display == tool->focus_display);
+
+ active_modifiers = gimp_tool_control_get_active_modifiers (tool->control);
+
+ if (state_changed (tool->active_modifier_state, state, GDK_SHIFT_MASK,
+ &press))
+ {
+#ifdef DEBUG_ACTIVE_STATE
+ g_printerr ("%s: SHIFT %s\n", G_STRFUNC,
+ press ? "pressed" : "released");
+#endif
+
+ switch (active_modifiers)
+ {
+ case GIMP_TOOL_ACTIVE_MODIFIERS_OFF:
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SAME:
+ gimp_tool_modifier_key (tool, GDK_SHIFT_MASK,
+ press, state,
+ display);
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE:
+ if (! press && (tool->button_press_state & GDK_SHIFT_MASK))
+ {
+ tool->button_press_state &= ~GDK_SHIFT_MASK;
+ }
+ else
+ {
+ gimp_tool_active_modifier_key (tool, GDK_SHIFT_MASK,
+ press, state,
+ display);
+ }
+ break;
+ }
+ }
+
+ if (state_changed (tool->active_modifier_state, state, GDK_CONTROL_MASK,
+ &press))
+ {
+#ifdef DEBUG_ACTIVE_STATE
+ g_printerr ("%s: CONTROL %s\n", G_STRFUNC,
+ press ? "pressed" : "released");
+#endif
+
+ switch (active_modifiers)
+ {
+ case GIMP_TOOL_ACTIVE_MODIFIERS_OFF:
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SAME:
+ gimp_tool_modifier_key (tool, GDK_CONTROL_MASK,
+ press, state,
+ display);
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE:
+ if (! press && (tool->button_press_state & GDK_CONTROL_MASK))
+ {
+ tool->button_press_state &= ~GDK_CONTROL_MASK;
+ }
+ else
+ {
+ gimp_tool_active_modifier_key (tool, GDK_CONTROL_MASK,
+ press, state,
+ display);
+ }
+ break;
+ }
+ }
+
+ if (state_changed (tool->active_modifier_state, state, GDK_MOD1_MASK,
+ &press))
+ {
+#ifdef DEBUG_ACTIVE_STATE
+ g_printerr ("%s: ALT %s\n", G_STRFUNC,
+ press ? "pressed" : "released");
+#endif
+
+ switch (active_modifiers)
+ {
+ case GIMP_TOOL_ACTIVE_MODIFIERS_OFF:
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SAME:
+ gimp_tool_modifier_key (tool, GDK_MOD1_MASK,
+ press, state,
+ display);
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE:
+ if (! press && (tool->button_press_state & GDK_MOD1_MASK))
+ {
+ tool->button_press_state &= ~GDK_MOD1_MASK;
+ }
+ else
+ {
+ gimp_tool_active_modifier_key (tool, GDK_MOD1_MASK,
+ press, state,
+ display);
+ }
+ break;
+ }
+ }
+
+ if (state_changed (tool->active_modifier_state, state, GDK_MOD2_MASK,
+ &press))
+ {
+#ifdef DEBUG_ACTIVE_STATE
+ g_printerr ("%s: MOD2 %s\n", G_STRFUNC,
+ press ? "pressed" : "released");
+#endif
+
+ switch (active_modifiers)
+ {
+ case GIMP_TOOL_ACTIVE_MODIFIERS_OFF:
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SAME:
+ gimp_tool_modifier_key (tool, GDK_MOD2_MASK,
+ press, state,
+ display);
+ break;
+
+ case GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE:
+ if (! press && (tool->button_press_state & GDK_MOD2_MASK))
+ {
+ tool->button_press_state &= ~GDK_MOD2_MASK;
+ }
+ else
+ {
+ gimp_tool_active_modifier_key (tool, GDK_MOD2_MASK,
+ press, state,
+ display);
+ }
+ break;
+ }
+ }
+
+ tool->active_modifier_state = state;
+
+ if (active_modifiers == GIMP_TOOL_ACTIVE_MODIFIERS_SAME)
+ tool->modifier_state = state;
+}
+
+void
+gimp_tool_oper_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ gboolean proximity,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (coords != NULL);
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
+
+ GIMP_TOOL_GET_CLASS (tool)->oper_update (tool, coords, state, proximity,
+ display);
+
+ if (G_UNLIKELY (gimp_image_is_empty (gimp_display_get_image (display)) &&
+ ! gimp_tool_control_get_handle_empty_image (tool->control)))
+ {
+ gimp_tool_replace_status (tool, display,
+ "%s",
+ _("Can't work on an empty image, "
+ "add a layer first"));
+ }
+}
+
+void
+gimp_tool_cursor_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (coords != NULL);
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
+
+ GIMP_TOOL_GET_CLASS (tool)->cursor_update (tool, coords, state, display);
+}
+
+const gchar *
+gimp_tool_can_undo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), NULL);
+
+ if (display == tool->display)
+ return GIMP_TOOL_GET_CLASS (tool)->can_undo (tool, display);
+
+ return NULL;
+}
+
+const gchar *
+gimp_tool_can_redo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), NULL);
+
+ if (display == tool->display)
+ return GIMP_TOOL_GET_CLASS (tool)->can_redo (tool, display);
+
+ return NULL;
+}
+
+gboolean
+gimp_tool_undo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), FALSE);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
+
+ if (gimp_tool_can_undo (tool, display))
+ return GIMP_TOOL_GET_CLASS (tool)->undo (tool, display);
+
+ return FALSE;
+}
+
+gboolean
+gimp_tool_redo (GimpTool *tool,
+ GimpDisplay *display)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), FALSE);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
+
+ if (gimp_tool_can_redo (tool, display))
+ return GIMP_TOOL_GET_CLASS (tool)->redo (tool, display);
+
+ return FALSE;
+}
+
+GimpUIManager *
+gimp_tool_get_popup (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display,
+ const gchar **ui_path)
+{
+ g_return_val_if_fail (GIMP_IS_TOOL (tool), NULL);
+ g_return_val_if_fail (coords != NULL, NULL);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), NULL);
+ g_return_val_if_fail (ui_path != NULL, NULL);
+
+ return GIMP_TOOL_GET_CLASS (tool)->get_popup (tool, coords, state, display,
+ ui_path);
+}
+
+void
+gimp_tool_push_status (GimpTool *tool,
+ GimpDisplay *display,
+ const gchar *format,
+ ...)
+{
+ GimpDisplayShell *shell;
+ const gchar *icon_name;
+ va_list args;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (format != NULL);
+
+ shell = gimp_display_get_shell (display);
+
+ icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool->tool_info));
+
+ va_start (args, format);
+
+ gimp_statusbar_push_valist (gimp_display_shell_get_statusbar (shell),
+ G_OBJECT_TYPE_NAME (tool), icon_name,
+ format, args);
+
+ va_end (args);
+
+ tool->status_displays = g_list_remove (tool->status_displays, display);
+ tool->status_displays = g_list_prepend (tool->status_displays, display);
+}
+
+void
+gimp_tool_push_status_coords (GimpTool *tool,
+ GimpDisplay *display,
+ GimpCursorPrecision precision,
+ const gchar *title,
+ gdouble x,
+ const gchar *separator,
+ gdouble y,
+ const gchar *help)
+{
+ GimpDisplayShell *shell;
+ const gchar *icon_name;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+
+ shell = gimp_display_get_shell (display);
+
+ icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool->tool_info));
+
+ gimp_statusbar_push_coords (gimp_display_shell_get_statusbar (shell),
+ G_OBJECT_TYPE_NAME (tool), icon_name,
+ precision, title, x, separator, y,
+ help);
+
+ tool->status_displays = g_list_remove (tool->status_displays, display);
+ tool->status_displays = g_list_prepend (tool->status_displays, display);
+}
+
+void
+gimp_tool_push_status_length (GimpTool *tool,
+ GimpDisplay *display,
+ const gchar *title,
+ GimpOrientationType axis,
+ gdouble value,
+ const gchar *help)
+{
+ GimpDisplayShell *shell;
+ const gchar *icon_name;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+
+ shell = gimp_display_get_shell (display);
+
+ icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool->tool_info));
+
+ gimp_statusbar_push_length (gimp_display_shell_get_statusbar (shell),
+ G_OBJECT_TYPE_NAME (tool), icon_name,
+ title, axis, value, help);
+
+ tool->status_displays = g_list_remove (tool->status_displays, display);
+ tool->status_displays = g_list_prepend (tool->status_displays, display);
+}
+
+void
+gimp_tool_replace_status (GimpTool *tool,
+ GimpDisplay *display,
+ const gchar *format,
+ ...)
+{
+ GimpDisplayShell *shell;
+ const gchar *icon_name;
+ va_list args;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (format != NULL);
+
+ shell = gimp_display_get_shell (display);
+
+ icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool->tool_info));
+
+ va_start (args, format);
+
+ gimp_statusbar_replace_valist (gimp_display_shell_get_statusbar (shell),
+ G_OBJECT_TYPE_NAME (tool), icon_name,
+ format, args);
+
+ va_end (args);
+
+ tool->status_displays = g_list_remove (tool->status_displays, display);
+ tool->status_displays = g_list_prepend (tool->status_displays, display);
+}
+
+void
+gimp_tool_pop_status (GimpTool *tool,
+ GimpDisplay *display)
+{
+ GimpDisplayShell *shell;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+
+ shell = gimp_display_get_shell (display);
+
+ gimp_statusbar_pop (gimp_display_shell_get_statusbar (shell),
+ G_OBJECT_TYPE_NAME (tool));
+
+ tool->status_displays = g_list_remove (tool->status_displays, display);
+}
+
+void
+gimp_tool_message (GimpTool *tool,
+ GimpDisplay *display,
+ const gchar *format,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (format != NULL);
+
+ va_start (args, format);
+
+ gimp_message_valist (display->gimp, G_OBJECT (display),
+ GIMP_MESSAGE_WARNING, format, args);
+
+ va_end (args);
+}
+
+void
+gimp_tool_message_literal (GimpTool *tool,
+ GimpDisplay *display,
+ const gchar *message)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+ g_return_if_fail (message != NULL);
+
+ gimp_message_literal (display->gimp, G_OBJECT (display),
+ GIMP_MESSAGE_WARNING, message);
+}
+
+void
+gimp_tool_set_cursor (GimpTool *tool,
+ GimpDisplay *display,
+ GimpCursorType cursor,
+ GimpToolCursorType tool_cursor,
+ GimpCursorModifier modifier)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+ g_return_if_fail (GIMP_IS_DISPLAY (display));
+
+ gimp_display_shell_set_cursor (gimp_display_get_shell (display),
+ cursor, tool_cursor, modifier);
+}
+
+
+/* private functions */
+
+static void
+gimp_tool_options_notify (GimpToolOptions *options,
+ const GParamSpec *pspec,
+ GimpTool *tool)
+{
+ GIMP_TOOL_GET_CLASS (tool)->options_notify (tool, options, pspec);
+}
+
+static void
+gimp_tool_clear_status (GimpTool *tool)
+{
+ g_return_if_fail (GIMP_IS_TOOL (tool));
+
+ while (tool->status_displays)
+ gimp_tool_pop_status (tool, tool->status_displays->data);
+}
+
+static void
+gimp_tool_release (GimpTool *tool)
+{
+ if (tool->last_pointer_state &&
+ gimp_tool_control_is_active (tool->control))
+ {
+ gimp_tool_button_release (
+ tool,
+ &tool->last_pointer_coords,
+ tool->last_pointer_time + g_get_monotonic_time () / 1000,
+ tool->last_pointer_state,
+ tool->display);
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-09 04:15:44 +0000