dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/display/gimptooltransformgrid.c

2495 lines
88 KiB
C
Raw Normal View History

app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
/* 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
Change the license URL from http://www.gnu.org/licenses/ to https://
2018-07-12 05:27:07 +08:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
*/
#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"
app: make GimpToolTransformGrid handle modifiers itself and update the grid as soon as a constraint is changed, not only on the next motion. Change GimpTransformTool to forward the events to the widget if it exists, but still handle them if it doesn't (yes this code duplication is ugly, but the widget can hardly handle events if it doesn't exist...).
2017-07-16 01:34:08 +08:00
#include "widgets/gimpwidgets-utils.h"
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
#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,
app: use gimp_transform_polygon() in GimpCanvasTransformGuides Add a "clip" property to GimpCavnasTransformGuides. When set, use gimp_transform_polygon() for transforming the guides and the bounding box, so that they're properly clipped. Add a corresponding "clip-guides" property to GimpToolTransformGrid, and set it to TRUE in GimpToolHandleGrid, so that the handle-transform tool's guides are clipped properly.
2018-01-29 02:39:00 +08:00
PROP_CLIP_GUIDES,
app: add show-guides property to GimpToolTransformGrid ... which can be used to control the guides' visibility. Will be used by the next commit, to hide the guides in GimpToolHandleGrid when the tranformation is invalid.
2018-01-27 20:15:05 +08:00
PROP_SHOW_GUIDES,
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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,
app: add GimpTransformGridTool::dynamic-handle-size property Add a boolean GimpTransformGridTool::dynamic-handle-size property, which controls whether the handle sizes are adjustment dynamically according to the grid's size, or remain fixed. This property is TRUE by default, to maintain the current behavior.
2020-01-06 22:35:01 +08:00
PROP_DYNAMIC_HANDLE_SIZE,
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: use gimp_transform_polygon() in GimpCanvasTransformGuides Add a "clip" property to GimpCavnasTransformGuides. When set, use gimp_transform_polygon() for transforming the guides and the bounding box, so that they're properly clipped. Add a corresponding "clip-guides" property to GimpToolTransformGrid, and set it to TRUE in GimpToolHandleGrid, so that the handle-transform tool's guides are clipped properly.
2018-01-29 02:39:00 +08:00
gboolean clip_guides;
app: add show-guides property to GimpToolTransformGrid ... which can be used to control the guides' visibility. Will be used by the next commit, to hide the guides in GimpToolHandleGrid when the tranformation is invalid.
2018-01-27 20:15:05 +08:00
gboolean show_guides;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: add GimpTransformGridTool::dynamic-handle-size property Add a boolean GimpTransformGridTool::dynamic-handle-size property, which controls whether the handle sizes are adjustment dynamically according to the grid's size, or remain fixed. This property is TRUE by default, to maintain the current behavior.
2020-01-06 22:35:01 +08:00
gboolean dynamic_handle_size;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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 */
app: implement GimpToolActiveModifiers in GimpTool Change gimp_tool_set_active_modifier_state() to honor the new GimpToolControlSetting. Explicitly set the mode to SEPARATE in all tools that require modifier keys during a stroke. And here comes the actual fix: change GimpTransformTool and GimpToolTransformGrid to use SAME mode, and remove their active_modifer_key() and hover_modifier() impls, so it makes no difference whether a modifier is pressed before of after mouse button press/release.
2017-10-29 23:38:24 +08:00
gdouble button_down; /* is the mouse button pressed */
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
static GimpHit gimp_tool_transform_grid_hit (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
static void gimp_tool_transform_grid_hover (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity);
app: implement GimpToolWidget::leave_notify() in various tool widgets ... by having them disable item highlights, and any other proximity indication, when the cursor leaves the widget.
2018-06-02 13:50:50 +08:00
static void gimp_tool_transform_grid_leave_notify (GimpToolWidget *widget);
app: make GimpToolTransformGrid handle modifiers itself and update the grid as soon as a constraint is changed, not only on the next motion. Change GimpTransformTool to forward the events to the widget if it exists, but still handle them if it doesn't (yes this code duplication is ugly, but the widget can hardly handle events if it doesn't exist...).
2017-07-16 01:34:08 +08:00
static void gimp_tool_transform_grid_hover_modifier (GimpToolWidget *widget,
GdkModifierType key,
gboolean press,
GdkModifierType state);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
static gboolean gimp_tool_transform_grid_get_cursor (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
GimpCursorType *cursor,
GimpToolCursorType *tool_cursor,
app: gimp_tool_widget_get_cursor(): rename "cursor_modifier" to just "modifier" The same in all subclasses.
2017-06-27 04:13:00 +08:00
GimpCursorModifier *modifier);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
static GimpTransformHandle
app: add a protected gimp_tool_transform_grid_get_handle() function ... which can be used by subclasses to retrieve the currently- active handle.
2020-01-06 22:37:12 +08:00
gimp_tool_transform_grid_get_handle_for_coords
(GimpToolTransformGrid *grid,
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
const GimpCoords *coords);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolTransformGrid, gimp_tool_transform_grid,
GIMP_TYPE_TOOL_WIDGET)
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
#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;
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
widget_class->hit = gimp_tool_transform_grid_hit;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
widget_class->hover = gimp_tool_transform_grid_hover;
app: implement GimpToolWidget::leave_notify() in various tool widgets ... by having them disable item highlights, and any other proximity indication, when the cursor leaves the widget.
2018-06-02 13:50:50 +08:00
widget_class->leave_notify = gimp_tool_transform_grid_leave_notify;
app: make GimpToolTransformGrid handle modifiers itself and update the grid as soon as a constraint is changed, not only on the next motion. Change GimpTransformTool to forward the events to the widget if it exists, but still handle them if it doesn't (yes this code duplication is ugly, but the widget can hardly handle events if it doesn't exist...).
2017-07-16 01:34:08 +08:00
widget_class->hover_modifier = gimp_tool_transform_grid_hover_modifier;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
widget_class->get_cursor = gimp_tool_transform_grid_get_cursor;
app: update tool widgets on display-shell changes more granularly Partially revert commit c73710e410b663edee14bbfb1a0b96b7fbeb9047, avoiding updating tool widgets unconditionally on tool resume in GimpDrawTool -- it's too expensive in general. Instead, handle display-shell changes in GimpToolWidget, by adding GimpToolWidget::update_on_{scale,scroll,rotate} flags, which subclasses can use to request an update on any of these events. Set the flags as necessary for the affected widgets.
2020-05-26 15:36:58 +08:00
widget_class->update_on_scale = TRUE;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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));
app: use gimp_transform_polygon() in GimpCanvasTransformGuides Add a "clip" property to GimpCavnasTransformGuides. When set, use gimp_transform_polygon() for transforming the guides and the bounding box, so that they're properly clipped. Add a corresponding "clip-guides" property to GimpToolTransformGrid, and set it to TRUE in GimpToolHandleGrid, so that the handle-transform tool's guides are clipped properly.
2018-01-29 02:39:00 +08:00
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));
app: add show-guides property to GimpToolTransformGrid ... which can be used to control the guides' visibility. Will be used by the next commit, to hide the guides in GimpToolHandleGrid when the tranformation is invalid.
2018-01-27 20:15:05 +08:00
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));
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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));
app: add GimpTransformGridTool::dynamic-handle-size property Add a boolean GimpTransformGridTool::dynamic-handle-size property, which controls whether the handle sizes are adjustment dynamically according to the grid's size, or remain fixed. This property is TRUE by default, to maintain the current behavior.
2020-01-06 22:35:01 +08:00
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));
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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)
{
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
grid->private = gimp_tool_transform_grid_get_instance_private (grid);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
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,
app: use gimp_transform_polygon() in GimpCanvasTransformGuides Add a "clip" property to GimpCavnasTransformGuides. When set, use gimp_transform_polygon() for transforming the guides and the bounding box, so that they're properly clipped. Add a corresponding "clip-guides" property to GimpToolTransformGrid, and set it to TRUE in GimpToolHandleGrid, so that the handle-transform tool's guides are clipped properly.
2018-01-29 02:39:00 +08:00
private->n_guides,
private->clip_guides);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: use gimp_transform_polygon() in GimpCanvasTransformGuides Add a "clip" property to GimpCavnasTransformGuides. When set, use gimp_transform_polygon() for transforming the guides and the bounding box, so that they're properly clipped. Add a corresponding "clip-guides" property to GimpToolTransformGrid, and set it to TRUE in GimpToolHandleGrid, so that the handle-transform tool's guides are clipped properly.
2018-01-29 02:39:00 +08:00
case PROP_CLIP_GUIDES:
private->clip_guides = g_value_get_boolean (value);
break;
app: add show-guides property to GimpToolTransformGrid ... which can be used to control the guides' visibility. Will be used by the next commit, to hide the guides in GimpToolHandleGrid when the tranformation is invalid.
2018-01-27 20:15:05 +08:00
case PROP_SHOW_GUIDES:
private->show_guides = g_value_get_boolean (value);
break;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: add GimpTransformGridTool::dynamic-handle-size property Add a boolean GimpTransformGridTool::dynamic-handle-size property, which controls whether the handle sizes are adjustment dynamically according to the grid's size, or remain fixed. This property is TRUE by default, to maintain the current behavior.
2020-01-06 22:35:01 +08:00
case PROP_DYNAMIC_HANDLE_SIZE:
private->dynamic_handle_size = g_value_get_boolean (value);
break;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: use gimp_transform_polygon() in GimpCanvasTransformGuides Add a "clip" property to GimpCavnasTransformGuides. When set, use gimp_transform_polygon() for transforming the guides and the bounding box, so that they're properly clipped. Add a corresponding "clip-guides" property to GimpToolTransformGrid, and set it to TRUE in GimpToolHandleGrid, so that the handle-transform tool's guides are clipped properly.
2018-01-29 02:39:00 +08:00
case PROP_CLIP_GUIDES:
g_value_set_boolean (value, private->clip_guides);
break;
app: add show-guides property to GimpToolTransformGrid ... which can be used to control the guides' visibility. Will be used by the next commit, to hide the guides in GimpToolHandleGrid when the tranformation is invalid.
2018-01-27 20:15:05 +08:00
case PROP_SHOW_GUIDES:
g_value_set_boolean (value, private->show_guides);
break;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: add GimpTransformGridTool::dynamic-handle-size property Add a boolean GimpTransformGridTool::dynamic-handle-size property, which controls whether the handle sizes are adjustment dynamically according to the grid's size, or remain fixed. This property is TRUE by default, to maintain the current behavior.
2020-01-06 22:35:01 +08:00
case PROP_DYNAMIC_HANDLE_SIZE:
g_value_set_boolean (value, private->dynamic_handle_size);
break;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
}
app: fix transform-grid center point for non-affine transforms; use as pivot In GimpToolTransformGrid, use the transformed center-point of the original polygon as the position of the center-point handle, and as a snapping point for the pivot when "cornersnap" is TRUE, instead of using the center-point of the transformed polygon. These two points are different for non-affine transformations. Furthermore, when "use-pivot-handle" is FALSE, use the center- point as the reference point when transforming around the pivot, instead of the pivot itself, which might not be set. In particular, this fixes transformation around the pivot in the perspective tool. Don't explicitly set the center-point as the pivot in the scale tool, since this commit makes it unnecessary.
2019-03-01 04:21:40 +08:00
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);
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
Issue #2090 - Crash when using transform tools In GimpTransformGridTool, avoid producing non-finite coordinate and angle values. In particular, this fixes a crash in gimp_transform_grid_tool_get_cursor() as a result of a NaN angle value being converted to a negative integer, hitting an assert.
2019-03-30 23:11:10 +08:00
angle = acos (SAFE_CLAMP (dotprod (a, b) / length, -1.0, +1.0));
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
angle2 = b.y;
b.y = -b.x;
b.x = angle2;
Issue #2090 - Crash when using transform tools In GimpTransformGridTool, avoid producing non-finite coordinate and angle values. In particular, this fixes a crash in gimp_transform_grid_tool_get_cursor() as a result of a NaN angle value being converted to a negative integer, hitting an assert.
2019-03-30 23:11:10 +08:00
angle2 = acos (SAFE_CLAMP (dotprod (a, b) / length, -1.0, +1.0));
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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,
app: use gimp_transform_polygon() in GimpCanvasTransformGuides Add a "clip" property to GimpCavnasTransformGuides. When set, use gimp_transform_polygon() for transforming the guides and the bounding box, so that they're properly clipped. Add a corresponding "clip-guides" property to GimpToolTransformGrid, and set it to TRUE in GimpToolHandleGrid, so that the handle-transform tool's guides are clipped properly.
2018-01-29 02:39:00 +08:00
private->n_guides,
private->clip_guides);
app: add show-guides property to GimpToolTransformGrid ... which can be used to control the guides' visibility. Will be used by the next commit, to hide the guides in GimpToolHandleGrid when the tranformation is invalid.
2018-01-27 20:15:05 +08:00
gimp_canvas_item_set_visible (private->guides, private->show_guides);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
app: don't set properties of invisible handles in GimpToolTransformGrid This avoids warnings when the handle positions the handle-transform tool result in a matrix that transforms the TransformGrid's handles (which are all invisible) to coordinates that are outside of the corresponding properties' range.
2018-02-05 03:37:58 +08:00
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);
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
/* 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);
app: don't set properties of invisible handles in GimpToolTransformGrid This avoids warnings when the handle positions the handle-transform tool result in a matrix that transforms the TransformGrid's handles (which are all invisible) to coordinates that are outside of the corresponding properties' range.
2018-02-05 03:37:58 +08:00
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);
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
/* 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);
app: don't set properties of invisible handles in GimpToolTransformGrid This avoids warnings when the handle positions the handle-transform tool result in a matrix that transforms the TransformGrid's handles (which are all invisible) to coordinates that are outside of the corresponding properties' range.
2018-02-05 03:37:58 +08:00
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);
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
/* 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);
Bug 777485 - Move unified transform tool shear handles to places... ...corresponding to the spec
2017-07-09 00:21:33 +08:00
t[3] = scalemult (vectoradd (scalemult (o[0], 3.0), o[2] ),
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
app: don't set properties of invisible handles in GimpToolTransformGrid This avoids warnings when the handle positions the handle-transform tool result in a matrix that transforms the TransformGrid's handles (which are all invisible) to coordinates that are outside of the corresponding properties' range.
2018-02-05 03:37:58 +08:00
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);
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
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);
app: don't set properties of invisible handles in GimpToolTransformGrid This avoids warnings when the handle positions the handle-transform tool result in a matrix that transforms the TransformGrid's handles (which are all invisible) to coordinates that are outside of the corresponding properties' range.
2018-02-05 03:37:58 +08:00
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);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
app: don't set properties of invisible handles in GimpToolTransformGrid This avoids warnings when the handle positions the handle-transform tool result in a matrix that transforms the TransformGrid's handles (which are all invisible) to coordinates that are outside of the corresponding properties' range.
2018-02-05 03:37:58 +08:00
gimp_canvas_handle_set_position (private->pivot_items[1],
private->tpx, private->tpy);
gimp_canvas_handle_set_size (private->pivot_items[1], d, d);
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
d = MIN (handle_w, handle_h);
gimp_canvas_item_set_visible (private->handles[GIMP_TRANSFORM_HANDLE_CENTER],
private->use_center_handle);
app: don't set properties of invisible handles in GimpToolTransformGrid This avoids warnings when the handle positions the handle-transform tool result in a matrix that transforms the TransformGrid's handles (which are all invisible) to coordinates that are outside of the corresponding properties' range.
2018-02-05 03:37:58 +08:00
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);
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: implement GimpToolActiveModifiers in GimpTool Change gimp_tool_set_active_modifier_state() to honor the new GimpToolControlSetting. Explicitly set the mode to SEPARATE in all tools that require modifier keys during a stroke. And here comes the actual fix: change GimpTransformTool and GimpToolTransformGrid to use SAME mode, and remove their active_modifer_key() and hover_modifier() impls, so it makes no difference whether a modifier is pressed before of after mouse button press/release.
2017-10-29 23:38:24 +08:00
private->button_down = TRUE;
private->mousex = coords->x;
private->mousey = coords->y;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
app: store the snap offsets in GimpToolWidget Rename gimp_tool_widget_snap_offsets() to set_snap_offsets(), and add gimp_tool_widget_get_snap_offsets(). Also rename gimp_tool_widget_status() to set_status(), and add new function and signal set_status_coords().
2017-06-25 03:09:18 +08:00
gimp_tool_widget_set_snap_offsets (widget,
SIGNED_ROUND (x - coords->x),
SIGNED_ROUND (y - coords->y),
0, 0);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
else
{
app: store the snap offsets in GimpToolWidget Rename gimp_tool_widget_snap_offsets() to set_snap_offsets(), and add gimp_tool_widget_get_snap_offsets(). Also rename gimp_tool_widget_status() to set_status(), and add new function and signal set_status_coords().
2017-06-25 03:09:18 +08:00
gimp_tool_widget_set_snap_offsets (widget, 0, 0, 0, 0);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
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;
}
app: store the snap offsets in GimpToolWidget Rename gimp_tool_widget_snap_offsets() to set_snap_offsets(), and add gimp_tool_widget_get_snap_offsets(). Also rename gimp_tool_widget_status() to set_status(), and add new function and signal set_status_coords().
2017-06-25 03:09:18 +08:00
gimp_tool_widget_set_snap_offsets (widget, 0, 0, 0, 0);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
return 0;
}
void
gimp_tool_transform_grid_button_release (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type)
{
app: implement GimpToolActiveModifiers in GimpTool Change gimp_tool_set_active_modifier_state() to honor the new GimpToolControlSetting. Explicitly set the mode to SEPARATE in all tools that require modifier keys during a stroke. And here comes the actual fix: change GimpTransformTool and GimpToolTransformGrid to use SAME mode, and remove their active_modifer_key() and hover_modifier() impls, so it makes no difference whether a modifier is pressed before of after mouse button press/release.
2017-10-29 23:38:24 +08:00
GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget);
GimpToolTransformGridPrivate *private = grid->private;
private->button_down = FALSE;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
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 */
app: fix transform-grid center point for non-affine transforms; use as pivot In GimpToolTransformGrid, use the transformed center-point of the original polygon as the position of the center-point handle, and as a snapping point for the pivot when "cornersnap" is TRUE, instead of using the center-point of the transformed polygon. These two points are different for non-affine transformations. Furthermore, when "use-pivot-handle" is FALSE, use the center- point as the reference point when transforming around the pivot, instead of the pivot itself, which might not be set. In particular, this fixes transformation around the pivot in the perspective tool. Don't explicitly set the center-point as the pivot in the scale tool, since this commit makes it unnecessary.
2019-03-01 04:21:40 +08:00
oldpos[4].x = private->prev_tcx;
oldpos[4].y = private->prev_tcy;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
d = vectorsubtract (cur, mouse);
newpivot_x = &private->tpx;
newpivot_y = &private->tpy;
app: fix transform-grid center point for non-affine transforms; use as pivot In GimpToolTransformGrid, use the transformed center-point of the original polygon as the position of the center-point handle, and as a snapping point for the pivot when "cornersnap" is TRUE, instead of using the center-point of the transformed polygon. These two points are different for non-affine transformations. Furthermore, when "use-pivot-handle" is FALSE, use the center- point as the reference point when transforming around the pivot, instead of the pivot itself, which might not be set. In particular, this fixes transformation around the pivot in the perspective tool. Don't explicitly set the center-point as the pivot in the scale tool, since this commit makes it unnecessary.
2019-03-01 04:21:40 +08:00
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;
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
/* 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
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert_not_reached ();
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
/* when the keep aspect transformation constraint is enabled,
* the translation shall only be along the diagonal that runs
Fix typos Found via: ``` codespell -q 3 -S ./ChangeLog*,*.po,./.git,./NEWS* -L als,ang,ba,chello,daa,doubleclick,foto,hist,iff,inport,klass,mut,nd,ower,paeth,params,pard,pevent,sinc,thru,tim,uint ```
2020-11-06 00:43:53 +08:00
* through this corner point.
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
*/
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
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert_not_reached ();
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert_not_reached ();
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert_not_reached ();
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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
Fix typos Found via: ``` codespell -q 3 -S ./ChangeLog*,*.po,./.git,./NEWS* -L als,ang,ba,chello,daa,doubleclick,foto,hist,iff,inport,klass,mut,nd,ower,paeth,params,pard,pevent,sinc,thru,tim,uint ```
2020-11-06 00:43:53 +08:00
* along the diagonal that runs through this corner point.
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
*/
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);
}
Issue #2090 - Crash when using transform tools In GimpTransformGridTool, avoid producing non-finite coordinate and angle values. In particular, this fixes a crash in gimp_transform_grid_tool_get_cursor() as a result of a NaN angle value being converted to a negative integer, hitting an assert.
2019-03-30 23:11:10 +08:00
/* 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;
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
/* 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:
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert_not_reached ();
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
}
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)
{
app: in GimpToolTransformGrid, add NONE function In GimpToolTransformGrid, allow setting "inside-function" and "outside-function" to a new NONE value, performing no transformation when dragging the respective area.
2020-01-06 22:30:58 +08:00
case GIMP_TRANSFORM_FUNCTION_NONE:
break;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
}
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
GimpHit
gimp_tool_transform_grid_hit (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity)
{
GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget);
GimpTransformHandle handle;
app: add a protected gimp_tool_transform_grid_get_handle() function ... which can be used by subclasses to retrieve the currently- active handle.
2020-01-06 22:37:12 +08:00
handle = gimp_tool_transform_grid_get_handle_for_coords (grid, coords);
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
if (handle != GIMP_TRANSFORM_HANDLE_NONE)
return GIMP_HIT_DIRECT;
return GIMP_HIT_INDIRECT;
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
GimpTransformHandle handle;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
app: add a protected gimp_tool_transform_grid_get_handle() function ... which can be used by subclasses to retrieve the currently- active handle.
2020-01-06 22:37:12 +08:00
handle = gimp_tool_transform_grid_get_handle_for_coords (grid, coords);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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);
}
}
app: clear GimpToolTransformGrid's status when we leave proximity
2017-06-20 06:23:25 +08:00
if (handle != GIMP_TRANSFORM_HANDLE_NONE && proximity)
{
app: store the snap offsets in GimpToolWidget Rename gimp_tool_widget_snap_offsets() to set_snap_offsets(), and add gimp_tool_widget_get_snap_offsets(). Also rename gimp_tool_widget_status() to set_status(), and add new function and signal set_status_coords().
2017-06-25 03:09:18 +08:00
gimp_tool_widget_set_status (widget,
get_friendly_operation_name (handle));
app: clear GimpToolTransformGrid's status when we leave proximity
2017-06-20 06:23:25 +08:00
}
else
{
app: store the snap offsets in GimpToolWidget Rename gimp_tool_widget_snap_offsets() to set_snap_offsets(), and add gimp_tool_widget_get_snap_offsets(). Also rename gimp_tool_widget_status() to set_status(), and add new function and signal set_status_coords().
2017-06-25 03:09:18 +08:00
gimp_tool_widget_set_status (widget, NULL);
app: clear GimpToolTransformGrid's status when we leave proximity
2017-06-20 06:23:25 +08:00
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
private->handle = handle;
gimp_tool_transform_grid_update_hilight (grid);
}
app: implement GimpToolWidget::leave_notify() in various tool widgets ... by having them disable item highlights, and any other proximity indication, when the cursor leaves the widget.
2018-06-02 13:50:50 +08:00
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);
}
app: make GimpToolTransformGrid handle modifiers itself and update the grid as soon as a constraint is changed, not only on the next motion. Change GimpTransformTool to forward the events to the widget if it exists, but still handle them if it doesn't (yes this code duplication is ugly, but the widget can hardly handle events if it doesn't exist...).
2017-07-16 01:34:08 +08:00
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
app: implement GimpToolActiveModifiers in GimpTool Change gimp_tool_set_active_modifier_state() to honor the new GimpToolControlSetting. Explicitly set the mode to SEPARATE in all tools that require modifier keys during a stroke. And here comes the actual fix: change GimpTransformTool and GimpToolTransformGrid to use SAME mode, and remove their active_modifer_key() and hover_modifier() impls, so it makes no difference whether a modifier is pressed before of after mouse button press/release.
2017-10-29 23:38:24 +08:00
gimp_tool_transform_grid_hover_modifier (GimpToolWidget *widget,
GdkModifierType key,
gboolean press,
GdkModifierType state)
app: make GimpToolTransformGrid handle modifiers itself and update the grid as soon as a constraint is changed, not only on the next motion. Change GimpTransformTool to forward the events to the widget if it exists, but still handle them if it doesn't (yes this code duplication is ugly, but the widget can hardly handle events if it doesn't exist...).
2017-07-16 01:34:08 +08:00
{
GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget);
GimpToolTransformGridPrivate *private = grid->private;
GimpCoords coords = { 0.0, };
gimp_tool_transform_grid_modifier (widget, key);
app: implement GimpToolActiveModifiers in GimpTool Change gimp_tool_set_active_modifier_state() to honor the new GimpToolControlSetting. Explicitly set the mode to SEPARATE in all tools that require modifier keys during a stroke. And here comes the actual fix: change GimpTransformTool and GimpToolTransformGrid to use SAME mode, and remove their active_modifer_key() and hover_modifier() impls, so it makes no difference whether a modifier is pressed before of after mouse button press/release.
2017-10-29 23:38:24 +08:00
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);
}
app: make GimpToolTransformGrid handle modifiers itself and update the grid as soon as a constraint is changed, not only on the next motion. Change GimpTransformTool to forward the events to the widget if it exists, but still handle them if it doesn't (yes this code duplication is ugly, but the widget can hardly handle events if it doesn't exist...).
2017-07-16 01:34:08 +08:00
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
static gboolean
gimp_tool_transform_grid_get_cursor (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
GimpCursorType *cursor,
GimpToolCursorType *tool_cursor,
app: gimp_tool_widget_get_cursor(): rename "cursor_modifier" to just "modifier" The same in all subclasses.
2017-06-27 04:13:00 +08:00
GimpCursorModifier *modifier)
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
{
GimpToolTransformGrid *grid = GIMP_TOOL_TRANSFORM_GRID (widget);
GimpToolTransformGridPrivate *private = grid->private;
Bug 784643 - Crash when using transform tools Fix buffer overflow in gimp_tool_transform_grid_get_cursor().
2017-09-12 02:59:44 +08:00
gdouble angle[9];
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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:
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert_not_reached ();
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
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;
app: gimp_tool_widget_get_cursor(): rename "cursor_modifier" to just "modifier" The same in all subclasses.
2017-06-27 04:13:00 +08:00
*modifier = GIMP_CURSOR_MODIFIER_MOVE;
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
}
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
static GimpTransformHandle
app: add a protected gimp_tool_transform_grid_get_handle() function ... which can be used by subclasses to retrieve the currently- active handle.
2020-01-06 22:37:12 +08:00
gimp_tool_transform_grid_get_handle_for_coords (GimpToolTransformGrid *grid,
const GimpCoords *coords)
app: implement GimpToolWidget::hit() in all tool widgets ... and move the common functionality of their hit() and hover() implementation to a separate function.
2018-06-03 16:45:36 +08:00
{
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;
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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;
app: fix transform-grid center point for non-affine transforms; use as pivot In GimpToolTransformGrid, use the transformed center-point of the original polygon as the position of the center-point handle, and as a snapping point for the pivot when "cornersnap" is TRUE, instead of using the center-point of the transformed polygon. These two points are different for non-affine transformations. Furthermore, when "use-pivot-handle" is FALSE, use the center- point as the reference point when transforming around the pivot, instead of the pivot itself, which might not be set. In particular, this fixes transformation around the pivot in the perspective tool. Don't explicitly set the center-point as the pivot in the scale tool, since this commit makes it unnecessary.
2019-03-01 04:21:40 +08:00
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;
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
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;
app: add GimpTransformGridTool::dynamic-handle-size property Add a boolean GimpTransformGridTool::dynamic-handle-size property, which controls whether the handle sizes are adjustment dynamically according to the grid's size, or remain fixed. This property is TRUE by default, to maintain the current behavior.
2020-01-06 22:35:01 +08:00
if (! private->dynamic_handle_size)
{
*handle_w = GIMP_CANVAS_HANDLE_SIZE_LARGE;
*handle_h = GIMP_CANVAS_HANDLE_SIZE_LARGE;
return;
}
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
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,
app: add #defines of standard handle sizes to gimpcanvashandle.h The same values as in gimpdrawtool.h, tool widgets in display/ must not include the draw tool header from tools/.
2017-06-19 16:46:05 +08:00
MIN_HANDLE_SIZE, GIMP_CANVAS_HANDLE_SIZE_LARGE);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
*handle_h = CLAMP ((y2 - y1) / 3,
app: add #defines of standard handle sizes to gimpcanvashandle.h The same values as in gimpdrawtool.h, tool widgets in display/ must not include the draw tool header from tools/.
2017-06-19 16:46:05 +08:00
MIN_HANDLE_SIZE, GIMP_CANVAS_HANDLE_SIZE_LARGE);
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
}
/* public functions */
GimpToolWidget *
gimp_tool_transform_grid_new (GimpDisplayShell *shell,
const GimpMatrix3 *transform,
gdouble x1,
gdouble y1,
gdouble x2,
app: manage the transform tools' grid properties in GimpTransformTool Simply use g_object_bind_property() to connect the grid properties of GimpTransformOoptions and GimpToolTransformGrid and remove all other grid property setting code.
2017-06-20 05:06:39 +08:00
gdouble y2)
app: add GimpToolTransformGrid, GimpToolRotateGrid and GimpToolShearGrid which do all transform tools' (except handle transform) canvas GUI and their interaction.
2017-06-17 08:34:35 +08:00
{
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);
}
app: add a protected gimp_tool_transform_grid_get_handle() function ... which can be used by subclasses to retrieve the currently- active handle.
2020-01-06 22:37:12 +08:00
/* 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;
}