| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Gimp/app/display/ (Gimp Bildeditor Version 3.2.0©) Datei vom 14.2.2026 mit Größe 87 kB |
|
Quelle gimptooltransformgrid.c Sprache: C |
|||||||||||||||||||||||||
|
/* GIMP - The GNU Image Manipulation Program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * gimptooltransformgrid.c * Copyright (C) 2017 Michael Natterer <mitch@gimp.org> * * Based on GimpUnifiedTransformTool * Copyright (C) 2011 Mikael Magnusson <mikachu@src.gnome.org> * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <https://www.gnu.org/licenses/>. */ #include "config.h" #include <gegl.h> #include <gtk/gtk.h> #include "libgimpbase/gimpbase.h" #include "libgimpmath/gimpmath.h" #include "display-types.h" #include "core/gimp-transform-utils.h" #include "core/gimp-utils.h" #include "widgets/gimpwidgets-utils.h" #include "gimpcanvashandle.h" #include "gimpcanvastransformguides.h" #include "gimpdisplayshell.h" #include "gimptooltransformgrid.h" #include "gimp-intl.h" #define MIN_HANDLE_SIZE 6 enum { PROP_0, PROP_TRANSFORM, PROP_X1, PROP_Y1, PROP_X2, PROP_Y2, PROP_PIVOT_X, PROP_PIVOT_Y, PROP_GUIDE_TYPE, PROP_N_GUIDES, PROP_CLIP_GUIDES, PROP_SHOW_GUIDES, PROP_INSIDE_FUNCTION, PROP_OUTSIDE_FUNCTION, PROP_USE_CORNER_HANDLES, PROP_USE_PERSPECTIVE_HANDLES, PROP_USE_SIDE_HANDLES, PROP_USE_SHEAR_HANDLES, PROP_USE_CENTER_HANDLE, PROP_USE_PIVOT_HANDLE, PROP_DYNAMIC_HANDLE_SIZE, PROP_CONSTRAIN_MOVE, PROP_CONSTRAIN_SCALE, PROP_CONSTRAIN_ROTATE, PROP_CONSTRAIN_SHEAR, PROP_CONSTRAIN_PERSPECTIVE, PROP_FROMPIVOT_SCALE, PROP_FROMPIVOT_SHEAR, PROP_FROMPIVOT_PERSPECTIVE, PROP_CORNERSNAP, PROP_FIXEDPIVOT }; struct _GimpToolTransformGridPrivate { GimpMatrix3 transform; gdouble x1, y1; gdouble x2, y2; gdouble pivot_x; gdouble pivot_y; GimpGuidesType guide_type; gint n_guides; gboolean clip_guides; gboolean show_guides; GimpTransformFunction inside_function; GimpTransformFunction outside_function; gboolean use_corner_handles; gboolean use_perspective_handles; gboolean use_side_handles; gboolean use_shear_handles; gboolean use_center_handle; gboolean use_pivot_handle; gboolean dynamic_handle_size; gboolean constrain_move; gboolean constrain_scale; gboolean constrain_rotate; gboolean constrain_shear; gboolean constrain_perspective; gboolean frompivot_scale; gboolean frompivot_shear; gboolean frompivot_perspective; gboolean cornersnap; gboolean fixedpivot; gdouble curx; /* current x coord */ gdouble cury; /* current y coord */ gdouble button_down; /* is the mouse button pressed */ gdouble mousex; /* x coord where mouse was clicked */ gdouble mousey; /* y coord where mouse was clicked */ gdouble cx, cy; /* center point (for moving) */ /* transformed handle coords */ gdouble tx1, ty1; gdouble tx2, ty2; gdouble tx3, ty3; gdouble tx4, ty4; gdouble tcx, tcy; gdouble tpx, tpy; /* previous transformed handle coords */ gdouble prev_tx1, prev_ty1; gdouble prev_tx2, prev_ty2; gdouble prev_tx3, prev_ty3; gdouble prev_tx4, prev_ty4; gdouble prev_tcx, prev_tcy; gdouble prev_tpx, prev_tpy; GimpTransformHandle handle; /* current tool activity */ GimpCanvasItem *guides; GimpCanvasItem *handles[GIMP_N_TRANSFORM_HANDLES]; GimpCanvasItem *center_items[2]; GimpCanvasItem *pivot_items[2]; }; /* local function prototypes */ static void gimp_tool_transform_grid_constructed (GObject *object); static void gimp_tool_transform_grid_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec); static void gimp_tool_transform_grid_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); static void gimp_tool_transform_grid_changed (GimpToolWidget *widget); static gint gimp_tool_transform_grid_button_press (GimpToolWidget *widget, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type); static void gimp_tool_transform_grid_button_release (GimpToolWidget *widget, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type); static void gimp_tool_transform_grid_motion (GimpToolWidget *widget, const GimpCoords *coords, guint32 time, GdkModifierType state); static GimpHit gimp_tool_transform_grid_hit (GimpToolWidget *widget, const GimpCoords *coords, GdkModifierType state, gboolean proximity); static void gimp_tool_transform_grid_hover (GimpToolWidget *widget, const GimpCoords *coords, GdkModifierType state, gboolean proximity); static void gimp_tool_transform_grid_leave_notify (GimpToolWidget *widget); static void gimp_tool_transform_grid_hover_modifier (GimpToolWidget *widget, GdkModifierType key, gboolean press, GdkModifierType state); static gboolean gimp_tool_transform_grid_get_cursor (GimpToolWidget *widget, const GimpCoords *coords, GdkModifierType state, GimpCursorType *cursor, GimpToolCursorType *tool_cursor, GimpCursorModifier *modifier); static GimpTransformHandle gimp_tool_transform_grid_get_handle_for_coords (GimpToolTransformGrid *grid, const GimpCoords *coords); static void gimp_tool_transform_grid_update_hilight (GimpToolTransformGrid *grid); static void gimp_tool_transform_grid_update_box (GimpToolTransformGrid *grid); static void gimp_tool_transform_grid_update_matrix (GimpToolTransformGrid *grid); static void gimp_tool_transform_grid_calc_handles (GimpToolTransformGrid *grid, gint *handle_w, gint *handle_h); G_DEFINE_TYPE_WITH_PRIVATE (GimpToolTransformGrid, gimp_tool_transform_grid, GIMP_TYPE_TOOL_WIDGET) #define parent_class gimp_tool_transform_grid_parent_class static void gimp_tool_transform_grid_class_init (GimpToolTransformGridClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GimpToolWidgetClass *widget_class = GIMP_TOOL_WIDGET_CLASS (klass); object_class->constructed = gimp_tool_transform_grid_constructed; object_class->set_property = gimp_tool_transform_grid_set_property; object_class->get_property = gimp_tool_transform_grid_get_property; widget_class->changed = gimp_tool_transform_grid_changed; widget_class->button_press = gimp_tool_transform_grid_button_press; widget_class->button_release = gimp_tool_transform_grid_button_release; widget_class->motion = gimp_tool_transform_grid_motion; widget_class->hit = gimp_tool_transform_grid_hit; widget_class->hover = gimp_tool_transform_grid_hover; widget_class->leave_notify = gimp_tool_transform_grid_leave_notify; widget_class->hover_modifier = gimp_tool_transform_grid_hover_modifier; widget_class->get_cursor = gimp_tool_transform_grid_get_cursor; widget_class->update_on_scale = TRUE; g_object_class_install_property (object_class, PROP_TRANSFORM, gimp_param_spec_matrix3 ("transform", NULL, NULL, NULL, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_X1, g_param_spec_double ("x1", NULL, NULL, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0.0, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_Y1, g_param_spec_double ("y1", NULL, NULL, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0.0, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_X2, g_param_spec_double ("x2", NULL, NULL, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0.0, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_Y2, g_param_spec_double ("y2", NULL, NULL, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0.0, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_PIVOT_X, g_param_spec_double ("pivot-x", NULL, NULL, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0.0, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_PIVOT_Y, g_param_spec_double ("pivot-y", NULL, NULL, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0.0, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_GUIDE_TYPE, g_param_spec_enum ("guide-type", NULL, NULL, GIMP_TYPE_GUIDES_TYPE, GIMP_GUIDES_NONE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_N_GUIDES, g_param_spec_int ("n-guides", NULL, NULL, 1, 128, 4, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_CLIP_GUIDES, g_param_spec_boolean ("clip-guides", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_SHOW_GUIDES, g_param_spec_boolean ("show-guides", NULL, NULL, TRUE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_INSIDE_FUNCTION, g_param_spec_enum ("inside-function", NULL, NULL, GIMP_TYPE_TRANSFORM_FUNCTION, GIMP_TRANSFORM_FUNCTION_MOVE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_OUTSIDE_FUNCTION, g_param_spec_enum ("outside-function", NULL, NULL, GIMP_TYPE_TRANSFORM_FUNCTION, GIMP_TRANSFORM_FUNCTION_ROTATE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_USE_CORNER_HANDLES, g_param_spec_boolean ("use-corner-handles", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_USE_PERSPECTIVE_HANDLES, g_param_spec_boolean ("use-perspective-handles", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_USE_SIDE_HANDLES, g_param_spec_boolean ("use-side-handles", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_USE_SHEAR_HANDLES, g_param_spec_boolean ("use-shear-handles", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_USE_CENTER_HANDLE, g_param_spec_boolean ("use-center-handle", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_USE_PIVOT_HANDLE, g_param_spec_boolean ("use-pivot-handle", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_DYNAMIC_HANDLE_SIZE, g_param_spec_boolean ("dynamic-handle-size", NULL, NULL, TRUE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_CONSTRAIN_MOVE, g_param_spec_boolean ("constrain-move", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_CONSTRAIN_SCALE, g_param_spec_boolean ("constrain-scale", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_CONSTRAIN_ROTATE, g_param_spec_boolean ("constrain-rotate", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_CONSTRAIN_SHEAR, g_param_spec_boolean ("constrain-shear", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_CONSTRAIN_PERSPECTIVE, g_param_spec_boolean ("constrain-perspective", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_FROMPIVOT_SCALE, g_param_spec_boolean ("frompivot-scale", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_FROMPIVOT_SHEAR, g_param_spec_boolean ("frompivot-shear", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_FROMPIVOT_PERSPECTIVE, g_param_spec_boolean ("frompivot-perspective", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_CORNERSNAP, g_param_spec_boolean ("cornersnap", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (object_class, PROP_FIXEDPIVOT, g_param_spec_boolean ("fixedpivot", NULL, NULL, FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); } static void gimp_tool_transform_grid_init (GimpToolTransformGrid *grid) { grid->private = gimp_tool_transform_grid_get_instance_private (grid); } static void gimp_tool_transform_grid_constructed (GObject *object) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (object); GimpToolWidget *widget = GIMP_TOOL_WIDGET (object); GimpToolTransformGridPrivate *private = grid->private; GimpCanvasGroup *stroke_group; gint i; G_OBJECT_CLASS (parent_class)->constructed (object); private->guides = gimp_tool_widget_add_transform_guides (widget, &private->transform, private->x1, private->y1, private->x2, private->y2, private->guide_type, private->n_guides, private->clip_guides); for (i = 0; i < 4; i++) { /* draw the scale handles */ private->handles[GIMP_TRANSFORM_HANDLE_NW + i] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_SQUARE, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); /* draw the perspective handles */ private->handles[GIMP_TRANSFORM_HANDLE_NW_P + i] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_DIAMOND, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); /* draw the side handles */ private->handles[GIMP_TRANSFORM_HANDLE_N + i] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_SQUARE, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); /* draw the shear handles */ private->handles[GIMP_TRANSFORM_HANDLE_N_S + i] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_FILLED_DIAMOND, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); } /* draw the rotation center axis handle */ stroke_group = gimp_tool_widget_add_stroke_group (widget); private->handles[GIMP_TRANSFORM_HANDLE_PIVOT] = GIMP_CANVAS_ITEM (stroke_group); gimp_tool_widget_push_group (widget, stroke_group); private->pivot_items[0] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_CIRCLE, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); private->pivot_items[1] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_CROSS, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); gimp_tool_widget_pop_group (widget); /* draw the center handle */ stroke_group = gimp_tool_widget_add_stroke_group (widget); private->handles[GIMP_TRANSFORM_HANDLE_CENTER] = GIMP_CANVAS_ITEM (stroke_group); gimp_tool_widget_push_group (widget, stroke_group); private->center_items[0] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_SQUARE, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); private->center_items[1] = gimp_tool_widget_add_handle (widget, GIMP_HANDLE_CROSS, 0, 0, 10, 10, GIMP_HANDLE_ANCHOR_CENTER); gimp_tool_widget_pop_group (widget); gimp_tool_transform_grid_changed (widget); } static void gimp_tool_transform_grid_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (object); GimpToolTransformGridPrivate *private = grid->private; gboolean box = FALSE; switch (property_id) { case PROP_TRANSFORM: { GimpMatrix3 *transform = g_value_get_boxed (value); if (transform) private->transform = *transform; else gimp_matrix3_identity (&private->transform); } break; case PROP_X1: private->x1 = g_value_get_double (value); box = TRUE; break; case PROP_Y1: private->y1 = g_value_get_double (value); box = TRUE; break; case PROP_X2: private->x2 = g_value_get_double (value); box = TRUE; break; case PROP_Y2: private->y2 = g_value_get_double (value); box = TRUE; break; case PROP_PIVOT_X: private->pivot_x = g_value_get_double (value); break; case PROP_PIVOT_Y: private->pivot_y = g_value_get_double (value); break; case PROP_GUIDE_TYPE: private->guide_type = g_value_get_enum (value); break; case PROP_N_GUIDES: private->n_guides = g_value_get_int (value); break; case PROP_CLIP_GUIDES: private->clip_guides = g_value_get_boolean (value); break; case PROP_SHOW_GUIDES: private->show_guides = g_value_get_boolean (value); break; case PROP_INSIDE_FUNCTION: private->inside_function = g_value_get_enum (value); break; case PROP_OUTSIDE_FUNCTION: private->outside_function = g_value_get_enum (value); break; case PROP_USE_CORNER_HANDLES: private->use_corner_handles = g_value_get_boolean (value); break; case PROP_USE_PERSPECTIVE_HANDLES: private->use_perspective_handles = g_value_get_boolean (value); break; case PROP_USE_SIDE_HANDLES: private->use_side_handles = g_value_get_boolean (value); break; case PROP_USE_SHEAR_HANDLES: private->use_shear_handles = g_value_get_boolean (value); break; case PROP_USE_CENTER_HANDLE: private->use_center_handle = g_value_get_boolean (value); break; case PROP_USE_PIVOT_HANDLE: private->use_pivot_handle = g_value_get_boolean (value); break; case PROP_DYNAMIC_HANDLE_SIZE: private->dynamic_handle_size = g_value_get_boolean (value); break; case PROP_CONSTRAIN_MOVE: private->constrain_move = g_value_get_boolean (value); break; case PROP_CONSTRAIN_SCALE: private->constrain_scale = g_value_get_boolean (value); break; case PROP_CONSTRAIN_ROTATE: private->constrain_rotate = g_value_get_boolean (value); break; case PROP_CONSTRAIN_SHEAR: private->constrain_shear = g_value_get_boolean (value); break; case PROP_CONSTRAIN_PERSPECTIVE: private->constrain_perspective = g_value_get_boolean (value); break; case PROP_FROMPIVOT_SCALE: private->frompivot_scale = g_value_get_boolean (value); break; case PROP_FROMPIVOT_SHEAR: private->frompivot_shear = g_value_get_boolean (value); break; case PROP_FROMPIVOT_PERSPECTIVE: private->frompivot_perspective = g_value_get_boolean (value); break; case PROP_CORNERSNAP: private->cornersnap = g_value_get_boolean (value); break; case PROP_FIXEDPIVOT: private->fixedpivot = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } if (box) { private->cx = (private->x1 + private->x2) / 2.0; private->cy = (private->y1 + private->y2) / 2.0; } } static void gimp_tool_transform_grid_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (object); GimpToolTransformGridPrivate *private = grid->private; switch (property_id) { case PROP_TRANSFORM: g_value_set_boxed (value, &private->transform); break; case PROP_X1: g_value_set_double (value, private->x1); break; case PROP_Y1: g_value_set_double (value, private->y1); break; case PROP_X2: g_value_set_double (value, private->x2); break; case PROP_Y2: g_value_set_double (value, private->y2); break; case PROP_PIVOT_X: g_value_set_double (value, private->pivot_x); break; case PROP_PIVOT_Y: g_value_set_double (value, private->pivot_y); break; case PROP_GUIDE_TYPE: g_value_set_enum (value, private->guide_type); break; case PROP_N_GUIDES: g_value_set_int (value, private->n_guides); break; case PROP_CLIP_GUIDES: g_value_set_boolean (value, private->clip_guides); break; case PROP_SHOW_GUIDES: g_value_set_boolean (value, private->show_guides); break; case PROP_INSIDE_FUNCTION: g_value_set_enum (value, private->inside_function); break; case PROP_OUTSIDE_FUNCTION: g_value_set_enum (value, private->outside_function); break; case PROP_USE_CORNER_HANDLES: g_value_set_boolean (value, private->use_corner_handles); break; case PROP_USE_PERSPECTIVE_HANDLES: g_value_set_boolean (value, private->use_perspective_handles); break; case PROP_USE_SIDE_HANDLES: g_value_set_boolean (value, private->use_side_handles); break; case PROP_USE_SHEAR_HANDLES: g_value_set_boolean (value, private->use_shear_handles); break; case PROP_USE_CENTER_HANDLE: g_value_set_boolean (value, private->use_center_handle); break; case PROP_USE_PIVOT_HANDLE: g_value_set_boolean (value, private->use_pivot_handle); break; case PROP_DYNAMIC_HANDLE_SIZE: g_value_set_boolean (value, private->dynamic_handle_size); break; case PROP_CONSTRAIN_MOVE: g_value_set_boolean (value, private->constrain_move); break; case PROP_CONSTRAIN_SCALE: g_value_set_boolean (value, private->constrain_scale); break; case PROP_CONSTRAIN_ROTATE: g_value_set_boolean (value, private->constrain_rotate); break; case PROP_CONSTRAIN_SHEAR: g_value_set_boolean (value, private->constrain_shear); break; case PROP_CONSTRAIN_PERSPECTIVE: g_value_set_boolean (value, private->constrain_perspective); break; case PROP_FROMPIVOT_SCALE: g_value_set_boolean (value, private->frompivot_scale); break; case PROP_FROMPIVOT_SHEAR: g_value_set_boolean (value, private->frompivot_shear); break; case PROP_FROMPIVOT_PERSPECTIVE: g_value_set_boolean (value, private->frompivot_perspective); break; case PROP_CORNERSNAP: g_value_set_boolean (value, private->cornersnap); break; case PROP_FIXEDPIVOT: g_value_set_boolean (value, private->fixedpivot); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static gboolean transform_is_convex (GimpVector2 *pos) { return gimp_transform_polygon_is_convex (pos[0].x, pos[0].y, pos[1].x, pos[1].y, pos[2].x, pos[2].y, pos[3].x, pos[3].y); } static gboolean transform_grid_is_convex (GimpToolTransformGrid *grid) { GimpToolTransformGridPrivate *private = grid->private; return gimp_transform_polygon_is_convex (private->tx1, private->ty1, private->tx2, private->ty2, private->tx3, private->ty3, private->tx4, private->ty4); } static inline gboolean vectorisnull (GimpVector2 v) { return ((v.x == 0.0) && (v.y == 0.0)); } static inline gdouble dotprod (GimpVector2 a, GimpVector2 b) { return a.x * b.x + a.y * b.y; } static inline gdouble norm (GimpVector2 a) { return sqrt (dotprod (a, a)); } static inline GimpVector2 vectorsubtract (GimpVector2 a, GimpVector2 b) { GimpVector2 c; c.x = a.x - b.x; c.y = a.y - b.y; return c; } static inline GimpVector2 vectoradd (GimpVector2 a, GimpVector2 b) { GimpVector2 c; c.x = a.x + b.x; c.y = a.y + b.y; return c; } static inline GimpVector2 scalemult (GimpVector2 a, gdouble b) { GimpVector2 c; c.x = a.x * b; c.y = a.y * b; return c; } static inline GimpVector2 vectorproject (GimpVector2 a, GimpVector2 b) { return scalemult (b, dotprod (a, b) / dotprod (b, b)); } /* finds the clockwise angle between the vectors given, 0-2π */ static inline gdouble calcangle (GimpVector2 a, GimpVector2 b) { gdouble angle, angle2; gdouble length; if (vectorisnull (a) || vectorisnull (b)) return 0.0; length = norm (a) * norm (b); angle = acos (SAFE_CLAMP (dotprod (a, b) / length, -1.0, +1.0)); angle2 = b.y; b.y = -b.x; b.x = angle2; angle2 = acos (SAFE_CLAMP (dotprod (a, b) / length, -1.0, +1.0)); return ((angle2 > G_PI / 2.0) ? angle : 2.0 * G_PI - angle); } static inline GimpVector2 rotate2d (GimpVector2 p, gdouble angle) { GimpVector2 ret; ret.x = cos (angle) * p.x-sin (angle) * p.y; ret.y = sin (angle) * p.x+cos (angle) * p.y; return ret; } static inline GimpVector2 lineintersect (GimpVector2 p1, GimpVector2 p2, GimpVector2 q1, GimpVector2 q2) { gdouble denom, u; GimpVector2 p; denom = (q2.y - q1.y) * (p2.x - p1.x) - (q2.x - q1.x) * (p2.y - p1.y); if (denom == 0.0) { p.x = (p1.x + p2.x + q1.x + q2.x) / 4; p.y = (p1.y + p2.y + q1.y + q2.y) / 4; } else { u = (q2.x - q1.x) * (p1.y - q1.y) - (q2.y - q1.y) * (p1.x - q1.x); u /= denom; p.x = p1.x + u * (p2.x - p1.x); p.y = p1.y + u * (p2.y - p1.y); } return p; } static inline GimpVector2 get_pivot_delta (GimpToolTransformGrid *grid, GimpVector2 *oldpos, GimpVector2 *newpos, GimpVector2 pivot) { GimpToolTransformGridPrivate *private = grid->private; GimpMatrix3 transform_before; GimpMatrix3 transform_after; GimpVector2 delta; gimp_matrix3_identity (&transform_before); gimp_matrix3_identity (&transform_after); gimp_transform_matrix_perspective (&transform_before, private->x1, private->y1, private->x2 - private->x1, private->y2 - private->y1, oldpos[0].x, oldpos[0].y, oldpos[1].x, oldpos[1].y, oldpos[2].x, oldpos[2].y, oldpos[3].x, oldpos[3].y); gimp_transform_matrix_perspective (&transform_after, private->x1, private->y1, private->x2 - private->x1, private->y2 - private->y1, newpos[0].x, newpos[0].y, newpos[1].x, newpos[1].y, newpos[2].x, newpos[2].y, newpos[3].x, newpos[3].y); gimp_matrix3_invert (&transform_before); gimp_matrix3_mult (&transform_after, &transform_before); gimp_matrix3_transform_point (&transform_before, pivot.x, pivot.y, &delta.x, &delta.y); delta = vectorsubtract (delta, pivot); return delta; } static gboolean point_is_inside_polygon (gint n, gdouble *x, gdouble *y, gdouble px, gdouble py) { gint i, j; gboolean odd = FALSE; for (i = 0, j = n - 1; i < n; j = i++) { if ((y[i] < py && y[j] >= py) || (y[j] < py && y[i] >= py)) { if (x[i] + (py - y[i]) / (y[j] - y[i]) * (x[j] - x[i]) < px) odd = !odd; } } return odd; } static gboolean point_is_inside_polygon_pos (GimpVector2 *pos, GimpVector2 point) { return point_is_inside_polygon (4, (gdouble[4]){ pos[0].x, pos[1].x, pos[3].x, pos[2].x }, (gdouble[4]){ pos[0].y, pos[1].y, pos[3].y, pos[2].y }, point.x, point.y); } static void get_handle_geometry (GimpToolTransformGrid *grid, GimpVector2 *position, gdouble *angle) { GimpToolTransformGridPrivate *private = grid->private; GimpVector2 o[] = { { .x = private->tx1, .y = private->ty1 }, { .x = private->tx2, .y = private->ty2 }, { .x = private->tx3, .y = private->ty3 }, { .x = private->tx4, .y = private->ty4 } }; GimpVector2 right = { .x = 1.0, .y = 0.0 }; GimpVector2 up = { .x = 0.0, .y = 1.0 }; if (position) { position[0] = o[0]; position[1] = o[1]; position[2] = o[2]; position[3] = o[3]; } angle[0] = calcangle (vectorsubtract (o[1], o[0]), right); angle[1] = calcangle (vectorsubtract (o[3], o[2]), right); angle[2] = calcangle (vectorsubtract (o[3], o[1]), up); angle[3] = calcangle (vectorsubtract (o[2], o[0]), up); angle[4] = (angle[0] + angle[3]) / 2.0; angle[5] = (angle[0] + angle[2]) / 2.0; angle[6] = (angle[1] + angle[3]) / 2.0; angle[7] = (angle[1] + angle[2]) / 2.0; angle[8] = (angle[0] + angle[1] + angle[2] + angle[3]) / 4.0; } static void gimp_tool_transform_grid_changed (GimpToolWidget *widget) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; gdouble angle[9]; GimpVector2 o[4], t[4]; gint handle_w; gint handle_h; gint d, i; gimp_tool_transform_grid_update_box (grid); gimp_canvas_transform_guides_set (private->guides, &private->transform, private->x1, private->y1, private->x2, private->y2, private->guide_type, private->n_guides, private->clip_guides); gimp_canvas_item_set_visible (private->guides, private->show_guides); get_handle_geometry (grid, o, angle); gimp_tool_transform_grid_calc_handles (grid, &handle_w, &handle_h); for (i = 0; i < 4; i++) { GimpCanvasItem *h; gdouble factor; /* the scale handles */ factor = 1.0; if (private->use_perspective_handles) factor = 1.5; h = private->handles[GIMP_TRANSFORM_HANDLE_NW + i]; gimp_canvas_item_set_visible (h, private->use_corner_handles); if (private->use_corner_handles) { gimp_canvas_handle_set_position (h, o[i].x, o[i].y); gimp_canvas_handle_set_size (h, handle_w * factor, handle_h * factor); gimp_canvas_handle_set_angles (h, angle[i + 4], 0.0); } /* the perspective handles */ factor = 1.0; if (private->use_corner_handles) factor = 0.8; h = private->handles[GIMP_TRANSFORM_HANDLE_NW_P + i]; gimp_canvas_item_set_visible (h, private->use_perspective_handles); if (private->use_perspective_handles) { gimp_canvas_handle_set_position (h, o[i].x, o[i].y); gimp_canvas_handle_set_size (h, handle_w * factor, handle_h * factor); gimp_canvas_handle_set_angles (h, angle[i + 4], 0.0); } } /* draw the side handles */ t[0] = scalemult (vectoradd (o[0], o[1]), 0.5); t[1] = scalemult (vectoradd (o[2], o[3]), 0.5); t[2] = scalemult (vectoradd (o[1], o[3]), 0.5); t[3] = scalemult (vectoradd (o[2], o[0]), 0.5); for (i = 0; i < 4; i++) { GimpCanvasItem *h; h = private->handles[GIMP_TRANSFORM_HANDLE_N + i]; gimp_canvas_item_set_visible (h, private->use_side_handles); if (private->use_side_handles) { gimp_canvas_handle_set_position (h, t[i].x, t[i].y); gimp_canvas_handle_set_size (h, handle_w, handle_h); gimp_canvas_handle_set_angles (h, angle[i], 0.0); } } /* draw the shear handles */ t[0] = scalemult (vectoradd ( o[0] , scalemult (o[1], 3.0)), 0.25); t[1] = scalemult (vectoradd (scalemult (o[2], 3.0), o[3] ), 0.25); t[2] = scalemult (vectoradd ( o[1] , scalemult (o[3], 3.0)), 0.25); t[3] = scalemult (vectoradd (scalemult (o[0], 3.0), o[2] ), 0.25); for (i = 0; i < 4; i++) { GimpCanvasItem *h; h = private->handles[GIMP_TRANSFORM_HANDLE_N_S + i]; gimp_canvas_item_set_visible (h, private->use_shear_handles); if (private->use_shear_handles) { gimp_canvas_handle_set_position (h, t[i].x, t[i].y); gimp_canvas_handle_set_size (h, handle_w, handle_h); gimp_canvas_handle_set_angles (h, angle[i], 0.0); } } d = MIN (handle_w, handle_h); if (private->use_center_handle) d *= 2; /* so you can grab it from under the center handle */ gimp_canvas_item_set_visible (private->handles[GIMP_TRANSFORM_HANDLE_PIVOT], private->use_pivot_handle); if (private->use_pivot_handle) { gimp_canvas_handle_set_position (private->pivot_items[0], private->tpx, private->tpy); gimp_canvas_handle_set_size (private->pivot_items[0], d, d); gimp_canvas_handle_set_position (private->pivot_items[1], private->tpx, private->tpy); gimp_canvas_handle_set_size (private->pivot_items[1], d, d); } d = MIN (handle_w, handle_h); gimp_canvas_item_set_visible (private->handles[GIMP_TRANSFORM_HANDLE_CENTER], private->use_center_handle); if (private->use_center_handle) { gimp_canvas_handle_set_position (private->center_items[0], private->tcx, private->tcy); gimp_canvas_handle_set_size (private->center_items[0], d, d); gimp_canvas_handle_set_angles (private->center_items[0], angle[8], 0.0); gimp_canvas_handle_set_position (private->center_items[1], private->tcx, private->tcy); gimp_canvas_handle_set_size (private->center_items[1], d, d); gimp_canvas_handle_set_angles (private->center_items[1], angle[8], 0.0); } gimp_tool_transform_grid_update_hilight (grid); } gint gimp_tool_transform_grid_button_press (GimpToolWidget *widget, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; private->button_down = TRUE; private->mousex = coords->x; private->mousey = coords->y; if (private->handle != GIMP_TRANSFORM_HANDLE_NONE) { if (private->handles[private->handle]) { GimpCanvasItem *handle; gdouble x, y; switch (private->handle) { case GIMP_TRANSFORM_HANDLE_CENTER: handle = private->center_items[0]; break; case GIMP_TRANSFORM_HANDLE_PIVOT: handle = private->pivot_items[0]; break; default: handle = private->handles[private->handle]; break; } gimp_canvas_handle_get_position (handle, &x, &y); gimp_tool_widget_set_snap_offsets (widget, SIGNED_ROUND (x - coords->x), SIGNED_ROUND (y - coords->y), 0, 0); } else { gimp_tool_widget_set_snap_offsets (widget, 0, 0, 0, 0); } private->prev_tx1 = private->tx1; private->prev_ty1 = private->ty1; private->prev_tx2 = private->tx2; private->prev_ty2 = private->ty2; private->prev_tx3 = private->tx3; private->prev_ty3 = private->ty3; private->prev_tx4 = private->tx4; private->prev_ty4 = private->ty4; private->prev_tpx = private->tpx; private->prev_tpy = private->tpy; private->prev_tcx = private->tcx; private->prev_tcy = private->tcy; return private->handle; } gimp_tool_widget_set_snap_offsets (widget, 0, 0, 0, 0); return 0; } void gimp_tool_transform_grid_button_release (GimpToolWidget *widget, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; private->button_down = FALSE; } void gimp_tool_transform_grid_motion (GimpToolWidget *widget, const GimpCoords *coords, guint32 time, GdkModifierType state) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; gdouble *x[4], *y[4]; gdouble *newpivot_x, *newpivot_y; GimpVector2 oldpos[5], newpos[4]; GimpVector2 cur = { .x = coords->x, .y = coords->y }; GimpVector2 mouse = { .x = private->mousex, .y = private->mousey }; GimpVector2 d; GimpVector2 pivot; gboolean fixedpivot = private->fixedpivot; GimpTransformHandle handle = private->handle; gint i; private->curx = coords->x; private->cury = coords->y; x[0] = &private->tx1; y[0] = &private->ty1; x[1] = &private->tx2; y[1] = &private->ty2; x[2] = &private->tx3; y[2] = &private->ty3; x[3] = &private->tx4; y[3] = &private->ty4; newpos[0].x = oldpos[0].x = private->prev_tx1; newpos[0].y = oldpos[0].y = private->prev_ty1; newpos[1].x = oldpos[1].x = private->prev_tx2; newpos[1].y = oldpos[1].y = private->prev_ty2; newpos[2].x = oldpos[2].x = private->prev_tx3; newpos[2].y = oldpos[2].y = private->prev_ty3; newpos[3].x = oldpos[3].x = private->prev_tx4; newpos[3].y = oldpos[3].y = private->prev_ty4; /* put center point in this array too */ oldpos[4].x = private->prev_tcx; oldpos[4].y = private->prev_tcy; d = vectorsubtract (cur, mouse); newpivot_x = &private->tpx; newpivot_y = &private->tpy; if (private->use_pivot_handle) { pivot.x = private->prev_tpx; pivot.y = private->prev_tpy; } else { /* when the transform grid doesn't use a pivot handle, use the center * point as the pivot instead. */ pivot.x = private->prev_tcx; pivot.y = private->prev_tcy; fixedpivot = TRUE; } /* move */ if (handle == GIMP_TRANSFORM_HANDLE_CENTER) { if (private->constrain_move) { /* snap to 45 degree vectors from starting point */ gdouble angle = 16.0 * calcangle ((GimpVector2) { 1.0, 0.0 }, d) / (2.0 * G_PI); gdouble dist = norm (d) / sqrt (2); if (angle < 1.0 || angle >= 15.0) d.y = 0; else if (angle < 3.0) d.y = -(d.x = dist); else if (angle < 5.0) d.x = 0; else if (angle < 7.0) d.x = d.y = -dist; else if (angle < 9.0) d.y = 0; else if (angle < 11.0) d.x = -(d.y = dist); else if (angle < 13.0) d.x = 0; else if (angle < 15.0) d.x = d.y = dist; } for (i = 0; i < 4; i++) newpos[i] = vectoradd (oldpos[i], d); } /* rotate */ if (handle == GIMP_TRANSFORM_HANDLE_ROTATION) { gdouble angle = calcangle (vectorsubtract (cur, pivot), vectorsubtract (mouse, pivot)); if (private->constrain_rotate) { /* round to 15 degree multiple */ angle /= 2 * G_PI / 24.0; angle = round (angle); angle *= 2 * G_PI / 24.0; } for (i = 0; i < 4; i++) newpos[i] = vectoradd (pivot, rotate2d (vectorsubtract (oldpos[i], pivot), angle)); fixedpivot = TRUE; } /* move rotation axis */ if (handle == GIMP_TRANSFORM_HANDLE_PIVOT) { pivot = vectoradd (pivot, d); if (private->cornersnap) { /* snap to corner points and center */ gint closest = 0; gdouble closest_dist = G_MAXDOUBLE, dist; for (i = 0; i < 5; i++) { dist = norm (vectorsubtract (pivot, oldpos[i])); if (dist < closest_dist) { closest_dist = dist; closest = i; } } if (closest_dist * gimp_tool_widget_get_shell (widget)->scale_x < 50) { pivot = oldpos[closest]; } } fixedpivot = TRUE; } /* scaling via corner */ if (handle == GIMP_TRANSFORM_HANDLE_NW || handle == GIMP_TRANSFORM_HANDLE_NE || handle == GIMP_TRANSFORM_HANDLE_SE || handle == GIMP_TRANSFORM_HANDLE_SW) { /* Scaling through scale handles means translating one corner point, * with all sides at constant angles. */ gint this, left, right, opposite; /* 0: northwest, 1: northeast, 2: southwest, 3: southeast */ if (handle == GIMP_TRANSFORM_HANDLE_NW) { this = 0; left = 1; right = 2; opposite = 3; } else if (handle == GIMP_TRANSFORM_HANDLE_NE) { this = 1; left = 3; right = 0; opposite = 2; } else if (handle == GIMP_TRANSFORM_HANDLE_SW) { this = 2; left = 0; right = 3; opposite = 1; } else if (handle == GIMP_TRANSFORM_HANDLE_SE) { this = 3; left = 2; right = 1; opposite = 0; } else gimp_assert_not_reached (); /* when the keep aspect transformation constraint is enabled, * the translation shall only be along the diagonal that runs * through this corner point. */ if (private->constrain_scale) { /* restrict to movement along the diagonal */ GimpVector2 diag = vectorsubtract (oldpos[this], oldpos[opposite]); d = vectorproject (d, diag); } /* Move the corner being interacted with */ /* rp---------tp * / /\ <- d, the interaction vector * / / tp * op----------/ * */ newpos[this] = vectoradd (oldpos[this], d); /* Where the corner to the right and left would go, need these to form * lines to intersect with the sides */ /* rp----------/ * /\ /\ * / nr / nt * op----------lp * \ * nl */ newpos[right] = vectoradd (oldpos[right], d); newpos[left] = vectoradd (oldpos[left], d); /* Now we just need to find the intersection of op-rp and nr-nt. * rp----------/ * / / * / nr==========nt * op----------/ * */ newpos[right] = lineintersect (newpos[right], newpos[this], oldpos[opposite], oldpos[right]); newpos[left] = lineintersect (newpos[left], newpos[this], oldpos[opposite], oldpos[left]); /* /-----------/ * / / * rp============nt * op----------/ * */ /* * * /--------------/ * /--------------/ * */ if (private->frompivot_scale && transform_is_convex (newpos) && transform_is_convex (oldpos)) { /* transform the pivot point before the interaction and * after, and move everything by this difference */ //TODO the handle doesn't actually end up where the mouse cursor is GimpVector2 delta = get_pivot_delta (grid, oldpos, newpos, pivot); for (i = 0; i < 4; i++) newpos[i] = vectorsubtract (newpos[i], delta); fixedpivot = TRUE; } } /* scaling via sides */ if (handle == GIMP_TRANSFORM_HANDLE_N || handle == GIMP_TRANSFORM_HANDLE_E || handle == GIMP_TRANSFORM_HANDLE_S || handle == GIMP_TRANSFORM_HANDLE_W) { gint this_l, this_r, opp_l, opp_r; GimpVector2 side_l, side_r, midline; /* 0: northwest, 1: northeast, 2: southwest, 3: southeast */ if (handle == GIMP_TRANSFORM_HANDLE_N) { this_l = 1; this_r = 0; } else if (handle == GIMP_TRANSFORM_HANDLE_E) { this_l = 3; this_r = 1; } else if (handle == GIMP_TRANSFORM_HANDLE_S) { this_l = 2; this_r = 3; } else if (handle == GIMP_TRANSFORM_HANDLE_W) { this_l = 0; this_r = 2; } else gimp_assert_not_reached (); opp_l = 3 - this_r; opp_r = 3 - this_l; side_l = vectorsubtract (oldpos[opp_l], oldpos[this_l]); side_r = vectorsubtract (oldpos[opp_r], oldpos[this_r]); midline = vectoradd (side_l, side_r); /* restrict to movement along the midline */ d = vectorproject (d, midline); if (private->constrain_scale) { GimpVector2 before, after, effective_pivot = pivot; gdouble distance; if (! private->frompivot_scale) { /* center of the opposite side is pivot */ effective_pivot = scalemult (vectoradd (oldpos[opp_l], oldpos[opp_r]), 0.5); } /* get the difference between the distance from the pivot to * where interaction started and the distance from the pivot * to where cursor is now, and scale all corners distance * from the pivot with this factor */ before = vectorsubtract (effective_pivot, mouse); after = vectorsubtract (effective_pivot, cur); after = vectorproject (after, before); distance = 0.5 * (after.x / before.x + after.y / before.y); for (i = 0; i < 4; i++) newpos[i] = vectoradd (effective_pivot, scalemult (vectorsubtract (oldpos[i], effective_pivot), distance)); } else { /* just move the side */ newpos[this_l] = vectoradd (oldpos[this_l], d); newpos[this_r] = vectoradd (oldpos[this_r], d); } if (! private->constrain_scale && private->frompivot_scale && transform_is_convex (newpos) && transform_is_convex (oldpos)) { GimpVector2 delta = get_pivot_delta (grid, oldpos, newpos, pivot); for (i = 0; i < 4; i++) newpos[i] = vectorsubtract (newpos[i], delta); fixedpivot = TRUE; } } /* shear */ if (handle == GIMP_TRANSFORM_HANDLE_N_S || handle == GIMP_TRANSFORM_HANDLE_E_S || handle == GIMP_TRANSFORM_HANDLE_S_S || handle == GIMP_TRANSFORM_HANDLE_W_S) { gint this_l, this_r; /* set up indices for this edge and the opposite edge */ if (handle == GIMP_TRANSFORM_HANDLE_N_S) { this_l = 1; this_r = 0; } else if (handle == GIMP_TRANSFORM_HANDLE_W_S) { this_l = 0; this_r = 2; } else if (handle == GIMP_TRANSFORM_HANDLE_S_S) { this_l = 2; this_r = 3; } else if (handle == GIMP_TRANSFORM_HANDLE_E_S) { this_l = 3; this_r = 1; } else gimp_assert_not_reached (); if (private->constrain_shear) { /* restrict to movement along the side */ GimpVector2 side = vectorsubtract (oldpos[this_r], oldpos[this_l]); d = vectorproject (d, side); } newpos[this_l] = vectoradd (oldpos[this_l], d); newpos[this_r] = vectoradd (oldpos[this_r], d); if (private->frompivot_shear && transform_is_convex (newpos) && transform_is_convex (oldpos)) { GimpVector2 delta = get_pivot_delta (grid, oldpos, newpos, pivot); for (i = 0; i < 4; i++) newpos[i] = vectorsubtract (newpos[i], delta); fixedpivot = TRUE; } } /* perspective transform */ if (handle == GIMP_TRANSFORM_HANDLE_NW_P || handle == GIMP_TRANSFORM_HANDLE_NE_P || handle == GIMP_TRANSFORM_HANDLE_SE_P || handle == GIMP_TRANSFORM_HANDLE_SW_P) { gint this, left, right, opposite; /* 0: northwest, 1: northeast, 2: southwest, 3: southeast */ if (handle == GIMP_TRANSFORM_HANDLE_NW_P) { this = 0; left = 1; right = 2; opposite = 3; } else if (handle == GIMP_TRANSFORM_HANDLE_NE_P) { this = 1; left = 3; right = 0; opposite = 2; } else if (handle == GIMP_TRANSFORM_HANDLE_SW_P) { this = 2; left = 0; right = 3; opposite = 1; } else if (handle == GIMP_TRANSFORM_HANDLE_SE_P) { this = 3; left = 2; right = 1; opposite = 0; } else gimp_assert_not_reached (); if (private->constrain_perspective) { /* when the constrain transformation constraint is enabled, * the translation shall only be either along the side * angles of the two sides that run to this corner point, or * along the diagonal that runs through this corner point. */ GimpVector2 proj[4]; gdouble rej[4]; for (i = 0; i < 4; i++) { if (i == this) continue; /* get the vectors along the sides and the diagonal */ proj[i] = vectorsubtract (oldpos[this], oldpos[i]); /* project d on each candidate vector and see which has * the shortest rejection */ proj[i] = vectorproject (d, proj[i]); rej[i] = norm (vectorsubtract (d, proj[i])); } if (rej[left] < rej[right] && rej[left] < rej[opposite]) d = proj[left]; else if (rej[right] < rej[opposite]) d = proj[right]; else d = proj[opposite]; } newpos[this] = vectoradd (oldpos[this], d); if (private->frompivot_perspective && transform_is_convex (newpos) && transform_is_convex (oldpos)) { GimpVector2 delta = get_pivot_delta (grid, oldpos, newpos, pivot); for (i = 0; i < 4; i++) newpos[i] = vectorsubtract (newpos[i], delta); fixedpivot = TRUE; } } /* this will have been set to TRUE if an operation used the pivot in * addition to being a user option */ if (! fixedpivot && transform_is_convex (newpos) && transform_is_convex (oldpos) && point_is_inside_polygon_pos (oldpos, pivot)) { GimpVector2 delta = get_pivot_delta (grid, oldpos, newpos, pivot); pivot = vectoradd (pivot, delta); } /* make sure the new coordinates are valid */ for (i = 0; i < 4; i++) { if (! isfinite (newpos[i].x) || ! isfinite (newpos[i].y)) return; } if (! isfinite (pivot.x) || ! isfinite (pivot.y)) return; for (i = 0; i < 4; i++) { *x[i] = newpos[i].x; *y[i] = newpos[i].y; } /* set unconditionally: if options get toggled during operation, we * have to move pivot back */ *newpivot_x = pivot.x; *newpivot_y = pivot.y; gimp_tool_transform_grid_update_matrix (grid); } static const gchar * get_friendly_operation_name (GimpTransformHandle handle) { switch (handle) { case GIMP_TRANSFORM_HANDLE_NONE: return ""; case GIMP_TRANSFORM_HANDLE_NW_P: case GIMP_TRANSFORM_HANDLE_NE_P: case GIMP_TRANSFORM_HANDLE_SW_P: case GIMP_TRANSFORM_HANDLE_SE_P: return _("Click-Drag to change perspective"); case GIMP_TRANSFORM_HANDLE_NW: case GIMP_TRANSFORM_HANDLE_NE: case GIMP_TRANSFORM_HANDLE_SW: case GIMP_TRANSFORM_HANDLE_SE: return _("Click-Drag to scale"); case GIMP_TRANSFORM_HANDLE_N: case GIMP_TRANSFORM_HANDLE_S: case GIMP_TRANSFORM_HANDLE_E: case GIMP_TRANSFORM_HANDLE_W: return _("Click-Drag to scale"); case GIMP_TRANSFORM_HANDLE_CENTER: return _("Click-Drag to move"); case GIMP_TRANSFORM_HANDLE_PIVOT: return _("Click-Drag to move the pivot point"); case GIMP_TRANSFORM_HANDLE_N_S: case GIMP_TRANSFORM_HANDLE_S_S: case GIMP_TRANSFORM_HANDLE_E_S: case GIMP_TRANSFORM_HANDLE_W_S: return _("Click-Drag to shear"); case GIMP_TRANSFORM_HANDLE_ROTATION: return _("Click-Drag to rotate"); default: gimp_assert_not_reached (); } } static GimpTransformHandle gimp_tool_transform_get_area_handle (GimpToolTransformGrid *grid, const GimpCoords *coords, GimpTransformFunction function) { GimpToolTransformGridPrivate *private = grid->private; GimpTransformHandle handle = GIMP_TRANSFORM_HANDLE_NONE; switch (function) { case GIMP_TRANSFORM_FUNCTION_NONE: break; case GIMP_TRANSFORM_FUNCTION_MOVE: handle = GIMP_TRANSFORM_HANDLE_CENTER; break; case GIMP_TRANSFORM_FUNCTION_ROTATE: handle = GIMP_TRANSFORM_HANDLE_ROTATION; break; case GIMP_TRANSFORM_FUNCTION_SCALE: case GIMP_TRANSFORM_FUNCTION_PERSPECTIVE: { gdouble closest_dist; gdouble dist; dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, private->tx1, private->ty1); closest_dist = dist; if (function == GIMP_TRANSFORM_FUNCTION_PERSPECTIVE) handle = GIMP_TRANSFORM_HANDLE_NW_P; else handle = GIMP_TRANSFORM_HANDLE_NW; dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, private->tx2, private->ty2); if (dist < closest_dist) { closest_dist = dist; if (function == GIMP_TRANSFORM_FUNCTION_PERSPECTIVE) handle = GIMP_TRANSFORM_HANDLE_NE_P; else handle = GIMP_TRANSFORM_HANDLE_NE; } dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, private->tx3, private->ty3); if (dist < closest_dist) { closest_dist = dist; if (function == GIMP_TRANSFORM_FUNCTION_PERSPECTIVE) handle = GIMP_TRANSFORM_HANDLE_SW_P; else handle = GIMP_TRANSFORM_HANDLE_SW; } dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, private->tx4, private->ty4); if (dist < closest_dist) { closest_dist = dist; if (function == GIMP_TRANSFORM_FUNCTION_PERSPECTIVE) handle = GIMP_TRANSFORM_HANDLE_SE_P; else handle = GIMP_TRANSFORM_HANDLE_SE; } } break; case GIMP_TRANSFORM_FUNCTION_SHEAR: { gdouble handle_x; gdouble handle_y; gdouble closest_dist; gdouble dist; gimp_canvas_handle_get_position (private->handles[GIMP_TRANSFORM_HANDLE_N], &handle_x, &handle_y); dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, handle_x, handle_y); closest_dist = dist; handle = GIMP_TRANSFORM_HANDLE_N_S; gimp_canvas_handle_get_position (private->handles[GIMP_TRANSFORM_HANDLE_W], &handle_x, &handle_y); dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, handle_x, handle_y); if (dist < closest_dist) { closest_dist = dist; handle = GIMP_TRANSFORM_HANDLE_W_S; } gimp_canvas_handle_get_position (private->handles[GIMP_TRANSFORM_HANDLE_E], &handle_x, &handle_y); dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, handle_x, handle_y); if (dist < closest_dist) { closest_dist = dist; handle = GIMP_TRANSFORM_HANDLE_E_S; } gimp_canvas_handle_get_position (private->handles[GIMP_TRANSFORM_HANDLE_S], &handle_x, &handle_y); dist = gimp_canvas_item_transform_distance_square (private->guides, coords->x, coords->y, handle_x, handle_y); if (dist < closest_dist) { closest_dist = dist; handle = GIMP_TRANSFORM_HANDLE_S_S; } } break; } return handle; } GimpHit gimp_tool_transform_grid_hit (GimpToolWidget *widget, const GimpCoords *coords, GdkModifierType state, gboolean proximity) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpTransformHandle handle; handle = gimp_tool_transform_grid_get_handle_for_coords (grid, coords); if (handle != GIMP_TRANSFORM_HANDLE_NONE) return GIMP_HIT_DIRECT; return GIMP_HIT_INDIRECT; } void gimp_tool_transform_grid_hover (GimpToolWidget *widget, const GimpCoords *coords, GdkModifierType state, gboolean proximity) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; GimpTransformHandle handle; handle = gimp_tool_transform_grid_get_handle_for_coords (grid, coords); if (handle == GIMP_TRANSFORM_HANDLE_NONE) { /* points passed in clockwise order */ if (point_is_inside_polygon (4, (gdouble[4]){ private->tx1, private->tx2, private->tx4, private->tx3 }, (gdouble[4]){ private->ty1, private->ty2, private->ty4, private->ty3 }, coords->x, coords->y)) { handle = gimp_tool_transform_get_area_handle (grid, coords, private->inside_function); } else { handle = gimp_tool_transform_get_area_handle (grid, coords, private->outside_function); } } if (handle != GIMP_TRANSFORM_HANDLE_NONE && proximity) { gimp_tool_widget_set_status (widget, get_friendly_operation_name (handle)); } else { gimp_tool_widget_set_status (widget, NULL); } private->handle = handle; gimp_tool_transform_grid_update_hilight (grid); } void gimp_tool_transform_grid_leave_notify (GimpToolWidget *widget) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; private->handle = GIMP_TRANSFORM_HANDLE_NONE; gimp_tool_transform_grid_update_hilight (grid); GIMP_TOOL_WIDGET_CLASS (parent_class)->leave_notify (widget); } static void gimp_tool_transform_grid_modifier (GimpToolWidget *widget, GdkModifierType key) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; if (key == gimp_get_constrain_behavior_mask ()) { g_object_set (widget, "frompivot-scale", ! private->frompivot_scale, "frompivot-shear", ! private->frompivot_shear, "frompivot-perspective", ! private->frompivot_perspective, NULL); } else if (key == gimp_get_extend_selection_mask ()) { g_object_set (widget, "cornersnap", ! private->cornersnap, "constrain-move", ! private->constrain_move, "constrain-scale", ! private->constrain_scale, "constrain-rotate", ! private->constrain_rotate, "constrain-shear", ! private->constrain_shear, "constrain-perspective", ! private->constrain_perspective, NULL); } } static void gimp_tool_transform_grid_hover_modifier (GimpToolWidget *widget, GdkModifierType key, gboolean press, GdkModifierType state) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; GimpCoords coords = { 0.0, }; gimp_tool_transform_grid_modifier (widget, key); if (private->button_down) { /* send a non-motion to update the grid with the new constraints */ coords.x = private->curx; coords.y = private->cury; gimp_tool_transform_grid_motion (widget, &coords, 0, state); } } static gboolean gimp_tool_transform_grid_get_cursor (GimpToolWidget *widget, const GimpCoords *coords, GdkModifierType state, GimpCursorType *cursor, GimpToolCursorType *tool_cursor, GimpCursorModifier *modifier) { GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget); GimpToolTransformGridPrivate *private = grid->private; gdouble angle[9]; gint i; GimpCursorType map[8]; GimpVector2 pos[4], this, that; gboolean flip = FALSE; gboolean side = FALSE; gboolean set_cursor = TRUE; map[0] = GIMP_CURSOR_CORNER_TOP_LEFT; map[1] = GIMP_CURSOR_CORNER_TOP; map[2] = GIMP_CURSOR_CORNER_TOP_RIGHT; map[3] = GIMP_CURSOR_CORNER_RIGHT; map[4] = GIMP_CURSOR_CORNER_BOTTOM_RIGHT; map[5] = GIMP_CURSOR_CORNER_BOTTOM; map[6] = GIMP_CURSOR_CORNER_BOTTOM_LEFT; map[7] = GIMP_CURSOR_CORNER_LEFT; get_handle_geometry (grid, pos, angle); for (i = 0; i < 8; i++) angle[i] = round (angle[i] * 180.0 / G_PI / 45.0); switch (private->handle) { case GIMP_TRANSFORM_HANDLE_NW_P: case GIMP_TRANSFORM_HANDLE_NW: i = (gint) angle[4] + 0; this = pos[0]; that = pos[3]; break; case GIMP_TRANSFORM_HANDLE_NE_P: case GIMP_TRANSFORM_HANDLE_NE: i = (gint) angle[5] + 2; this = pos[1]; that = pos[2]; break; case GIMP_TRANSFORM_HANDLE_SW_P: case GIMP_TRANSFORM_HANDLE_SW: i = (gint) angle[6] + 6; this = pos[2]; that = pos[1]; break; case GIMP_TRANSFORM_HANDLE_SE_P: case GIMP_TRANSFORM_HANDLE_SE: i = (gint) angle[7] + 4; this = pos[3]; that = pos[0]; break; case GIMP_TRANSFORM_HANDLE_N: case GIMP_TRANSFORM_HANDLE_N_S: i = (gint) angle[0] + 1; this = vectoradd (pos[0], pos[1]); that = vectoradd (pos[2], pos[3]); side = TRUE; break; case GIMP_TRANSFORM_HANDLE_S: case GIMP_TRANSFORM_HANDLE_S_S: i = (gint) angle[1] + 5; this = vectoradd (pos[2], pos[3]); that = vectoradd (pos[0], pos[1]); side = TRUE; break; case GIMP_TRANSFORM_HANDLE_E: case GIMP_TRANSFORM_HANDLE_E_S: i = (gint) angle[2] + 3; this = vectoradd (pos[1], pos[3]); that = vectoradd (pos[0], pos[2]); side = TRUE; break; case GIMP_TRANSFORM_HANDLE_W: case GIMP_TRANSFORM_HANDLE_W_S: i = (gint) angle[3] + 7; this = vectoradd (pos[0], pos[2]); that = vectoradd (pos[1], pos[3]); side = TRUE; break; default: set_cursor = FALSE; break; } if (set_cursor) { i %= 8; switch (map[i]) { case GIMP_CURSOR_CORNER_TOP_LEFT: if (this.x + this.y > that.x + that.y) flip = TRUE; break; case GIMP_CURSOR_CORNER_TOP: if (this.y > that.y) flip = TRUE; break; case GIMP_CURSOR_CORNER_TOP_RIGHT: if (this.x - this.y < that.x - that.y) flip = TRUE; break; case GIMP_CURSOR_CORNER_RIGHT: if (this.x < that.x) flip = TRUE; break; case GIMP_CURSOR_CORNER_BOTTOM_RIGHT: if (this.x + this.y < that.x + that.y) flip = TRUE; break; case GIMP_CURSOR_CORNER_BOTTOM: if (this.y < that.y) flip = TRUE; break; case GIMP_CURSOR_CORNER_BOTTOM_LEFT: if (this.x - this.y > that.x - that.y) flip = TRUE; break; case GIMP_CURSOR_CORNER_LEFT: if (this.x > that.x) flip = TRUE; break; default: gimp_assert_not_reached (); } if (flip) *cursor = map[(i + 4) % 8]; else *cursor = map[i]; if (side) *cursor += 8; } /* parent class handles *cursor and *modifier for most handles */ switch (private->handle) { case GIMP_TRANSFORM_HANDLE_NONE: *tool_cursor = GIMP_TOOL_CURSOR_NONE; break; case GIMP_TRANSFORM_HANDLE_NW_P: case GIMP_TRANSFORM_HANDLE_NE_P: case GIMP_TRANSFORM_HANDLE_SW_P: case GIMP_TRANSFORM_HANDLE_SE_P: *tool_cursor = GIMP_TOOL_CURSOR_PERSPECTIVE; break; case GIMP_TRANSFORM_HANDLE_NW: case GIMP_TRANSFORM_HANDLE_NE: case GIMP_TRANSFORM_HANDLE_SW: case GIMP_TRANSFORM_HANDLE_SE: case GIMP_TRANSFORM_HANDLE_N: case GIMP_TRANSFORM_HANDLE_S: case GIMP_TRANSFORM_HANDLE_E: case GIMP_TRANSFORM_HANDLE_W: *tool_cursor = GIMP_TOOL_CURSOR_RESIZE; break; case GIMP_TRANSFORM_HANDLE_CENTER: *tool_cursor = GIMP_TOOL_CURSOR_MOVE; break; case GIMP_TRANSFORM_HANDLE_PIVOT: *tool_cursor = GIMP_TOOL_CURSOR_ROTATE; *modifier = GIMP_CURSOR_MODIFIER_MOVE; break; case GIMP_TRANSFORM_HANDLE_N_S: case GIMP_TRANSFORM_HANDLE_S_S: case GIMP_TRANSFORM_HANDLE_E_S: case GIMP_TRANSFORM_HANDLE_W_S: *tool_cursor = GIMP_TOOL_CURSOR_SHEAR; break; case GIMP_TRANSFORM_HANDLE_ROTATION: *tool_cursor = GIMP_TOOL_CURSOR_ROTATE; break; default: g_return_val_if_reached (FALSE); } return TRUE; } static GimpTransformHandle gimp_tool_transform_grid_get_handle_for_coords (GimpToolTransformGrid *grid, const GimpCoords *coords) { GimpToolTransformGridPrivate *private = grid->private; GimpTransformHandle i; for (i = GIMP_TRANSFORM_HANDLE_NONE + 1; i < GIMP_N_TRANSFORM_HANDLES; i++) { if (private->handles[i] && gimp_canvas_item_hit (private->handles[i], coords->x, coords->y)) { return i; } } return GIMP_TRANSFORM_HANDLE_NONE; } static void gimp_tool_transform_grid_update_hilight (GimpToolTransformGrid *grid) { GimpToolTransformGridPrivate *private = grid->private; GimpTransformHandle handle; for (handle = GIMP_TRANSFORM_HANDLE_NONE; handle < GIMP_N_TRANSFORM_HANDLES; handle++) { if (private->handles[handle]) { gimp_canvas_item_set_highlight (private->handles[handle], handle == private->handle); } } } static void gimp_tool_transform_grid_update_box (GimpToolTransformGrid *grid) { GimpToolTransformGridPrivate *private = grid->private; gimp_matrix3_transform_point (&private->transform, private->x1, private->y1, &private->tx1, &private->ty1); gimp_matrix3_transform_point (&private->transform, private->x2, private->y1, &private->tx2, &private->ty2); gimp_matrix3_transform_point (&private->transform, private->x1, private->y2, &private->tx3, &private->ty3); gimp_matrix3_transform_point (&private->transform, private->x2, private->y2, &private->tx4, &private->ty4); /* don't transform pivot */ private->tpx = private->pivot_x; private->tpy = private->pivot_y; if (transform_grid_is_convex (grid)) { gimp_matrix3_transform_point (&private->transform, (private->x1 + private->x2) / 2.0, (private->y1 + private->y2) / 2.0, &private->tcx, &private->tcy); } else { private->tcx = (private->tx1 + private->tx2 + private->tx3 + private->tx4) / 4.0; private->tcy = (private->ty1 + private->ty2 + private->ty3 + private->ty4) / 4.0; } } static void gimp_tool_transform_grid_update_matrix (GimpToolTransformGrid *grid) { GimpToolTransformGridPrivate *private = grid->private; gimp_matrix3_identity (&private->transform); gimp_transform_matrix_perspective (&private->transform, private->x1, private->y1, private->x2 - private->x1, private->y2 - private->y1, private->tx1, private->ty1, private->tx2, private->ty2, private->tx3, private->ty3, private->tx4, private->ty4); private->pivot_x = private->tpx; private->pivot_y = private->tpy; g_object_freeze_notify (G_OBJECT (grid)); g_object_notify (G_OBJECT (grid), "transform"); g_object_notify (G_OBJECT (grid), "pivot-x"); g_object_notify (G_OBJECT (grid), "pivot-x"); g_object_thaw_notify (G_OBJECT (grid)); } static void gimp_tool_transform_grid_calc_handles (GimpToolTransformGrid *grid, gint *handle_w, gint *handle_h) { GimpToolTransformGridPrivate *private = grid->private; gint dx1, dy1; gint dx2, dy2; gint dx3, dy3; gint dx4, dy4; gint x1, y1; gint x2, y2; if (! private->dynamic_handle_size) { *handle_w = GIMP_CANVAS_HANDLE_SIZE_LARGE; *handle_h = GIMP_CANVAS_HANDLE_SIZE_LARGE; return; } gimp_canvas_item_transform_xy (private->guides, private->tx1, private->ty1, &dx1, &dy1); gimp_canvas_item_transform_xy (private->guides, private->tx2, private->ty2, &dx2, &dy2); gimp_canvas_item_transform_xy (private->guides, private->tx3, private->ty3, &dx3, &dy3); gimp_canvas_item_transform_xy (private->guides, private->tx4, private->ty4, &dx4, &dy4); x1 = MIN4 (dx1, dx2, dx3, dx4); y1 = MIN4 (dy1, dy2, dy3, dy4); x2 = MAX4 (dx1, dx2, dx3, dx4); y2 = MAX4 (dy1, dy2, dy3, dy4); *handle_w = CLAMP ((x2 - x1) / 3, MIN_HANDLE_SIZE, GIMP_CANVAS_HANDLE_SIZE_LARGE); *handle_h = CLAMP ((y2 - y1) / 3, MIN_HANDLE_SIZE, GIMP_CANVAS_HANDLE_SIZE_LARGE); } /* public functions */ GimpToolWidget * gimp_tool_transform_grid_new (GimpDisplayShell *shell, const GimpMatrix3 *transform, gdouble x1, gdouble y1, gdouble x2, gdouble y2) { g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), NULL); return g_object_new (GIMP_TYPE_TOOL_TRANSFORM_GRID, "shell", shell, "transform", transform, "x1", x1, "y1", y1, "x2", x2, "y2", y2, NULL); } /* protected functions */ GimpTransformHandle gimp_tool_transform_grid_get_handle (GimpToolTransformGrid *grid) { g_return_val_if_fail (GIMP_IS_TOOL_TRANSFORM_GRID (grid), GIMP_TRANSFORM_HANDLE_NONE); return grid->private->handle; }
¤ Dauer der Verarbeitung: 0.44 Sekunden (vorverarbeitet am 2026-11-04) ¤*© Formatika GbR, Deutschland |
|
||||||||||||||||||||||||
2026-11-01