diff options
Diffstat (limited to 'app/tools/gimptool.c')
| -rw-r--r-- | app/tools/gimptool.c | 1512 |
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); + } +} |