AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/app/tools/pikatransformgridtool.c

2223 lines
80 KiB
C
Raw Normal View History

Initial checkin of Pika from heckimp
2023-09-26 00:35:21 +02:00
/* 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-2001 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 <gdk/gdkkeysyms.h>
#include "libpikamath/pikamath.h"
#include "libpikawidgets/pikawidgets.h"
#include "tools-types.h"
#include "gegl/pikaapplicator.h"
#include "gegl/pika-gegl-nodes.h"
#include "gegl/pika-gegl-utils.h"
#include "core/pika.h"
#include "core/pika-transform-resize.h"
#include "core/pika-transform-utils.h"
#include "core/pikaboundary.h"
#include "core/pikacontainer.h"
#include "core/pikadrawablefilter.h"
#include "core/pikaerror.h"
#include "core/pikafilter.h"
#include "core/pikagrouplayer.h"
#include "core/pikaimage.h"
#include "core/pikaimage-item-list.h"
#include "core/pikaimage-undo.h"
#include "core/pikaimage-undo-push.h"
#include "core/pikalayer.h"
#include "core/pikalayermask.h"
#include "core/pikapickable.h"
#include "core/pikaprojection.h"
#include "core/pikatoolinfo.h"
#include "core/pikaviewable.h"
#include "vectors/pikavectors.h"
#include "vectors/pikastroke.h"
#include "widgets/pikawidgets-utils.h"
#include "display/pikacanvasitem.h"
#include "display/pikadisplay.h"
#include "display/pikadisplayshell.h"
#include "display/pikatoolgui.h"
#include "display/pikatoolwidget.h"
#include "pikatoolcontrol.h"
#include "pikatransformgridoptions.h"
#include "pikatransformgridtool.h"
#include "pikatransformgridtoolundo.h"
#include "pikatransformoptions.h"
#include "pika-intl.h"
#define EPSILON 1e-6
#define RESPONSE_RESET 1
#define RESPONSE_READJUST 2
#define UNDO_COMPRESS_TIME (0.5 * G_TIME_SPAN_SECOND)
typedef struct
{
PikaTransformGridTool *tg_tool;
PikaDrawable *drawable;
PikaDrawableFilter *filter;
PikaDrawable *root_drawable;
GeglNode *transform_node;
GeglNode *crop_node;
PikaMatrix3 transform;
GeglRectangle bounds;
} Filter;
typedef struct
{
PikaTransformGridTool *tg_tool;
PikaDrawable *root_drawable;
} AddFilterData;
typedef struct
{
gint64 time;
PikaTransformDirection direction;
TransInfo trans_infos[2];
} UndoInfo;
static void pika_transform_grid_tool_finalize (GObject *object);
static gboolean pika_transform_grid_tool_initialize (PikaTool *tool,
PikaDisplay *display,
GError **error);
static void pika_transform_grid_tool_control (PikaTool *tool,
PikaToolAction action,
PikaDisplay *display);
static void pika_transform_grid_tool_button_press (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonPressType press_type,
PikaDisplay *display);
static void pika_transform_grid_tool_button_release (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonReleaseType release_type,
PikaDisplay *display);
static void pika_transform_grid_tool_motion (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display);
static void pika_transform_grid_tool_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display);
static void pika_transform_grid_tool_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display);
static const gchar * pika_transform_grid_tool_can_undo (PikaTool *tool,
PikaDisplay *display);
static const gchar * pika_transform_grid_tool_can_redo (PikaTool *tool,
PikaDisplay *display);
static gboolean pika_transform_grid_tool_undo (PikaTool *tool,
PikaDisplay *display);
static gboolean pika_transform_grid_tool_redo (PikaTool *tool,
PikaDisplay *display);
static void pika_transform_grid_tool_options_notify (PikaTool *tool,
PikaToolOptions *options,
const GParamSpec *pspec);
static void pika_transform_grid_tool_draw (PikaDrawTool *draw_tool);
static void pika_transform_grid_tool_recalc_matrix (PikaTransformTool *tr_tool);
static gchar * pika_transform_grid_tool_get_undo_desc (PikaTransformTool *tr_tool);
static PikaTransformDirection pika_transform_grid_tool_get_direction
(PikaTransformTool *tr_tool);
static GeglBuffer * pika_transform_grid_tool_transform (PikaTransformTool *tr_tool,
GList *objects,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
PikaColorProfile **buffer_profile,
gint *new_offset_x,
gint *new_offset_y);
static void pika_transform_grid_tool_real_apply_info (PikaTransformGridTool *tg_tool,
const TransInfo info);
static gchar * pika_transform_grid_tool_real_get_undo_desc (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_real_update_widget (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_real_widget_changed (PikaTransformGridTool *tg_tool);
static GeglBuffer * pika_transform_grid_tool_real_transform (PikaTransformGridTool *tg_tool,
GList *objects,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
PikaColorProfile **buffer_profile,
gint *new_offset_x,
gint *new_offset_y);
static void pika_transform_grid_tool_widget_changed (PikaToolWidget *widget,
PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_widget_response (PikaToolWidget *widget,
gint response_id,
PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_filter_flush (PikaDrawableFilter *filter,
PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_halt (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_commit (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_dialog (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_dialog_update (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_prepare (PikaTransformGridTool *tg_tool,
PikaDisplay *display);
static PikaToolWidget * pika_transform_grid_tool_get_widget (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_update_widget (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_response (PikaToolGui *gui,
gint response_id,
PikaTransformGridTool *tg_tool);
static gboolean pika_transform_grid_tool_composited_preview (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_update_sensitivity (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_update_preview (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_update_filters (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_hide_selected_objects (PikaTransformGridTool *tg_tool,
GList *objects);
static void pika_transform_grid_tool_show_selected_objects (PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_add_filter (PikaDrawable *drawable,
AddFilterData *data);
static void pika_transform_grid_tool_remove_filter (PikaDrawable *drawable,
PikaTransformGridTool *tg_tool);
static void pika_transform_grid_tool_effective_mode_changed
(PikaLayer *layer,
PikaTransformGridTool *tg_tool);
static Filter * filter_new (PikaTransformGridTool *tg_tool,
PikaDrawable *drawable,
PikaDrawable *root_drawable,
gboolean add_filter);
static void filter_free (Filter *filter);
static UndoInfo * undo_info_new (void);
static void undo_info_free (UndoInfo *info);
static gboolean trans_info_equal (const TransInfo trans_info1,
const TransInfo trans_info2);
static gboolean trans_infos_equal (const TransInfo *trans_infos1,
const TransInfo *trans_infos2);
G_DEFINE_TYPE (PikaTransformGridTool, pika_transform_grid_tool, PIKA_TYPE_TRANSFORM_TOOL)
#define parent_class pika_transform_grid_tool_parent_class
static void
pika_transform_grid_tool_class_init (PikaTransformGridToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
PikaToolClass *tool_class = PIKA_TOOL_CLASS (klass);
PikaDrawToolClass *draw_class = PIKA_DRAW_TOOL_CLASS (klass);
PikaTransformToolClass *tr_class = PIKA_TRANSFORM_TOOL_CLASS (klass);
object_class->finalize = pika_transform_grid_tool_finalize;
tool_class->initialize = pika_transform_grid_tool_initialize;
tool_class->control = pika_transform_grid_tool_control;
tool_class->button_press = pika_transform_grid_tool_button_press;
tool_class->button_release = pika_transform_grid_tool_button_release;
tool_class->motion = pika_transform_grid_tool_motion;
tool_class->modifier_key = pika_transform_grid_tool_modifier_key;
tool_class->cursor_update = pika_transform_grid_tool_cursor_update;
tool_class->can_undo = pika_transform_grid_tool_can_undo;
tool_class->can_redo = pika_transform_grid_tool_can_redo;
tool_class->undo = pika_transform_grid_tool_undo;
tool_class->redo = pika_transform_grid_tool_redo;
tool_class->options_notify = pika_transform_grid_tool_options_notify;
draw_class->draw = pika_transform_grid_tool_draw;
tr_class->recalc_matrix = pika_transform_grid_tool_recalc_matrix;
tr_class->get_undo_desc = pika_transform_grid_tool_get_undo_desc;
tr_class->get_direction = pika_transform_grid_tool_get_direction;
tr_class->transform = pika_transform_grid_tool_transform;
klass->info_to_matrix = NULL;
klass->matrix_to_info = NULL;
klass->apply_info = pika_transform_grid_tool_real_apply_info;
klass->get_undo_desc = pika_transform_grid_tool_real_get_undo_desc;
klass->dialog = NULL;
klass->dialog_update = NULL;
klass->prepare = NULL;
klass->readjust = NULL;
klass->get_widget = NULL;
klass->update_widget = pika_transform_grid_tool_real_update_widget;
klass->widget_changed = pika_transform_grid_tool_real_widget_changed;
klass->transform = pika_transform_grid_tool_real_transform;
klass->ok_button_label = _("_Transform");
}
static void
pika_transform_grid_tool_init (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
pika_tool_control_set_scroll_lock (tool->control, TRUE);
pika_tool_control_set_preserve (tool->control, FALSE);
pika_tool_control_set_dirty_mask (tool->control,
PIKA_DIRTY_IMAGE_SIZE |
PIKA_DIRTY_IMAGE_STRUCTURE |
PIKA_DIRTY_DRAWABLE |
PIKA_DIRTY_SELECTION |
PIKA_DIRTY_ACTIVE_DRAWABLE);
pika_tool_control_set_active_modifiers (tool->control,
PIKA_TOOL_ACTIVE_MODIFIERS_SAME);
pika_tool_control_set_precision (tool->control,
PIKA_CURSOR_PRECISION_SUBPIXEL);
pika_tool_control_set_cursor (tool->control,
PIKA_CURSOR_CROSSHAIR_SMALL);
pika_tool_control_set_action_opacity (tool->control,
"tools-transform-preview-opacity-set");
tg_tool->strokes = g_ptr_array_new ();
}
static void
pika_transform_grid_tool_finalize (GObject *object)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (object);
g_clear_object (&tg_tool->gui);
g_clear_pointer (&tg_tool->strokes, g_ptr_array_unref);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gboolean
pika_transform_grid_tool_initialize (PikaTool *tool,
PikaDisplay *display,
GError **error)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tool);
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
PikaTransformGridOptions *tg_options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tool);
PikaImage *image = pika_display_get_image (display);
GList *drawables;
GList *objects;
GList *iter;
UndoInfo *undo_info;
objects = pika_transform_tool_check_selected_objects (tr_tool, display, error);
if (! objects)
return FALSE;
drawables = pika_image_get_selected_drawables (image);
if (g_list_length (drawables) < 1)
{
pika_tool_message_literal (tool, display, _("No selected drawables."));
g_list_free (drawables);
g_list_free (objects);
return FALSE;
}
tool->display = display;
tool->drawables = drawables;
tr_tool->objects = objects;
for (iter = objects; iter; iter = iter->next)
if (PIKA_IS_DRAWABLE (iter->data))
pika_viewable_preview_freeze (iter->data);
/* Initialize the transform_grid tool dialog */
if (! tg_tool->gui)
pika_transform_grid_tool_dialog (tg_tool);
/* Find the transform bounds for some tools (like scale,
* perspective) that actually need the bounds for initializing
*/
pika_transform_tool_bounds (tr_tool, display);
/* Initialize the tool-specific trans_info, and adjust the tool dialog */
pika_transform_grid_tool_prepare (tg_tool, display);
/* Recalculate the tool's transformation matrix */
pika_transform_tool_recalc_matrix (tr_tool, display);
/* Get the on-canvas gui */
tg_tool->widget = pika_transform_grid_tool_get_widget (tg_tool);
pika_transform_grid_tool_hide_selected_objects (tg_tool, objects);
/* start drawing the bounding box and handles... */
pika_draw_tool_start (PIKA_DRAW_TOOL (tool), display);
/* Initialize undo and redo lists */
undo_info = undo_info_new ();
tg_tool->undo_list = g_list_prepend (NULL, undo_info);
tg_tool->redo_list = NULL;
/* Save the current transformation info */
memcpy (undo_info->trans_infos, tg_tool->trans_infos,
sizeof (tg_tool->trans_infos));
if (tg_options->direction_chain_button)
gtk_widget_set_sensitive (tg_options->direction_chain_button, TRUE);
return TRUE;
}
static void
pika_transform_grid_tool_control (PikaTool *tool,
PikaToolAction action,
PikaDisplay *display)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
switch (action)
{
case PIKA_TOOL_ACTION_PAUSE:
case PIKA_TOOL_ACTION_RESUME:
break;
case PIKA_TOOL_ACTION_HALT:
pika_transform_grid_tool_halt (tg_tool);
break;
case PIKA_TOOL_ACTION_COMMIT:
if (tool->display)
pika_transform_grid_tool_commit (tg_tool);
break;
}
PIKA_TOOL_CLASS (parent_class)->control (tool, action, display);
}
static void
pika_transform_grid_tool_button_press (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonPressType press_type,
PikaDisplay *display)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
if (tg_tool->widget)
{
pika_tool_widget_hover (tg_tool->widget, coords, state, TRUE);
if (pika_tool_widget_button_press (tg_tool->widget, coords, time, state,
press_type))
{
tg_tool->grab_widget = tg_tool->widget;
}
}
pika_tool_control_activate (tool->control);
}
static void
pika_transform_grid_tool_button_release (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaButtonReleaseType release_type,
PikaDisplay *display)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tool);
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
pika_tool_control_halt (tool->control);
if (tg_tool->grab_widget)
{
pika_tool_widget_button_release (tg_tool->grab_widget,
coords, time, state, release_type);
tg_tool->grab_widget = NULL;
}
if (release_type != PIKA_BUTTON_RELEASE_CANCEL)
{
/* We're done with an interaction, save it on the undo list */
pika_transform_grid_tool_push_internal_undo (tg_tool, FALSE);
}
else
{
UndoInfo *undo_info = tg_tool->undo_list->data;
/* Restore the last saved state */
memcpy (tg_tool->trans_infos, undo_info->trans_infos,
sizeof (tg_tool->trans_infos));
/* recalculate the tool's transformation matrix */
pika_transform_tool_recalc_matrix (tr_tool, display);
}
}
static void
pika_transform_grid_tool_motion (PikaTool *tool,
const PikaCoords *coords,
guint32 time,
GdkModifierType state,
PikaDisplay *display)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
if (tg_tool->grab_widget)
{
pika_tool_widget_motion (tg_tool->grab_widget, coords, time, state);
}
}
static void
pika_transform_grid_tool_modifier_key (PikaTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
PikaDisplay *display)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
if (tg_tool->widget)
{
PIKA_TOOL_CLASS (parent_class)->modifier_key (tool, key, press,
state, display);
}
else
{
PikaTransformGridOptions *options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tool);
if (key == pika_get_constrain_behavior_mask ())
{
g_object_set (options,
"frompivot-scale", ! options->frompivot_scale,
"frompivot-shear", ! options->frompivot_shear,
"frompivot-perspective", ! options->frompivot_perspective,
NULL);
}
else if (key == pika_get_extend_selection_mask ())
{
g_object_set (options,
"cornersnap", ! options->cornersnap,
"constrain-move", ! options->constrain_move,
"constrain-scale", ! options->constrain_scale,
"constrain-rotate", ! options->constrain_rotate,
"constrain-shear", ! options->constrain_shear,
"constrain-perspective", ! options->constrain_perspective,
NULL);
}
}
}
static void
pika_transform_grid_tool_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tool);
GList *objects;
objects = pika_transform_tool_check_selected_objects (tr_tool, display, NULL);
if (display != tool->display && ! objects)
{
pika_tool_set_cursor (tool, display,
pika_tool_control_get_cursor (tool->control),
pika_tool_control_get_tool_cursor (tool->control),
PIKA_CURSOR_MODIFIER_BAD);
return;
}
g_list_free (objects);
PIKA_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static const gchar *
pika_transform_grid_tool_can_undo (PikaTool *tool,
PikaDisplay *display)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
if (! tg_tool->undo_list || ! tg_tool->undo_list->next)
return NULL;
return _("Transform Step");
}
static const gchar *
pika_transform_grid_tool_can_redo (PikaTool *tool,
PikaDisplay *display)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
if (! tg_tool->redo_list)
return NULL;
return _("Transform Step");
}
static gboolean
pika_transform_grid_tool_undo (PikaTool *tool,
PikaDisplay *display)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tool);
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tool);
UndoInfo *undo_info;
PikaTransformDirection direction;
undo_info = tg_tool->undo_list->data;
direction = undo_info->direction;
/* Move undo_info from undo_list to redo_list */
tg_tool->redo_list = g_list_prepend (tg_tool->redo_list, undo_info);
tg_tool->undo_list = g_list_remove (tg_tool->undo_list, undo_info);
undo_info = tg_tool->undo_list->data;
/* Restore the previous transformation info */
memcpy (tg_tool->trans_infos, undo_info->trans_infos,
sizeof (tg_tool->trans_infos));
/* Restore the previous transformation direction */
if (direction != tr_options->direction)
{
g_object_set (tr_options,
"direction", direction,
NULL);
}
/* recalculate the tool's transformation matrix */
pika_transform_tool_recalc_matrix (tr_tool, display);
return TRUE;
}
static gboolean
pika_transform_grid_tool_redo (PikaTool *tool,
PikaDisplay *display)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tool);
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tool);
UndoInfo *undo_info;
PikaTransformDirection direction;
undo_info = tg_tool->redo_list->data;
direction = undo_info->direction;
/* Move undo_info from redo_list to undo_list */
tg_tool->undo_list = g_list_prepend (tg_tool->undo_list, undo_info);
tg_tool->redo_list = g_list_remove (tg_tool->redo_list, undo_info);
/* Restore the previous transformation info */
memcpy (tg_tool->trans_infos, undo_info->trans_infos,
sizeof (tg_tool->trans_infos));
/* Restore the previous transformation direction */
if (direction != tr_options->direction)
{
g_object_set (tr_options,
"direction", direction,
NULL);
}
/* recalculate the tool's transformation matrix */
pika_transform_tool_recalc_matrix (tr_tool, display);
return TRUE;
}
static void
pika_transform_grid_tool_options_notify (PikaTool *tool,
PikaToolOptions *options,
const GParamSpec *pspec)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tool);
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tool);
PikaTransformGridOptions *tg_options = PIKA_TRANSFORM_GRID_OPTIONS (options);
PIKA_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! strcmp (pspec->name, "type"))
{
pika_tool_control (tool, PIKA_TOOL_ACTION_HALT, tool->display);
return;
}
if (! tg_tool->widget)
return;
if (! strcmp (pspec->name, "direction"))
{
/* recalculate the tool's transformation matrix */
pika_transform_tool_recalc_matrix (tr_tool, tool->display);
}
else if (! strcmp (pspec->name, "show-preview") ||
! strcmp (pspec->name, "composited-preview"))
{
if (tg_tool->previews)
{
PikaDisplay *display;
GList *objects;
display = tool->display;
objects = pika_transform_tool_get_selected_objects (tr_tool, display);
if (objects)
{
if (tg_options->show_preview &&
! pika_transform_grid_tool_composited_preview (tg_tool))
{
pika_transform_grid_tool_hide_selected_objects (tg_tool, objects);
}
else
{
pika_transform_grid_tool_show_selected_objects (tg_tool);
}
g_list_free (objects);
}
pika_transform_grid_tool_update_preview (tg_tool);
}
}
else if (! strcmp (pspec->name, "interpolation") ||
! strcmp (pspec->name, "clip") ||
! strcmp (pspec->name, "preview-opacity"))
{
pika_transform_grid_tool_update_preview (tg_tool);
}
else if (g_str_has_prefix (pspec->name, "constrain-") ||
g_str_has_prefix (pspec->name, "frompivot-") ||
! strcmp (pspec->name, "fixedpivot") ||
! strcmp (pspec->name, "cornersnap"))
{
pika_transform_grid_tool_dialog_update (tg_tool);
}
}
static void
pika_transform_grid_tool_draw (PikaDrawTool *draw_tool)
{
PikaTool *tool = PIKA_TOOL (draw_tool);
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (draw_tool);
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (draw_tool);
PikaTransformGridOptions *options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_OPTIONS (options);
PikaDisplayShell *shell = pika_display_get_shell (tool->display);
PikaImage *image = pika_display_get_image (tool->display);
PikaMatrix3 matrix = tr_tool->transform;
PikaCanvasItem *item;
if (tr_options->direction == PIKA_TRANSFORM_BACKWARD)
pika_matrix3_invert (&matrix);
if (tr_options->type == PIKA_TRANSFORM_TYPE_LAYER ||
tr_options->type == PIKA_TRANSFORM_TYPE_IMAGE)
{
GList *pickables = NULL;
GList *iter;
if (tr_options->type == PIKA_TRANSFORM_TYPE_IMAGE)
{
if (! shell->show_all)
pickables = g_list_prepend (pickables, image);
else
pickables = g_list_prepend (pickables, pika_image_get_projection (image));
}
else
{
for (iter = tool->drawables; iter; iter = iter->next)
pickables = g_list_prepend (pickables, iter->data);
}
for (iter = pickables; iter; iter = iter->next)
{
PikaCanvasItem *preview;
preview = pika_draw_tool_add_transform_preview (draw_tool,
PIKA_PICKABLE (iter->data),
&matrix,
tr_tool->x1,
tr_tool->y1,
tr_tool->x2,
tr_tool->y2);
tg_tool->previews = g_list_prepend (tg_tool->previews, preview);
/* NOT g_set_weak_pointr() because the pointer is already set */
g_object_add_weak_pointer (G_OBJECT (tg_tool->previews->data),
(gpointer) &tg_tool->previews->data);
}
g_list_free (pickables);
}
if (tr_options->type == PIKA_TRANSFORM_TYPE_SELECTION)
{
const PikaBoundSeg *segs_in;
const PikaBoundSeg *segs_out;
gint n_segs_in;
gint n_segs_out;
pika_channel_boundary (pika_image_get_mask (image),
&segs_in, &segs_out,
&n_segs_in, &n_segs_out,
0, 0, 0, 0);
if (segs_in)
{
g_set_weak_pointer
(&tg_tool->boundary_in,
pika_draw_tool_add_boundary (draw_tool,
segs_in, n_segs_in,
&matrix,
0, 0));
pika_canvas_item_set_visible (tg_tool->boundary_in,
tr_tool->transform_valid);
}
if (segs_out)
{
g_set_weak_pointer
(&tg_tool->boundary_out,
pika_draw_tool_add_boundary (draw_tool,
segs_out, n_segs_out,
&matrix,
0, 0));
pika_canvas_item_set_visible (tg_tool->boundary_out,
tr_tool->transform_valid);
}
}
else if (tr_options->type == PIKA_TRANSFORM_TYPE_PATH)
{
GList *iter;
for (iter = pika_image_get_selected_vectors (image); iter; iter = iter->next)
{
PikaVectors *vectors = iter->data;
PikaStroke *stroke = NULL;
while ((stroke = pika_vectors_stroke_get_next (vectors, stroke)))
{
GArray *coords;
gboolean closed;
coords = pika_stroke_interpolate (stroke, 1.0, &closed);
if (coords && coords->len)
{
item =
pika_draw_tool_add_strokes (draw_tool,
&g_array_index (coords,
PikaCoords, 0),
coords->len, &matrix, FALSE);
g_ptr_array_add (tg_tool->strokes, item);
g_object_weak_ref (G_OBJECT (item),
(GWeakNotify) g_ptr_array_remove,
tg_tool->strokes);
pika_canvas_item_set_visible (item, tr_tool->transform_valid);
}
if (coords)
g_array_free (coords, TRUE);
}
}
}
PIKA_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
pika_transform_grid_tool_update_preview (tg_tool);
}
static void
pika_transform_grid_tool_recalc_matrix (PikaTransformTool *tr_tool)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tr_tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tr_tool);
PikaTransformGridOptions *tg_options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tr_tool);
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->info_to_matrix)
{
PikaMatrix3 forward_transform;
PikaMatrix3 backward_transform;
gboolean forward_transform_valid;
gboolean backward_transform_valid;
tg_tool->trans_info = tg_tool->trans_infos[PIKA_TRANSFORM_FORWARD];
forward_transform_valid = pika_transform_grid_tool_info_to_matrix (
tg_tool, &forward_transform);
tg_tool->trans_info = tg_tool->trans_infos[PIKA_TRANSFORM_BACKWARD];
backward_transform_valid = pika_transform_grid_tool_info_to_matrix (
tg_tool, &backward_transform);
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->matrix_to_info &&
tg_options->direction_linked)
{
PikaMatrix3 transform = tr_tool->transform;
switch (tr_options->direction)
{
case PIKA_TRANSFORM_FORWARD:
if (forward_transform_valid)
{
pika_matrix3_invert (&transform);
backward_transform = forward_transform;
pika_matrix3_mult (&transform, &backward_transform);
tg_tool->trans_info =
tg_tool->trans_infos[PIKA_TRANSFORM_BACKWARD];
pika_transform_grid_tool_matrix_to_info (tg_tool,
&backward_transform);
backward_transform_valid =
pika_transform_grid_tool_info_to_matrix (
tg_tool, &backward_transform);
}
break;
case PIKA_TRANSFORM_BACKWARD:
if (backward_transform_valid)
{
forward_transform = backward_transform;
pika_matrix3_mult (&transform, &forward_transform);
tg_tool->trans_info =
tg_tool->trans_infos[PIKA_TRANSFORM_FORWARD];
pika_transform_grid_tool_matrix_to_info (tg_tool,
&forward_transform);
forward_transform_valid =
pika_transform_grid_tool_info_to_matrix (
tg_tool, &forward_transform);
}
break;
}
}
else if (forward_transform_valid && backward_transform_valid)
{
tr_tool->transform = backward_transform;
pika_matrix3_invert (&tr_tool->transform);
pika_matrix3_mult (&forward_transform, &tr_tool->transform);
}
tr_tool->transform_valid = forward_transform_valid &&
backward_transform_valid;
}
tg_tool->trans_info = tg_tool->trans_infos[tr_options->direction];
pika_transform_grid_tool_dialog_update (tg_tool);
pika_transform_grid_tool_update_sensitivity (tg_tool);
pika_transform_grid_tool_update_widget (tg_tool);
pika_transform_grid_tool_update_preview (tg_tool);
if (tg_tool->gui)
pika_tool_gui_show (tg_tool->gui);
}
static gchar *
pika_transform_grid_tool_get_undo_desc (PikaTransformTool *tr_tool)
{
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tr_tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tr_tool);
gchar *result;
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->matrix_to_info)
{
TransInfo trans_info;
memcpy (&trans_info, &tg_tool->init_trans_info, sizeof (TransInfo));
tg_tool->trans_info = trans_info;
pika_transform_grid_tool_matrix_to_info (tg_tool, &tr_tool->transform);
result = PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->get_undo_desc (
tg_tool);
}
else if (trans_info_equal (tg_tool->trans_infos[PIKA_TRANSFORM_BACKWARD],
tg_tool->init_trans_info))
{
tg_tool->trans_info = tg_tool->trans_infos[PIKA_TRANSFORM_FORWARD];
result = PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->get_undo_desc (
tg_tool);
}
else if (trans_info_equal (tg_tool->trans_infos[PIKA_TRANSFORM_FORWARD],
tg_tool->init_trans_info))
{
gchar *desc;
tg_tool->trans_info = tg_tool->trans_infos[PIKA_TRANSFORM_BACKWARD];
desc = PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->get_undo_desc (
tg_tool);
result = g_strdup_printf (_("%s (Corrective)"), desc);
g_free (desc);
}
else
{
result = PIKA_TRANSFORM_TOOL_CLASS (parent_class)->get_undo_desc (
tr_tool);
}
tg_tool->trans_info = tg_tool->trans_infos[tr_options->direction];
return result;
}
static PikaTransformDirection
pika_transform_grid_tool_get_direction (PikaTransformTool *tr_tool)
{
return PIKA_TRANSFORM_FORWARD;
}
static GeglBuffer *
pika_transform_grid_tool_transform (PikaTransformTool *tr_tool,
GList *objects,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
PikaColorProfile **buffer_profile,
gint *new_offset_x,
gint *new_offset_y)
{
PikaTool *tool = PIKA_TOOL (tr_tool);
PikaTransformGridTool *tg_tool = PIKA_TRANSFORM_GRID_TOOL (tr_tool);
PikaDisplay *display = tool->display;
PikaImage *image = pika_display_get_image (display);
GeglBuffer *new_buffer;
/* Send the request for the transformation to the tool...
*/
new_buffer =
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->transform (tg_tool,
objects,
orig_buffer,
orig_offset_x,
orig_offset_y,
buffer_profile,
new_offset_x,
new_offset_y);
pika_image_undo_push (image, PIKA_TYPE_TRANSFORM_GRID_TOOL_UNDO,
PIKA_UNDO_TRANSFORM_GRID, NULL,
0,
"transform-tool", tg_tool,
NULL);
return new_buffer;
}
static void
pika_transform_grid_tool_real_apply_info (PikaTransformGridTool *tg_tool,
const TransInfo info)
{
memcpy (tg_tool->trans_info, info, sizeof (TransInfo));
}
static gchar *
pika_transform_grid_tool_real_get_undo_desc (PikaTransformGridTool *tg_tool)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
return PIKA_TRANSFORM_TOOL_CLASS (parent_class)->get_undo_desc (tr_tool);
}
static void
pika_transform_grid_tool_real_update_widget (PikaTransformGridTool *tg_tool)
{
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->info_to_matrix)
{
PikaMatrix3 transform;
pika_transform_grid_tool_info_to_matrix (tg_tool, &transform);
g_object_set (tg_tool->widget,
"transform", &transform,
NULL);
}
}
static void
pika_transform_grid_tool_real_widget_changed (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
PikaToolWidget *widget = tg_tool->widget;
/* suppress the call to PikaTransformGridTool::update_widget() when
* recalculating the matrix
*/
tg_tool->widget = NULL;
pika_transform_tool_recalc_matrix (tr_tool, tool->display);
tg_tool->widget = widget;
}
static GeglBuffer *
pika_transform_grid_tool_real_transform (PikaTransformGridTool *tg_tool,
GList *objects,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
PikaColorProfile **buffer_profile,
gint *new_offset_x,
gint *new_offset_y)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
return PIKA_TRANSFORM_TOOL_CLASS (parent_class)->transform (tr_tool,
objects,
orig_buffer,
orig_offset_x,
orig_offset_y,
buffer_profile,
new_offset_x,
new_offset_y);
}
static void
pika_transform_grid_tool_widget_changed (PikaToolWidget *widget,
PikaTransformGridTool *tg_tool)
{
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->widget_changed)
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->widget_changed (tg_tool);
}
static void
pika_transform_grid_tool_widget_response (PikaToolWidget *widget,
gint response_id,
PikaTransformGridTool *tg_tool)
{
switch (response_id)
{
case PIKA_TOOL_WIDGET_RESPONSE_CONFIRM:
pika_transform_grid_tool_response (NULL, GTK_RESPONSE_OK, tg_tool);
break;
case PIKA_TOOL_WIDGET_RESPONSE_CANCEL:
pika_transform_grid_tool_response (NULL, GTK_RESPONSE_CANCEL, tg_tool);
break;
case PIKA_TOOL_WIDGET_RESPONSE_RESET:
pika_transform_grid_tool_response (NULL, RESPONSE_RESET, tg_tool);
break;
}
}
static void
pika_transform_grid_tool_filter_flush (PikaDrawableFilter *filter,
PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaImage *image = pika_display_get_image (tool->display);
pika_projection_flush (pika_image_get_projection (image));
}
static void
pika_transform_grid_tool_halt (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
PikaTransformGridOptions *tg_options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tg_tool);
GList *iter;
if (pika_draw_tool_is_active (PIKA_DRAW_TOOL (tg_tool)))
pika_draw_tool_stop (PIKA_DRAW_TOOL (tg_tool));
pika_draw_tool_set_widget (PIKA_DRAW_TOOL (tg_tool), NULL);
g_clear_object (&tg_tool->widget);
g_clear_pointer (&tg_tool->filters, g_hash_table_unref);
g_clear_pointer (&tg_tool->preview_drawables, g_list_free);
for (iter = tg_tool->previews; iter; iter = iter->next)
{
if (iter->data)
g_object_unref (iter->data);
}
g_clear_pointer (&tg_tool->previews, g_list_free);
if (tg_tool->gui)
pika_tool_gui_hide (tg_tool->gui);
if (tg_tool->redo_list)
{
g_list_free_full (tg_tool->redo_list, (GDestroyNotify) undo_info_free);
tg_tool->redo_list = NULL;
}
if (tg_tool->undo_list)
{
g_list_free_full (tg_tool->undo_list, (GDestroyNotify) undo_info_free);
tg_tool->undo_list = NULL;
}
pika_transform_grid_tool_show_selected_objects (tg_tool);
if (tg_options->direction_chain_button)
{
g_object_set (tg_options,
"direction-linked", FALSE,
NULL);
gtk_widget_set_sensitive (tg_options->direction_chain_button, FALSE);
}
tool->display = NULL;
g_list_free (tool->drawables);
tool->drawables = NULL;
if (tr_tool->objects)
{
GList *iter;
for (iter = tr_tool->objects; iter; iter = iter->next)
if (PIKA_IS_DRAWABLE (iter->data))
pika_viewable_preview_thaw (iter->data);
g_list_free (tr_tool->objects);
tr_tool->objects = NULL;
}
}
static void
pika_transform_grid_tool_commit (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
PikaDisplay *display = tool->display;
/* undraw the tool before we muck around with the transform matrix */
pika_draw_tool_stop (PIKA_DRAW_TOOL (tg_tool));
pika_transform_tool_transform (tr_tool, display);
}
static void
pika_transform_grid_tool_dialog (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaToolInfo *tool_info = tool->tool_info;
PikaDisplayShell *shell;
const gchar *ok_button_label;
if (! PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->dialog)
return;
g_return_if_fail (tool->display != NULL);
shell = pika_display_get_shell (tool->display);
ok_button_label = PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->ok_button_label;
tg_tool->gui = pika_tool_gui_new (tool_info,
NULL, NULL, NULL, NULL,
pika_widget_get_monitor (GTK_WIDGET (shell)),
TRUE,
NULL);
pika_tool_gui_add_button (tg_tool->gui, _("_Reset"), RESPONSE_RESET);
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->readjust)
pika_tool_gui_add_button (tg_tool->gui, _("Re_adjust"), RESPONSE_READJUST);
pika_tool_gui_add_button (tg_tool->gui, _("_Cancel"), GTK_RESPONSE_CANCEL);
pika_tool_gui_add_button (tg_tool->gui, ok_button_label, GTK_RESPONSE_OK);
pika_tool_gui_set_auto_overlay (tg_tool->gui, TRUE);
pika_tool_gui_set_default_response (tg_tool->gui, GTK_RESPONSE_OK);
pika_tool_gui_set_alternative_button_order (tg_tool->gui,
RESPONSE_RESET,
RESPONSE_READJUST,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (tg_tool->gui, "response",
G_CALLBACK (pika_transform_grid_tool_response),
tg_tool);
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->dialog (tg_tool);
}
static void
pika_transform_grid_tool_dialog_update (PikaTransformGridTool *tg_tool)
{
if (tg_tool->gui &&
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->dialog_update)
{
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->dialog_update (tg_tool);
}
}
static void
pika_transform_grid_tool_prepare (PikaTransformGridTool *tg_tool,
PikaDisplay *display)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
if (tg_tool->gui)
{
GList *objects = pika_transform_tool_get_selected_objects (tr_tool, display);
pika_tool_gui_set_shell (tg_tool->gui, pika_display_get_shell (display));
pika_tool_gui_set_viewables (tg_tool->gui, objects);
g_list_free (objects);
}
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->prepare)
{
tg_tool->trans_info = tg_tool->init_trans_info;
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->prepare (tg_tool);
memcpy (tg_tool->trans_infos[PIKA_TRANSFORM_FORWARD],
tg_tool->init_trans_info, sizeof (TransInfo));
memcpy (tg_tool->trans_infos[PIKA_TRANSFORM_BACKWARD],
tg_tool->init_trans_info, sizeof (TransInfo));
}
pika_matrix3_identity (&tr_tool->transform);
tr_tool->transform_valid = TRUE;
}
static PikaToolWidget *
pika_transform_grid_tool_get_widget (PikaTransformGridTool *tg_tool)
{
static const gchar *properties[] =
{
"constrain-move",
"constrain-scale",
"constrain-rotate",
"constrain-shear",
"constrain-perspective",
"frompivot-scale",
"frompivot-shear",
"frompivot-perspective",
"cornersnap",
"fixedpivot"
};
PikaToolWidget *widget = NULL;
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->get_widget)
{
PikaTransformGridOptions *options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tg_tool);
gint i;
widget = PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->get_widget (tg_tool);
pika_draw_tool_set_widget (PIKA_DRAW_TOOL (tg_tool), widget);
g_object_bind_property (G_OBJECT (options), "grid-type",
G_OBJECT (widget), "guide-type",
G_BINDING_SYNC_CREATE |
G_BINDING_BIDIRECTIONAL);
g_object_bind_property (G_OBJECT (options), "grid-size",
G_OBJECT (widget), "n-guides",
G_BINDING_SYNC_CREATE |
G_BINDING_BIDIRECTIONAL);
for (i = 0; i < G_N_ELEMENTS (properties); i++)
g_object_bind_property (G_OBJECT (options), properties[i],
G_OBJECT (widget), properties[i],
G_BINDING_SYNC_CREATE |
G_BINDING_BIDIRECTIONAL);
g_signal_connect (widget, "changed",
G_CALLBACK (pika_transform_grid_tool_widget_changed),
tg_tool);
g_signal_connect (widget, "response",
G_CALLBACK (pika_transform_grid_tool_widget_response),
tg_tool);
}
return widget;
}
static void
pika_transform_grid_tool_update_widget (PikaTransformGridTool *tg_tool)
{
if (tg_tool->widget &&
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->update_widget)
{
g_signal_handlers_block_by_func (
tg_tool->widget,
G_CALLBACK (pika_transform_grid_tool_widget_changed),
tg_tool);
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->update_widget (tg_tool);
g_signal_handlers_unblock_by_func (
tg_tool->widget,
G_CALLBACK (pika_transform_grid_tool_widget_changed),
tg_tool);
}
}
static void
pika_transform_grid_tool_response (PikaToolGui *gui,
gint response_id,
PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tg_tool);
PikaTransformGridOptions *tg_options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tg_tool);
PikaDisplay *display = tool->display;
/* we can get here while already committing a transformation. just return in
* this case. see issue #4734.
*/
if (! pika_draw_tool_is_active (PIKA_DRAW_TOOL (tg_tool)))
return;
switch (response_id)
{
case RESPONSE_RESET:
{
gboolean direction_linked;
/* restore the initial transformation info */
memcpy (tg_tool->trans_infos[PIKA_TRANSFORM_FORWARD],
tg_tool->init_trans_info,
sizeof (TransInfo));
memcpy (tg_tool->trans_infos[PIKA_TRANSFORM_BACKWARD],
tg_tool->init_trans_info,
sizeof (TransInfo));
/* recalculate the tool's transformation matrix */
direction_linked = tg_options->direction_linked;
tg_options->direction_linked = FALSE;
pika_transform_tool_recalc_matrix (tr_tool, display);
tg_options->direction_linked = direction_linked;
/* push the restored info to the undo stack */
pika_transform_grid_tool_push_internal_undo (tg_tool, FALSE);
}
break;
case RESPONSE_READJUST:
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->readjust &&
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->matrix_to_info &&
tr_tool->transform_valid)
{
TransInfo old_trans_infos[2];
gboolean direction_linked;
gboolean transform_valid;
/* save the current transformation info */
memcpy (old_trans_infos, tg_tool->trans_infos,
sizeof (old_trans_infos));
/* readjust the transformation info to view */
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->readjust (tg_tool);
/* recalculate the tool's transformation matrix, preserving the
* overall transformation
*/
direction_linked = tg_options->direction_linked;
tg_options->direction_linked = TRUE;
pika_transform_tool_recalc_matrix (tr_tool, display);
tg_options->direction_linked = direction_linked;
transform_valid = tr_tool->transform_valid;
/* if the resulting transformation is invalid, or if the
* transformation info is already adjusted to view ...
*/
if (! transform_valid ||
trans_infos_equal (old_trans_infos, tg_tool->trans_infos))
{
/* ... readjust the transformation info to the item bounds */
PikaMatrix3 transform = tr_tool->transform;
if (tr_options->direction == PIKA_TRANSFORM_BACKWARD)
pika_matrix3_invert (&transform);
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->apply_info (
tg_tool, tg_tool->init_trans_info);
PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->matrix_to_info (
tg_tool, &transform);
/* recalculate the tool's transformation matrix, preserving the
* overall transformation
*/
direction_linked = tg_options->direction_linked;
tg_options->direction_linked = TRUE;
pika_transform_tool_recalc_matrix (tr_tool, display);
tg_options->direction_linked = direction_linked;
if (! tr_tool->transform_valid ||
! trans_infos_equal (old_trans_infos, tg_tool->trans_infos))
{
transform_valid = tr_tool->transform_valid;
}
}
if (transform_valid)
{
/* push the new info to the undo stack */
pika_transform_grid_tool_push_internal_undo (tg_tool, FALSE);
}
else
{
/* restore the old transformation info */
memcpy (tg_tool->trans_infos, old_trans_infos,
sizeof (old_trans_infos));
/* recalculate the tool's transformation matrix */
direction_linked = tg_options->direction_linked;
tg_options->direction_linked = FALSE;
pika_transform_tool_recalc_matrix (tr_tool, display);
tg_options->direction_linked = direction_linked;
pika_tool_message_literal (tool, tool->display,
_("Cannot readjust the transformation"));
}
}
break;
case GTK_RESPONSE_OK:
g_return_if_fail (display != NULL);
pika_tool_control (tool, PIKA_TOOL_ACTION_COMMIT, display);
break;
default:
pika_tool_control (tool, PIKA_TOOL_ACTION_HALT, display);
/* update the undo actions / menu items */
if (display)
pika_image_flush (pika_display_get_image (display));
break;
}
}
static gboolean
pika_transform_grid_tool_composited_preview (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tg_tool);
PikaTransformGridOptions *tg_options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tg_tool);
PikaImage *image = pika_display_get_image (tool->display);
return tg_options->composited_preview &&
tr_options->type == PIKA_TRANSFORM_TYPE_LAYER &&
pika_channel_is_empty (pika_image_get_mask (image));
}
static void
pika_transform_grid_tool_update_sensitivity (PikaTransformGridTool *tg_tool)
{
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
if (! tg_tool->gui)
return;
pika_tool_gui_set_response_sensitive (
tg_tool->gui, GTK_RESPONSE_OK,
tr_tool->transform_valid);
pika_tool_gui_set_response_sensitive (
tg_tool->gui, RESPONSE_RESET,
! (trans_info_equal (tg_tool->trans_infos[PIKA_TRANSFORM_FORWARD],
tg_tool->init_trans_info) &&
trans_info_equal (tg_tool->trans_infos[PIKA_TRANSFORM_BACKWARD],
tg_tool->init_trans_info)));
pika_tool_gui_set_response_sensitive (
tg_tool->gui, RESPONSE_READJUST,
tr_tool->transform_valid);
}
static void
pika_transform_grid_tool_update_preview (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
PikaTransformTool *tr_tool = PIKA_TRANSFORM_TOOL (tg_tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tg_tool);
PikaTransformGridOptions *tg_options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tg_tool);
GList *iter;
gint i;
if (! tool->display)
return;
if (tg_options->show_preview &&
pika_transform_grid_tool_composited_preview (tg_tool) &&
tr_tool->transform_valid)
{
GHashTableIter iter;
PikaDrawable *drawable;
Filter *filter;
gboolean flush = FALSE;
if (! tg_tool->filters)
{
tg_tool->filters = g_hash_table_new_full (
g_direct_hash, g_direct_equal,
NULL, (GDestroyNotify) filter_free);
pika_transform_grid_tool_update_filters (tg_tool);
}
g_hash_table_iter_init (&iter, tg_tool->filters);
while (g_hash_table_iter_next (&iter,
(gpointer *) &drawable,
(gpointer *) &filter))
{
PikaMatrix3 transform;
GeglRectangle bounds;
gint offset_x;
gint offset_y;
gint width;
gint height;
gint x1, y1;
gint x2, y2;
gboolean update = FALSE;
if (! filter->filter)
continue;
pika_item_get_offset (PIKA_ITEM (drawable), &offset_x, &offset_y);
width = pika_item_get_width (PIKA_ITEM (drawable));
height = pika_item_get_height (PIKA_ITEM (drawable));
pika_matrix3_identity (&transform);
pika_matrix3_translate (&transform, +offset_x, +offset_y);
pika_matrix3_mult (&tr_tool->transform, &transform);
pika_matrix3_translate (&transform, -offset_x, -offset_y);
pika_transform_resize_boundary (&tr_tool->transform,
pika_item_get_clip (
PIKA_ITEM (filter->root_drawable),
tr_options->clip),
offset_x, offset_y,
offset_x + width, offset_y + height,
&x1, &y1,
&x2, &y2);
bounds.x = x1 - offset_x;
bounds.y = y1 - offset_y;
bounds.width = x2 - x1;
bounds.height = y2 - y1;
if (! pika_matrix3_equal (&transform, &filter->transform))
{
filter->transform = transform;
pika_gegl_node_set_matrix (filter->transform_node, &transform);
update = TRUE;
}
if (! gegl_rectangle_equal (&bounds, &filter->bounds))
{
filter->bounds = bounds;
gegl_node_set (filter->crop_node,
"x", (gdouble) bounds.x,
"y", (gdouble) bounds.y,
"width", (gdouble) bounds.width,
"height", (gdouble) bounds.height,
NULL);
update = TRUE;
}
if (PIKA_IS_LAYER (drawable))
{
pika_drawable_filter_set_add_alpha (
filter->filter,
tr_options->interpolation != PIKA_INTERPOLATION_NONE);
}
if (update)
{
if (tg_options->synchronous_preview)
{
g_signal_handlers_block_by_func (
filter->filter,
G_CALLBACK (pika_transform_grid_tool_filter_flush),
tg_tool);
}
pika_drawable_filter_apply (filter->filter, NULL);
if (tg_options->synchronous_preview)
{
g_signal_handlers_unblock_by_func (
filter->filter,
G_CALLBACK (pika_transform_grid_tool_filter_flush),
tg_tool);
flush = TRUE;
}
}
}
if (flush)
{
PikaImage *image = pika_display_get_image (tool->display);
pika_projection_flush_now (pika_image_get_projection (image), TRUE);
pika_display_flush_now (tool->display);
}
}
else
{
g_clear_pointer (&tg_tool->filters, g_hash_table_unref);
g_clear_pointer (&tg_tool->preview_drawables, g_list_free);
}
for (iter = tg_tool->previews; iter; iter = iter->next)
{
PikaCanvasItem *preview = iter->data;
if (preview == NULL)
continue;
if (tg_options->show_preview &&
! pika_transform_grid_tool_composited_preview (tg_tool) &&
tr_tool->transform_valid)
{
pika_canvas_item_begin_change (preview);
pika_canvas_item_set_visible (preview, TRUE);
g_object_set (
preview,
"transform", &tr_tool->transform,
"clip", pika_item_get_clip (PIKA_ITEM (tool->drawables->data),
tr_options->clip),
"opacity", tg_options->preview_opacity,
NULL);
pika_canvas_item_end_change (preview);
}
else
{
pika_canvas_item_set_visible (preview, FALSE);
}
}
if (tg_tool->boundary_in)
{
pika_canvas_item_begin_change (tg_tool->boundary_in);
pika_canvas_item_set_visible (tg_tool->boundary_in,
tr_tool->transform_valid);
g_object_set (tg_tool->boundary_in,
"transform", &tr_tool->transform,
NULL);
pika_canvas_item_end_change (tg_tool->boundary_in);
}
if (tg_tool->boundary_out)
{
pika_canvas_item_begin_change (tg_tool->boundary_out);
pika_canvas_item_set_visible (tg_tool->boundary_out,
tr_tool->transform_valid);
g_object_set (tg_tool->boundary_out,
"transform", &tr_tool->transform,
NULL);
pika_canvas_item_end_change (tg_tool->boundary_out);
}
for (i = 0; i < tg_tool->strokes->len; i++)
{
PikaCanvasItem *item = g_ptr_array_index (tg_tool->strokes, i);
pika_canvas_item_begin_change (item);
pika_canvas_item_set_visible (item, tr_tool->transform_valid);
g_object_set (item,
"transform", &tr_tool->transform,
NULL);
pika_canvas_item_end_change (item);
}
}
static void
pika_transform_grid_tool_update_filters (PikaTransformGridTool *tg_tool)
{
PikaTool *tool = PIKA_TOOL (tg_tool);
GHashTable *new_drawables;
GList *drawables;
GList *iter;
PikaDrawable *drawable;
GHashTableIter hash_iter;
if (! tg_tool->filters)
return;
drawables = pika_image_item_list_filter (g_list_copy (tool->drawables));
new_drawables = g_hash_table_new (g_direct_hash, g_direct_equal);
for (iter = drawables; iter; iter = g_list_next (iter))
g_hash_table_add (new_drawables, iter->data);
for (iter = tg_tool->preview_drawables; iter; iter = g_list_next (iter))
{
drawable = iter->data;
if (! g_hash_table_remove (new_drawables, drawable))
pika_transform_grid_tool_remove_filter (drawable, tg_tool);
}
g_hash_table_iter_init (&hash_iter, new_drawables);
while (g_hash_table_iter_next (&hash_iter, (gpointer *) &drawable, NULL))
{
AddFilterData data;
data.tg_tool = tg_tool;
data.root_drawable = drawable;
pika_transform_grid_tool_add_filter (drawable, &data);
}
g_hash_table_unref (new_drawables);
g_list_free (tg_tool->preview_drawables);
tg_tool->preview_drawables = drawables;
}
static void
pika_transform_grid_tool_hide_selected_objects (PikaTransformGridTool *tg_tool,
GList *objects)
{
PikaTransformGridOptions *options = PIKA_TRANSFORM_GRID_TOOL_GET_OPTIONS (tg_tool);
PikaTransformOptions *tr_options = PIKA_TRANSFORM_OPTIONS (options);
PikaDisplay *display = PIKA_TOOL (tg_tool)->display;
PikaImage *image = pika_display_get_image (display);
g_return_if_fail (tr_options->type != PIKA_TRANSFORM_TYPE_IMAGE ||
(g_list_length (objects) == 1 && PIKA_IS_IMAGE (objects->data)));
g_list_free (tg_tool->hidden_objects);
tg_tool->hidden_objects = NULL;
if (options->show_preview)
{
if (tr_options->type == PIKA_TRANSFORM_TYPE_IMAGE)
{
tg_tool->hidden_objects = g_list_copy (objects);
pika_display_shell_set_show_image (pika_display_get_shell (display),
FALSE);
}
else
{
/* hide only complete layers and channels, not layer masks */
GList *iter;
for (iter = objects; iter; iter = iter->next)
{
if (tr_options->type == PIKA_TRANSFORM_TYPE_LAYER &&
! options->composited_preview &&
PIKA_IS_DRAWABLE (iter->data) &&
! PIKA_IS_LAYER_MASK (iter->data) &&
pika_item_get_visible (iter->data) &&
pika_channel_is_empty (pika_image_get_mask (image)))
{
tg_tool->hidden_objects = g_list_prepend (tg_tool->hidden_objects, iter->data);
pika_item_set_visible (iter->data, FALSE, FALSE);
}
}
pika_projection_flush (pika_image_get_projection (image));
}
}
}
static void
pika_transform_grid_tool_show_selected_objects (PikaTransformGridTool *tg_tool)
{
if (tg_tool->hidden_objects)
{
PikaDisplay *display = PIKA_TOOL (tg_tool)->display;
PikaImage *image = pika_display_get_image (display);
GList *iter;
for (iter = tg_tool->hidden_objects; iter; iter = iter->next)
{
if (PIKA_IS_ITEM (iter->data))
{
pika_item_set_visible (PIKA_ITEM (iter->data), TRUE,
FALSE);
}
else
{
g_return_if_fail (PIKA_IS_IMAGE (iter->data));
pika_display_shell_set_show_image (pika_display_get_shell (display),
TRUE);
}
}
g_list_free (tg_tool->hidden_objects);
tg_tool->hidden_objects = NULL;
pika_image_flush (image);
}
}
static void
pika_transform_grid_tool_add_filter (PikaDrawable *drawable,
AddFilterData *data)
{
Filter *filter;
PikaLayerMode mode = PIKA_LAYER_MODE_NORMAL;
if (PIKA_IS_LAYER (drawable))
{
pika_layer_get_effective_mode (PIKA_LAYER (drawable),
&mode, NULL, NULL, NULL);
}
if (mode != PIKA_LAYER_MODE_PASS_THROUGH)
{
filter = filter_new (data->tg_tool, drawable, data->root_drawable, TRUE);
}
else
{
PikaContainer *container;
filter = filter_new (data->tg_tool, drawable, data->root_drawable, FALSE);
container = pika_viewable_get_children (PIKA_VIEWABLE (drawable));
pika_container_foreach (container,
(GFunc) pika_transform_grid_tool_add_filter,
data);
}
g_hash_table_insert (data->tg_tool->filters, drawable, filter);
if (PIKA_IS_LAYER (drawable))
{
PikaLayerMask *mask = pika_layer_get_mask (PIKA_LAYER (drawable));
if (mask)
pika_transform_grid_tool_add_filter (PIKA_DRAWABLE (mask), data);
}
}
static void
pika_transform_grid_tool_remove_filter (PikaDrawable *drawable,
PikaTransformGridTool *tg_tool)
{
Filter *filter = g_hash_table_lookup (tg_tool->filters, drawable);
if (PIKA_IS_LAYER (drawable))
{
PikaLayerMask *mask = pika_layer_get_mask (PIKA_LAYER (drawable));
if (mask)
pika_transform_grid_tool_remove_filter (PIKA_DRAWABLE (mask), tg_tool);
}
if (! filter->filter)
{
PikaContainer *container;
container = pika_viewable_get_children (PIKA_VIEWABLE (drawable));
pika_container_foreach (container,
(GFunc) pika_transform_grid_tool_remove_filter,
tg_tool);
}
g_hash_table_remove (tg_tool->filters, drawable);
}
static void
pika_transform_grid_tool_effective_mode_changed (PikaLayer *layer,
PikaTransformGridTool *tg_tool)
{
Filter *filter = g_hash_table_lookup (tg_tool->filters, layer);
PikaLayerMode mode;
gboolean old_pass_through;
gboolean new_pass_through;
pika_layer_get_effective_mode (layer, &mode, NULL, NULL, NULL);
old_pass_through = ! filter->filter;
new_pass_through = mode == PIKA_LAYER_MODE_PASS_THROUGH;
if (old_pass_through != new_pass_through)
{
AddFilterData data;
data.tg_tool = tg_tool;
data.root_drawable = filter->root_drawable;
pika_transform_grid_tool_remove_filter (PIKA_DRAWABLE (layer), tg_tool);
pika_transform_grid_tool_add_filter (PIKA_DRAWABLE (layer), &data);
pika_transform_grid_tool_update_preview (tg_tool);
}
}
static Filter *
filter_new (PikaTransformGridTool *tg_tool,
PikaDrawable *drawable,
PikaDrawable *root_drawable,
gboolean add_filter)
{
Filter *filter = g_slice_new0 (Filter);
GeglNode *node;
GeglNode *input_node;
GeglNode *output_node;
filter->tg_tool = tg_tool;
filter->drawable = drawable;
filter->root_drawable = root_drawable;
if (add_filter)
{
node = gegl_node_new ();
input_node = gegl_node_get_input_proxy (node, "input");
output_node = gegl_node_get_input_proxy (node, "output");
filter->transform_node = gegl_node_new_child (
node,
"operation", "gegl:transform",
"near-z", PIKA_TRANSFORM_NEAR_Z,
"sampler", GEGL_SAMPLER_NEAREST,
NULL);
filter->crop_node = gegl_node_new_child (
node,
"operation", "gegl:crop",
NULL);
gegl_node_link_many (input_node,
filter->transform_node,
filter->crop_node,
output_node,
NULL);
pika_gegl_node_set_underlying_operation (node, filter->transform_node);
filter->filter = pika_drawable_filter_new (
drawable,
PIKA_TRANSFORM_TOOL_GET_CLASS (tg_tool)->undo_desc,
node,
pika_tool_get_icon_name (PIKA_TOOL (tg_tool)));
pika_drawable_filter_set_clip (filter->filter, FALSE);
pika_drawable_filter_set_override_constraints (filter->filter, TRUE);
g_signal_connect (
filter->filter, "flush",
G_CALLBACK (pika_transform_grid_tool_filter_flush),
tg_tool);
g_object_unref (node);
}
if (PIKA_IS_GROUP_LAYER (drawable))
{
g_signal_connect (
drawable, "effective-mode-changed",
G_CALLBACK (pika_transform_grid_tool_effective_mode_changed),
tg_tool);
}
return filter;
}
static void
filter_free (Filter *filter)
{
if (filter->filter)
{
pika_drawable_filter_abort (filter->filter);
g_object_unref (filter->filter);
}
if (PIKA_IS_GROUP_LAYER (filter->drawable))
{
g_signal_handlers_disconnect_by_func (
filter->drawable,
pika_transform_grid_tool_effective_mode_changed,
filter->tg_tool);
}
g_slice_free (Filter, filter);
}
static UndoInfo *
undo_info_new (void)
{
return g_slice_new0 (UndoInfo);
}
static void
undo_info_free (UndoInfo *info)
{
g_slice_free (UndoInfo, info);
}
static gboolean
trans_info_equal (const TransInfo trans_info1,
const TransInfo trans_info2)
{
gint i;
for (i = 0; i < TRANS_INFO_SIZE; i++)
{
if (fabs (trans_info1[i] - trans_info2[i]) > EPSILON)
return FALSE;
}
return TRUE;
}
static gboolean
trans_infos_equal (const TransInfo *trans_infos1,
const TransInfo *trans_infos2)
{
return trans_info_equal (trans_infos1[PIKA_TRANSFORM_FORWARD],
trans_infos2[PIKA_TRANSFORM_FORWARD]) &&
trans_info_equal (trans_infos1[PIKA_TRANSFORM_BACKWARD],
trans_infos2[PIKA_TRANSFORM_BACKWARD]);
}
gboolean
pika_transform_grid_tool_info_to_matrix (PikaTransformGridTool *tg_tool,
PikaMatrix3 *transform)
{
g_return_val_if_fail (PIKA_IS_TRANSFORM_GRID_TOOL (tg_tool), FALSE);
g_return_val_if_fail (transform != NULL, FALSE);
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->info_to_matrix)
{
return PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->info_to_matrix (
tg_tool, transform);
}
return FALSE;
}
void
pika_transform_grid_tool_matrix_to_info (PikaTransformGridTool *tg_tool,
const PikaMatrix3 *transform)
{
g_return_if_fail (PIKA_IS_TRANSFORM_GRID_TOOL (tg_tool));
g_return_if_fail (transform != NULL);
if (PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->matrix_to_info)
{
return PIKA_TRANSFORM_GRID_TOOL_GET_CLASS (tg_tool)->matrix_to_info (
tg_tool, transform);
}
}
void
pika_transform_grid_tool_push_internal_undo (PikaTransformGridTool *tg_tool,
gboolean compress)
{
UndoInfo *undo_info;
g_return_if_fail (PIKA_IS_TRANSFORM_GRID_TOOL (tg_tool));
g_return_if_fail (tg_tool->undo_list != NULL);
undo_info = tg_tool->undo_list->data;
/* push current state on the undo list and set this state as the
* current state, but avoid doing this if there were no changes
*/
if (! trans_infos_equal (undo_info->trans_infos, tg_tool->trans_infos))
{
PikaTransformOptions *tr_options = PIKA_TRANSFORM_TOOL_GET_OPTIONS (tg_tool);
gint64 time = 0;
gboolean flush = FALSE;
if (tg_tool->undo_list->next == NULL)
flush = TRUE;
if (compress)
time = g_get_monotonic_time ();
if (! compress || time - undo_info->time >= UNDO_COMPRESS_TIME)
{
undo_info = undo_info_new ();
tg_tool->undo_list = g_list_prepend (tg_tool->undo_list, undo_info);
}
undo_info->time = time;
undo_info->direction = tr_options->direction;
memcpy (undo_info->trans_infos, tg_tool->trans_infos,
sizeof (tg_tool->trans_infos));
/* If we undid anything and started interacting, we have to
* discard the redo history
*/
if (tg_tool->redo_list)
{
g_list_free_full (tg_tool->redo_list,
(GDestroyNotify) undo_info_free);
tg_tool->redo_list = NULL;
flush = TRUE;
}
pika_transform_grid_tool_update_sensitivity (tg_tool);
/* update the undo actions / menu items */
if (flush)
{
pika_image_flush (
pika_display_get_image (PIKA_TOOL (tg_tool)->display));
}
}
}