/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* Copyright (C) 1995-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 .
*/
#include "config.h"
#include
#include
#include "libpikabase/pikabase.h"
#include "libpikamath/pikamath.h"
#include "tools-types.h"
#include "core/pika.h"
#include "core/pikacontainer.h"
#include "core/pikaimage.h"
#include "core/pikaprogress.h"
#include "core/pikatoolinfo.h"
#include "display/pikadisplay.h"
#include "display/pikadisplayshell.h"
#include "display/pikadisplayshell-cursor.h"
#include "display/pikastatusbar.h"
#include "pikatool.h"
#include "pikatool-progress.h"
#include "pikatoolcontrol.h"
#include "pika-log.h"
#include "pika-intl.h"
/* #define DEBUG_ACTIVE_STATE 1 */
enum
{
PROP_0,
PROP_TOOL_INFO
};
static void pika_tool_constructed (GObject *object);
static void pika_tool_dispose (GObject *object);
static void pika_tool_finalize (GObject *object);
static void pika_tool_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void pika_tool_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gboolean pika_tool_real_has_display (PikaTool *tool,
PikaDisplay *display);
static PikaDisplay * pika_tool_real_has_image (PikaTool *tool,
PikaImage *image);
static gboolean pika_tool_real_initialize (PikaTool *tool,
PikaDisplay *display,
GError **error);
static void pika_tool_real_control (PikaTool *tool,
PikaToolAction action,
PikaDisplay *display);
static void pika_tool_real_button_press (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonPressType press_type,
PikaDisplay *display);
static void pika_tool_real_button_release (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonReleaseType release_type,
PikaDisplay *display);
static void pika_tool_real_motion (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display);
static gboolean pika_tool_real_key_press (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display);
static gboolean pika_tool_real_key_release (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display);
static void pika_tool_real_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display);
static void pika_tool_real_active_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display);
static void pika_tool_real_oper_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
gboolean proximity,
PikaDisplay *display);
static void pika_tool_real_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display);
static const gchar * pika_tool_real_can_undo (PikaTool *tool,
PikaDisplay *display);
static const gchar * pika_tool_real_can_redo (PikaTool *tool,
PikaDisplay *display);
static gboolean pika_tool_real_undo (PikaTool *tool,
PikaDisplay *display);
static gboolean pika_tool_real_redo (PikaTool *tool,
PikaDisplay *display);
static PikaUIManager * pika_tool_real_get_popup (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display,
const gchar **ui_path);
static void pika_tool_real_options_notify (PikaTool *tool,
PikaToolOptions *options,
const GParamSpec *pspec);
static void pika_tool_options_notify (PikaToolOptions *options,
const GParamSpec *pspec,
PikaTool *tool);
static void pika_tool_clear_status (PikaTool *tool);
static void pika_tool_release (PikaTool *tool);
G_DEFINE_TYPE_WITH_CODE (PikaTool, pika_tool, PIKA_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (PIKA_TYPE_PROGRESS,
pika_tool_progress_iface_init))
#define parent_class pika_tool_parent_class
static gint global_tool_ID = 1;
static void
pika_tool_class_init (PikaToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructed = pika_tool_constructed;
object_class->dispose = pika_tool_dispose;
object_class->finalize = pika_tool_finalize;
object_class->set_property = pika_tool_set_property;
object_class->get_property = pika_tool_get_property;
klass->has_display = pika_tool_real_has_display;
klass->has_image = pika_tool_real_has_image;
klass->initialize = pika_tool_real_initialize;
klass->control = pika_tool_real_control;
klass->button_press = pika_tool_real_button_press;
klass->button_release = pika_tool_real_button_release;
klass->motion = pika_tool_real_motion;
klass->key_press = pika_tool_real_key_press;
klass->key_release = pika_tool_real_key_release;
klass->modifier_key = pika_tool_real_modifier_key;
klass->active_modifier_key = pika_tool_real_active_modifier_key;
klass->oper_update = pika_tool_real_oper_update;
klass->cursor_update = pika_tool_real_cursor_update;
klass->can_undo = pika_tool_real_can_undo;
klass->can_redo = pika_tool_real_can_redo;
klass->undo = pika_tool_real_undo;
klass->redo = pika_tool_real_redo;
klass->get_popup = pika_tool_real_get_popup;
klass->options_notify = pika_tool_real_options_notify;
g_object_class_install_property (object_class, PROP_TOOL_INFO,
g_param_spec_object ("tool-info",
NULL, NULL,
PIKA_TYPE_TOOL_INFO,
PIKA_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
}
static void
pika_tool_init (PikaTool *tool)
{
tool->tool_info = NULL;
tool->ID = global_tool_ID++;
tool->control = g_object_new (PIKA_TYPE_TOOL_CONTROL, NULL);
tool->display = NULL;
tool->drawables = NULL;
tool->focus_display = NULL;
tool->modifier_state = 0;
tool->active_modifier_state = 0;
tool->button_press_state = 0;
}
static void
pika_tool_constructed (GObject *object)
{
PikaTool *tool = PIKA_TOOL (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
pika_assert (PIKA_IS_TOOL_INFO (tool->tool_info));
g_signal_connect_object (pika_tool_get_options (tool), "notify",
G_CALLBACK (pika_tool_options_notify),
tool, 0);
}
static void
pika_tool_dispose (GObject *object)
{
PikaTool *tool = PIKA_TOOL (object);
pika_tool_control (tool, PIKA_TOOL_ACTION_HALT, tool->display);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
pika_tool_finalize (GObject *object)
{
PikaTool *tool = PIKA_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
pika_tool_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaTool *tool = PIKA_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
pika_tool_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PikaTool *tool = PIKA_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
pika_tool_real_has_display (PikaTool *tool,
PikaDisplay *display)
{
return (display == tool->display ||
g_list_find (tool->status_displays, display));
}
static PikaDisplay *
pika_tool_real_has_image (PikaTool *tool,
PikaImage *image)
{
if (tool->display)
{
if (image && pika_display_get_image (tool->display) == image)
return tool->display;
/* NULL image means any display */
if (! image)
return tool->display;
}
return NULL;
}
static gboolean
pika_tool_real_initialize (PikaTool *tool,
PikaDisplay *display,
GError **error)
{
return TRUE;
}
static void
pika_tool_real_control (PikaTool *tool,
PikaToolAction action,
PikaDisplay *display)
{
switch (action)
{
case PIKA_TOOL_ACTION_PAUSE:
case PIKA_TOOL_ACTION_RESUME:
break;
case PIKA_TOOL_ACTION_HALT:
tool->display = NULL;
g_list_free (tool->drawables);
tool->drawables = NULL;
break;
case PIKA_TOOL_ACTION_COMMIT:
break;
}
}
static void
pika_tool_real_button_press (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonPressType press_type,
PikaDisplay *display)
{
if (press_type == PIKA_BUTTON_PRESS_NORMAL)
{
PikaImage *image = pika_display_get_image (display);
tool->display = display;
g_list_free (tool->drawables);
tool->drawables = pika_image_get_selected_drawables (image);
pika_tool_control_activate (tool->control);
}
}
static void
pika_tool_real_button_release (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonReleaseType release_type,
PikaDisplay *display)
{
pika_tool_control_halt (tool->control);
}
static void
pika_tool_real_motion (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display)
{
}
static gboolean
pika_tool_real_key_press (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display)
{
return FALSE;
}
static gboolean
pika_tool_real_key_release (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display)
{
return FALSE;
}
static void
pika_tool_real_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display)
{
}
static void
pika_tool_real_active_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display)
{
}
static void
pika_tool_real_oper_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
gboolean proximity,
PikaDisplay *display)
{
}
static void
pika_tool_real_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display)
{
pika_tool_set_cursor (tool, display,
pika_tool_control_get_cursor (tool->control),
pika_tool_control_get_tool_cursor (tool->control),
pika_tool_control_get_cursor_modifier (tool->control));
}
static const gchar *
pika_tool_real_can_undo (PikaTool *tool,
PikaDisplay *display)
{
return NULL;
}
static const gchar *
pika_tool_real_can_redo (PikaTool *tool,
PikaDisplay *display)
{
return NULL;
}
static gboolean
pika_tool_real_undo (PikaTool *tool,
PikaDisplay *display)
{
return FALSE;
}
static gboolean
pika_tool_real_redo (PikaTool *tool,
PikaDisplay *display)
{
return FALSE;
}
static PikaUIManager *
pika_tool_real_get_popup (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display,
const gchar **ui_path)
{
*ui_path = NULL;
return NULL;
}
static void
pika_tool_real_options_notify (PikaTool *tool,
PikaToolOptions *options,
const GParamSpec *pspec)
{
}
/* public functions */
PikaToolOptions *
pika_tool_get_options (PikaTool *tool)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
g_return_val_if_fail (PIKA_IS_TOOL_INFO (tool->tool_info), NULL);
return tool->tool_info->tool_options;
}
void
pika_tool_set_label (PikaTool *tool,
const gchar *label)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_free (tool->label);
tool->label = g_strdup (label);
}
const gchar *
pika_tool_get_label (PikaTool *tool)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
if (tool->label)
return tool->label;
return tool->tool_info->label;
}
void
pika_tool_set_undo_desc (PikaTool *tool,
const gchar *undo_desc)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_free (tool->undo_desc);
tool->undo_desc = g_strdup (undo_desc);
}
const gchar *
pika_tool_get_undo_desc (PikaTool *tool)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
if (tool->undo_desc)
return tool->undo_desc;
return tool->tool_info->label;
}
void
pika_tool_set_icon_name (PikaTool *tool,
const gchar *icon_name)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_free (tool->icon_name);
tool->icon_name = g_strdup (icon_name);
}
const gchar *
pika_tool_get_icon_name (PikaTool *tool)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
if (tool->icon_name)
return tool->icon_name;
return pika_viewable_get_icon_name (PIKA_VIEWABLE (tool->tool_info));
}
void
pika_tool_set_help_id (PikaTool *tool,
const gchar *help_id)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_free (tool->help_id);
tool->help_id = g_strdup (help_id);
}
const gchar *
pika_tool_get_help_id (PikaTool *tool)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
if (tool->help_id)
return tool->help_id;
return tool->tool_info->help_id;
}
gboolean
pika_tool_has_display (PikaTool *tool,
PikaDisplay *display)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), FALSE);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), FALSE);
return PIKA_TOOL_GET_CLASS (tool)->has_display (tool, display);
}
PikaDisplay *
pika_tool_has_image (PikaTool *tool,
PikaImage *image)
{
PikaDisplay *display;
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
g_return_val_if_fail (image == NULL || PIKA_IS_IMAGE (image), NULL);
display = PIKA_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))
{
PikaDisplay *status_display = list->data;
if (pika_display_get_image (status_display) == image)
return status_display;
}
/* NULL image means any display */
if (! image)
return tool->status_displays->data;
}
return display;
}
gboolean
pika_tool_initialize (PikaTool *tool,
PikaDisplay *display)
{
GError *error = NULL;
g_return_val_if_fail (PIKA_IS_TOOL (tool), FALSE);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), FALSE);
if (! PIKA_TOOL_GET_CLASS (tool)->initialize (tool, display, &error))
{
if (error)
{
pika_tool_message_literal (tool, display, error->message);
g_clear_error (&error);
}
return FALSE;
}
return TRUE;
}
void
pika_tool_control (PikaTool *tool,
PikaToolAction action,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_object_ref (tool);
switch (action)
{
case PIKA_TOOL_ACTION_PAUSE:
if (! pika_tool_control_is_paused (tool->control))
PIKA_TOOL_GET_CLASS (tool)->control (tool, action, display);
pika_tool_control_pause (tool->control);
break;
case PIKA_TOOL_ACTION_RESUME:
if (pika_tool_control_is_paused (tool->control))
{
pika_tool_control_resume (tool->control);
if (! pika_tool_control_is_paused (tool->control))
PIKA_TOOL_GET_CLASS (tool)->control (tool, action, display);
}
else
{
g_warning ("pika_tool_control: unable to RESUME tool with "
"tool->control->paused_count == 0");
}
break;
case PIKA_TOOL_ACTION_COMMIT:
pika_tool_release (tool);
PIKA_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 = PIKA_TOOL_ACTION_HALT;
/* pass through */
case PIKA_TOOL_ACTION_HALT:
pika_tool_release (tool);
PIKA_TOOL_GET_CLASS (tool)->control (tool, action, display);
if (pika_tool_control_is_active (tool->control))
pika_tool_control_halt (tool->control);
pika_tool_clear_status (tool);
break;
}
g_object_unref (tool);
}
void
pika_tool_button_press (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonPressType press_type,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (coords != NULL);
g_return_if_fail (PIKA_IS_DISPLAY (display));
PIKA_TOOL_GET_CLASS (tool)->button_press (tool, coords, time, state,
press_type, display);
if (press_type == PIKA_BUTTON_PRESS_NORMAL &&
pika_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 (pika_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
pika_tool_check_click_distance (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
PikaDisplay *display)
{
PikaDisplayShell *shell;
gint double_click_time;
gint double_click_distance;
if (! tool->in_click_distance)
return FALSE;
shell = pika_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
{
PikaDisplayShell *shell = pika_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
pika_tool_button_release (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display)
{
PikaButtonReleaseType release_type = PIKA_BUTTON_RELEASE_NORMAL;
PikaCoords my_coords;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (coords != NULL);
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (pika_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 = PIKA_BUTTON_RELEASE_CANCEL;
}
else if (pika_tool_control_get_wants_click (tool->control))
{
if (pika_tool_check_click_distance (tool, coords, time, display))
{
release_type = PIKA_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
*/
PIKA_TOOL_GET_CLASS (tool)->motion (tool, &my_coords, time,
state & GDK_BUTTON1_MASK,
display);
}
}
else if (! tool->got_motion_event)
{
release_type = PIKA_BUTTON_RELEASE_NO_MOTION;
}
}
PIKA_TOOL_GET_CLASS (tool)->button_release (tool, &my_coords, time, state,
release_type, display);
g_warn_if_fail (pika_tool_control_is_active (tool->control) == FALSE);
if (tool->active_modifier_state != 0 &&
pika_tool_control_get_active_modifiers (tool->control) !=
PIKA_TOOL_ACTIVE_MODIFIERS_SAME)
{
pika_tool_control_activate (tool->control);
pika_tool_set_active_modifier_state (tool, 0, display);
pika_tool_control_halt (tool->control);
}
tool->button_press_state = 0;
tool->active_modifier_state = 0;
g_object_unref (tool);
}
void
pika_tool_motion (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (coords != NULL);
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (pika_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;
PIKA_TOOL_GET_CLASS (tool)->motion (tool, coords, time, state, display);
}
void
pika_tool_set_focus_display (PikaTool *tool,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (display == NULL || PIKA_IS_DISPLAY (display));
g_return_if_fail (pika_tool_control_is_active (tool->control) == FALSE);
PIKA_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)
{
pika_tool_control_activate (tool->control);
pika_tool_set_active_modifier_state (tool, 0, tool->focus_display);
pika_tool_control_halt (tool->control);
}
if (tool->modifier_state != 0)
pika_tool_set_modifier_state (tool, 0, tool->focus_display);
}
tool->focus_display = display;
}
}
gboolean
pika_tool_key_press (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), FALSE);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (display == tool->focus_display, FALSE);
g_return_val_if_fail (pika_tool_control_is_active (tool->control) == FALSE,
FALSE);
return PIKA_TOOL_GET_CLASS (tool)->key_press (tool, kevent, display);
}
gboolean
pika_tool_key_release (PikaTool *tool,
GdkEventKey *kevent,
PikaDisplay *display)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), FALSE);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (display == tool->focus_display, FALSE);
g_return_val_if_fail (pika_tool_control_is_active (tool->control) == FALSE,
FALSE);
return PIKA_TOOL_GET_CLASS (tool)->key_release (tool, kevent, display);
}
static void
pika_tool_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (display == tool->focus_display);
PIKA_TOOL_GET_CLASS (tool)->modifier_key (tool, key, press, state, display);
}
static void
pika_tool_active_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (display == tool->focus_display);
PIKA_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
pika_tool_set_modifier_state (PikaTool *tool,
GdkModifierType state,
PikaDisplay *display)
{
gboolean press;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (pika_tool_control_is_active (tool->control) == FALSE);
PIKA_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))
{
pika_tool_modifier_key (tool, GDK_SHIFT_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_CONTROL_MASK, &press))
{
pika_tool_modifier_key (tool, GDK_CONTROL_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_MOD1_MASK, &press))
{
pika_tool_modifier_key (tool, GDK_MOD1_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_MOD2_MASK, &press))
{
pika_tool_modifier_key (tool, GDK_MOD2_MASK,
press, state,
display);
}
tool->modifier_state = state;
}
void
pika_tool_set_active_modifier_state (PikaTool *tool,
GdkModifierType state,
PikaDisplay *display)
{
PikaToolActiveModifiers active_modifiers;
gboolean press;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (pika_tool_control_is_active (tool->control) == TRUE);
PIKA_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 = pika_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 PIKA_TOOL_ACTIVE_MODIFIERS_OFF:
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SAME:
pika_tool_modifier_key (tool, GDK_SHIFT_MASK,
press, state,
display);
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SEPARATE:
if (! press && (tool->button_press_state & GDK_SHIFT_MASK))
{
tool->button_press_state &= ~GDK_SHIFT_MASK;
}
else
{
pika_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 PIKA_TOOL_ACTIVE_MODIFIERS_OFF:
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SAME:
pika_tool_modifier_key (tool, GDK_CONTROL_MASK,
press, state,
display);
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SEPARATE:
if (! press && (tool->button_press_state & GDK_CONTROL_MASK))
{
tool->button_press_state &= ~GDK_CONTROL_MASK;
}
else
{
pika_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 PIKA_TOOL_ACTIVE_MODIFIERS_OFF:
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SAME:
pika_tool_modifier_key (tool, GDK_MOD1_MASK,
press, state,
display);
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SEPARATE:
if (! press && (tool->button_press_state & GDK_MOD1_MASK))
{
tool->button_press_state &= ~GDK_MOD1_MASK;
}
else
{
pika_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 PIKA_TOOL_ACTIVE_MODIFIERS_OFF:
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SAME:
pika_tool_modifier_key (tool, GDK_MOD2_MASK,
press, state,
display);
break;
case PIKA_TOOL_ACTIVE_MODIFIERS_SEPARATE:
if (! press && (tool->button_press_state & GDK_MOD2_MASK))
{
tool->button_press_state &= ~GDK_MOD2_MASK;
}
else
{
pika_tool_active_modifier_key (tool, GDK_MOD2_MASK,
press, state,
display);
}
break;
}
}
tool->active_modifier_state = state;
if (active_modifiers == PIKA_TOOL_ACTIVE_MODIFIERS_SAME)
tool->modifier_state = state;
}
void
pika_tool_oper_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
gboolean proximity,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (coords != NULL);
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (pika_tool_control_is_active (tool->control) == FALSE);
PIKA_TOOL_GET_CLASS (tool)->oper_update (tool, coords, state, proximity,
display);
if (G_UNLIKELY (pika_image_is_empty (pika_display_get_image (display)) &&
! pika_tool_control_get_handle_empty_image (tool->control)))
{
pika_tool_replace_status (tool, display,
"%s",
_("Can't work on an empty image, "
"add a layer first"));
}
}
void
pika_tool_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (coords != NULL);
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (pika_tool_control_is_active (tool->control) == FALSE);
PIKA_TOOL_GET_CLASS (tool)->cursor_update (tool, coords, state, display);
}
const gchar *
pika_tool_can_undo (PikaTool *tool,
PikaDisplay *display)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), NULL);
if (display == tool->display)
return PIKA_TOOL_GET_CLASS (tool)->can_undo (tool, display);
return NULL;
}
const gchar *
pika_tool_can_redo (PikaTool *tool,
PikaDisplay *display)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), NULL);
if (display == tool->display)
return PIKA_TOOL_GET_CLASS (tool)->can_redo (tool, display);
return NULL;
}
gboolean
pika_tool_undo (PikaTool *tool,
PikaDisplay *display)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), FALSE);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), FALSE);
if (pika_tool_can_undo (tool, display))
return PIKA_TOOL_GET_CLASS (tool)->undo (tool, display);
return FALSE;
}
gboolean
pika_tool_redo (PikaTool *tool,
PikaDisplay *display)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), FALSE);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), FALSE);
if (pika_tool_can_redo (tool, display))
return PIKA_TOOL_GET_CLASS (tool)->redo (tool, display);
return FALSE;
}
PikaUIManager *
pika_tool_get_popup (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display,
const gchar **ui_path)
{
g_return_val_if_fail (PIKA_IS_TOOL (tool), NULL);
g_return_val_if_fail (coords != NULL, NULL);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), NULL);
g_return_val_if_fail (ui_path != NULL, NULL);
return PIKA_TOOL_GET_CLASS (tool)->get_popup (tool, coords, state, display,
ui_path);
}
/*
* pika_tool_push_status:
* @tool:
* @display:
* @format:
*
* Push a new status message for the context of the @tool, in the shell
* associated to @display. Note that the message will replace any
* message for the same context (i.e. same tool) while also ensuring it
* is in the front of the message list (except for any progress or
* temporary messages which might be going on and are always front).
* This is the main difference with pika_tool_replace_status() which
* does not necessarily try to make it a front message.
*
* In particular, it means you don't have to call pika_tool_pop_status()
* first before calling pika_tool_push_status(). Even more, you should
* not pop the status if you were planning to push a new status for the
* same context because you are triggering non necessary redraws of the
* status bar.
*/
void
pika_tool_push_status (PikaTool *tool,
PikaDisplay *display,
const gchar *format,
...)
{
PikaDisplayShell *shell;
const gchar *icon_name;
va_list args;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (format != NULL);
shell = pika_display_get_shell (display);
icon_name = pika_viewable_get_icon_name (PIKA_VIEWABLE (tool->tool_info));
va_start (args, format);
pika_statusbar_push_valist (pika_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
pika_tool_push_status_coords (PikaTool *tool,
PikaDisplay *display,
PikaCursorPrecision precision,
const gchar *title,
gdouble x,
const gchar *separator,
gdouble y,
const gchar *help)
{
PikaDisplayShell *shell;
const gchar *icon_name;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
shell = pika_display_get_shell (display);
icon_name = pika_viewable_get_icon_name (PIKA_VIEWABLE (tool->tool_info));
pika_statusbar_push_coords (pika_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
pika_tool_push_status_length (PikaTool *tool,
PikaDisplay *display,
const gchar *title,
PikaOrientationType axis,
gdouble value,
const gchar *help)
{
PikaDisplayShell *shell;
const gchar *icon_name;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
shell = pika_display_get_shell (display);
icon_name = pika_viewable_get_icon_name (PIKA_VIEWABLE (tool->tool_info));
pika_statusbar_push_length (pika_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);
}
/*
* pika_tool_replace_status:
* @tool:
* @display:
* @format:
*
* Push a new status message for the context of the @tool, in the shell
* associated to @display. If any message for the same context (i.e.
* same tool) is already lined up, it will be replaced without changing
* the appearance order. In other words, it doesn't try to prioritize
* this new status message. Yet if no message for the same context
* existed already, the new status would end up front (except for any
* progress or temporary messages which might be going on and are always
* front).
* See also pika_tool_push_status().
*
* Therefore you should not call pika_tool_pop_status() first before
* calling pika_tool_replace_status() as it would not be the same
* behavior and could trigger unnecessary redraws of the status bar.
*/
void
pika_tool_replace_status (PikaTool *tool,
PikaDisplay *display,
const gchar *format,
...)
{
PikaDisplayShell *shell;
const gchar *icon_name;
va_list args;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (format != NULL);
shell = pika_display_get_shell (display);
icon_name = pika_viewable_get_icon_name (PIKA_VIEWABLE (tool->tool_info));
va_start (args, format);
pika_statusbar_replace_valist (pika_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
pika_tool_pop_status (PikaTool *tool,
PikaDisplay *display)
{
PikaDisplayShell *shell;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
shell = pika_display_get_shell (display);
pika_statusbar_pop (pika_display_shell_get_statusbar (shell),
G_OBJECT_TYPE_NAME (tool));
tool->status_displays = g_list_remove (tool->status_displays, display);
}
void
pika_tool_message (PikaTool *tool,
PikaDisplay *display,
const gchar *format,
...)
{
va_list args;
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (format != NULL);
va_start (args, format);
pika_message_valist (display->pika, G_OBJECT (display),
PIKA_MESSAGE_WARNING, format, args);
va_end (args);
}
void
pika_tool_message_literal (PikaTool *tool,
PikaDisplay *display,
const gchar *message)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
g_return_if_fail (message != NULL);
pika_message_literal (display->pika, G_OBJECT (display),
PIKA_MESSAGE_WARNING, message);
}
void
pika_tool_set_cursor (PikaTool *tool,
PikaDisplay *display,
PikaCursorType cursor,
PikaToolCursorType tool_cursor,
PikaCursorModifier modifier)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
g_return_if_fail (PIKA_IS_DISPLAY (display));
pika_display_shell_set_cursor (pika_display_get_shell (display),
cursor, tool_cursor, modifier);
}
/* private functions */
static void
pika_tool_options_notify (PikaToolOptions *options,
const GParamSpec *pspec,
PikaTool *tool)
{
PIKA_TOOL_GET_CLASS (tool)->options_notify (tool, options, pspec);
}
static void
pika_tool_clear_status (PikaTool *tool)
{
g_return_if_fail (PIKA_IS_TOOL (tool));
while (tool->status_displays)
pika_tool_pop_status (tool, tool->status_displays->data);
}
static void
pika_tool_release (PikaTool *tool)
{
if (tool->last_pointer_state &&
pika_tool_control_is_active (tool->control))
{
pika_tool_button_release (
tool,
&tool->last_pointer_coords,
tool->last_pointer_time + g_get_monotonic_time () / 1000,
tool->last_pointer_state,
tool->display);
}
}