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

1174 lines
40 KiB
C
Raw Normal View History

app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimptoolcompass.c
* Copyright (C) 2017 Michael Natterer <mitch@gimp.org>
*
* Measure tool
* Copyright (C) 1999-2003 Sven Neumann <sven@gimp.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 GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +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-utils.h"
#include "core/gimpimage.h"
#include "core/gimpmarshal.h"
#include "widgets/gimpwidgets-utils.h"
#include "gimpcanvashandle.h"
#include "gimpcanvasline.h"
#include "gimpdisplay.h"
#include "gimpdisplayshell.h"
#include "gimpdisplayshell-appearance.h"
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
#include "gimpdisplayshell-transform.h"
app: constrain line angles in display space, not image space Add an offset_angle parameter to gimp_constrain_line(), which offsets the radial lines by a given angle. Add gimpdisplayshell-utils.[ch], with two new functions: - gimp_display_shell_get_constrained_line_offset_angle(): Returns the offset angle to be passed to gimp_constrain_line(), in order to constrain line angles in display space, according to the shell's rotation angle and flip mode. - gimp_display_shell_constrain_line(): A convenience function which calls gimp_constrain_line() with the said offset angle. Use the new functions in all instances where we constrain line angles, so that angles are constrained in display space, rather than image space. The only exception is GimpEditSelectionTool, which keeps constraining angles in image space, since it's not entirely obvious that we want to constrain angles of dragged layers/selections in display space.
2017-12-22 18:56:11 +08:00
#include "gimpdisplayshell-utils.h"
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
#include "gimptoolcompass.h"
#include "gimp-intl.h"
#define ARC_RADIUS 30
app: in GimpToolCompass, add visual distinction between angle lines When using a GimpToolCompass in 3-point mode, add a small gap after the angle arc to the line corresponding to the "second" non-origin point, so that it's visually distinguishable from the line corresponding to the "first" point. This has significance for the measure tool, since it determines the direction of the rotation when straightening the image (the first point is rotated toward the second point.)
2018-07-16 14:13:26 +08:00
#define ARC_GAP (ARC_RADIUS / 2)
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
#define EPSILON 1e-6
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
/* possible measure functions */
typedef enum
{
CREATING,
ADDING,
MOVING,
MOVING_ALL,
GUIDING,
FINISHED
} CompassFunction;
enum
{
PROP_0,
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
PROP_ORIENTATION,
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
PROP_N_POINTS,
PROP_X1,
PROP_Y1,
PROP_X2,
PROP_Y2,
PROP_X3,
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
PROP_Y3,
PROP_PIXEL_ANGLE,
PROP_UNIT_ANGLE
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
};
enum
{
CREATE_GUIDES,
LAST_SIGNAL
};
struct _GimpToolCompassPrivate
{
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
GimpCompassOrientation orientation;
gint n_points;
gint x[3];
gint y[3];
GimpVector2 radius1;
GimpVector2 radius2;
gdouble display_angle;
gdouble pixel_angle;
gdouble unit_angle;
CompassFunction function;
gdouble mouse_x;
gdouble mouse_y;
gint last_x;
gint last_y;
gint point;
GimpCanvasItem *line1;
GimpCanvasItem *line2;
GimpCanvasItem *arc;
GimpCanvasItem *arc_line;
GimpCanvasItem *handles[3];
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
};
/* local function prototypes */
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
static void gimp_tool_compass_constructed (GObject *object);
static void gimp_tool_compass_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_tool_compass_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_tool_compass_changed (GimpToolWidget *widget);
static gint gimp_tool_compass_button_press (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type);
static void gimp_tool_compass_button_release (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type);
static void gimp_tool_compass_motion (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state);
static GimpHit gimp_tool_compass_hit (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity);
static void gimp_tool_compass_hover (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity);
static void gimp_tool_compass_leave_notify (GimpToolWidget *widget);
static void gimp_tool_compass_motion_modifier (GimpToolWidget *widget,
GdkModifierType key,
gboolean press,
GdkModifierType state);
static gboolean gimp_tool_compass_get_cursor (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
GimpCursorType *cursor,
GimpToolCursorType *tool_cursor,
GimpCursorModifier *modifier);
static gint gimp_tool_compass_get_point (GimpToolCompass *compass,
const GimpCoords *coords);
static void gimp_tool_compass_update_hilight (GimpToolCompass *compass);
static void gimp_tool_compass_update_angle (GimpToolCompass *compass,
GimpCompassOrientation orientation,
gboolean flip);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
G_DEFINE_TYPE (GimpToolCompass, gimp_tool_compass, GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_compass_parent_class
static guint compass_signals[LAST_SIGNAL] = { 0 };
static void
gimp_tool_compass_class_init (GimpToolCompassClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolWidgetClass *widget_class = GIMP_TOOL_WIDGET_CLASS (klass);
object_class->constructed = gimp_tool_compass_constructed;
object_class->set_property = gimp_tool_compass_set_property;
object_class->get_property = gimp_tool_compass_get_property;
widget_class->changed = gimp_tool_compass_changed;
widget_class->button_press = gimp_tool_compass_button_press;
widget_class->button_release = gimp_tool_compass_button_release;
widget_class->motion = gimp_tool_compass_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_compass_hit;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
widget_class->hover = gimp_tool_compass_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_compass_leave_notify;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
widget_class->motion_modifier = gimp_tool_compass_motion_modifier;
widget_class->get_cursor = gimp_tool_compass_get_cursor;
compass_signals[CREATE_GUIDES] =
g_signal_new ("create-guides",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolCompassClass, create_guides),
NULL, NULL,
gimp_marshal_VOID__INT_INT_BOOLEAN_BOOLEAN,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
g_object_class_install_property (object_class, PROP_ORIENTATION,
g_param_spec_enum ("orientation", NULL, NULL,
GIMP_TYPE_COMPASS_ORIENTATION,
GIMP_COMPASS_ORIENTATION_AUTO,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
g_object_class_install_property (object_class, PROP_N_POINTS,
g_param_spec_int ("n-points", NULL, NULL,
1, 3, 1,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_X1,
g_param_spec_int ("x1", NULL, NULL,
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_Y1,
g_param_spec_int ("y1", NULL, NULL,
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_X2,
g_param_spec_int ("x2", NULL, NULL,
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_Y2,
g_param_spec_int ("y2", NULL, NULL,
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_X3,
g_param_spec_int ("x3", NULL, NULL,
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_Y3,
g_param_spec_int ("y3", NULL, NULL,
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
g_object_class_install_property (object_class, PROP_PIXEL_ANGLE,
g_param_spec_double ("pixel-angle", NULL, NULL,
-G_PI, G_PI, 0.0,
GIMP_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_UNIT_ANGLE,
g_param_spec_double ("unit-angle", NULL, NULL,
-G_PI, G_PI, 0.0,
GIMP_PARAM_READABLE));
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
g_type_class_add_private (klass, sizeof (GimpToolCompassPrivate));
}
static void
gimp_tool_compass_init (GimpToolCompass *compass)
{
compass->private = G_TYPE_INSTANCE_GET_PRIVATE (compass,
GIMP_TYPE_TOOL_COMPASS,
GimpToolCompassPrivate);
compass->private->point = -1;
}
static void
gimp_tool_compass_constructed (GObject *object)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (object);
GimpToolWidget *widget = GIMP_TOOL_WIDGET (object);
GimpToolCompassPrivate *private = compass->private;
GimpCanvasGroup *stroke_group;
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
gint i;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
G_OBJECT_CLASS (parent_class)->constructed (object);
stroke_group = gimp_tool_widget_add_stroke_group (widget);
gimp_tool_widget_push_group (widget, stroke_group);
private->line1 = gimp_tool_widget_add_line (widget,
private->x[0],
private->y[0],
private->x[1],
private->y[1]);
private->line2 = gimp_tool_widget_add_line (widget,
private->x[0],
private->y[0],
private->x[2],
private->y[2]);
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
private->arc = gimp_tool_widget_add_handle (widget,
GIMP_HANDLE_CIRCLE,
private->x[0],
private->y[0],
ARC_RADIUS * 2 + 1,
ARC_RADIUS * 2 + 1,
GIMP_HANDLE_ANCHOR_CENTER);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
private->arc_line = gimp_tool_widget_add_line (widget,
private->x[0],
private->y[0],
private->x[0] + 10,
private->y[0]);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
gimp_tool_widget_pop_group (widget);
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
for (i = 0; i < 3; i++)
{
private->handles[i] =
gimp_tool_widget_add_handle (widget,
i == 0 ?
GIMP_HANDLE_CIRCLE : GIMP_HANDLE_CROSS,
private->x[i],
private->y[i],
GIMP_CANVAS_HANDLE_SIZE_CROSS,
GIMP_CANVAS_HANDLE_SIZE_CROSS,
GIMP_HANDLE_ANCHOR_CENTER);
}
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
gimp_tool_compass_changed (widget);
}
static void
gimp_tool_compass_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (object);
GimpToolCompassPrivate *private = compass->private;
switch (property_id)
{
case PROP_N_POINTS:
private->n_points = g_value_get_int (value);
break;
case PROP_X1:
private->x[0] = g_value_get_int (value);
break;
case PROP_Y1:
private->y[0] = g_value_get_int (value);
break;
case PROP_X2:
private->x[1] = g_value_get_int (value);
break;
case PROP_Y2:
private->y[1] = g_value_get_int (value);
break;
case PROP_X3:
private->x[2] = g_value_get_int (value);
break;
case PROP_Y3:
private->y[2] = g_value_get_int (value);
break;
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
case PROP_ORIENTATION:
private->orientation = g_value_get_enum (value);
break;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_tool_compass_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (object);
GimpToolCompassPrivate *private = compass->private;
switch (property_id)
{
case PROP_N_POINTS:
g_value_set_int (value, private->n_points);
break;
case PROP_X1:
g_value_set_int (value, private->x[0]);
break;
case PROP_Y1:
g_value_set_int (value, private->y[0]);
break;
case PROP_X2:
g_value_set_int (value, private->x[1]);
break;
case PROP_Y2:
g_value_set_int (value, private->y[1]);
break;
case PROP_X3:
g_value_set_int (value, private->x[2]);
break;
case PROP_Y3:
g_value_set_int (value, private->y[2]);
break;
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
case PROP_ORIENTATION:
g_value_set_enum (value, private->orientation);
break;
case PROP_PIXEL_ANGLE:
g_value_set_double (value, private->pixel_angle);
break;
case PROP_UNIT_ANGLE:
g_value_set_double (value, private->unit_angle);
break;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_tool_compass_changed (GimpToolWidget *widget)
{
app: in GimpToolCompass, add visual distinction between angle lines When using a GimpToolCompass in 3-point mode, add a small gap after the angle arc to the line corresponding to the "second" non-origin point, so that it's visually distinguishable from the line corresponding to the "first" point. This has significance for the measure tool, since it determines the direction of the rotation when straightening the image (the first point is rotated toward the second point.)
2018-07-16 14:13:26 +08:00
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->private;
GimpDisplayShell *shell = gimp_tool_widget_get_shell (widget);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
gdouble angle1;
gdouble angle2;
app: in GimpToolCompass, add visual distinction between angle lines When using a GimpToolCompass in 3-point mode, add a small gap after the angle arc to the line corresponding to the "second" non-origin point, so that it's visually distinguishable from the line corresponding to the "first" point. This has significance for the measure tool, since it determines the direction of the rotation when straightening the image (the first point is rotated toward the second point.)
2018-07-16 14:13:26 +08:00
gint draw_arc = 0;
gboolean draw_arc_line = FALSE;
gdouble arc_line_display_length;
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
gdouble arc_line_length;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
gimp_tool_compass_update_angle (compass, private->orientation, FALSE);
angle1 = -atan2 (private->radius1.y * shell->scale_y,
private->radius1.x * shell->scale_x);
angle2 = -private->display_angle;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
gimp_canvas_line_set (private->line1,
private->x[0],
private->y[0],
private->x[1],
private->y[1]);
gimp_canvas_item_set_visible (private->line1, private->n_points > 1);
if (private->n_points > 1 &&
gimp_canvas_item_transform_distance (private->line1,
private->x[0],
private->y[0],
private->x[1],
private->y[1]) > ARC_RADIUS)
{
draw_arc++;
}
app: in GimpToolCompass, add visual distinction between angle lines When using a GimpToolCompass in 3-point mode, add a small gap after the angle arc to the line corresponding to the "second" non-origin point, so that it's visually distinguishable from the line corresponding to the "first" point. This has significance for the measure tool, since it determines the direction of the rotation when straightening the image (the first point is rotated toward the second point.)
2018-07-16 14:13:26 +08:00
arc_line_display_length = ARC_RADIUS +
(GIMP_CANVAS_HANDLE_SIZE_CROSS >> 1) +
ARC_GAP;
arc_line_length = arc_line_display_length /
hypot (private->radius2.x * shell->scale_x,
private->radius2.y * shell->scale_y);
if (private->n_points > 2)
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
{
app: in GimpToolCompass, add visual distinction between angle lines When using a GimpToolCompass in 3-point mode, add a small gap after the angle arc to the line corresponding to the "second" non-origin point, so that it's visually distinguishable from the line corresponding to the "first" point. This has significance for the measure tool, since it determines the direction of the rotation when straightening the image (the first point is rotated toward the second point.)
2018-07-16 14:13:26 +08:00
gdouble length = gimp_canvas_item_transform_distance (private->line2,
private->x[0],
private->y[0],
private->x[2],
private->y[2]);
if (length > ARC_RADIUS)
{
draw_arc++;
draw_arc_line = TRUE;
if (length > arc_line_display_length)
{
gimp_canvas_line_set (
private->line2,
private->x[0] + private->radius2.x * arc_line_length,
private->y[0] + private->radius2.y * arc_line_length,
private->x[2],
private->y[2]);
gimp_canvas_item_set_visible (private->line2, TRUE);
}
else
{
gimp_canvas_item_set_visible (private->line2, FALSE);
}
}
else
{
gimp_canvas_line_set (private->line2,
private->x[0],
private->y[0],
private->x[2],
private->y[2]);
gimp_canvas_item_set_visible (private->line2, TRUE);
}
}
else
{
gimp_canvas_item_set_visible (private->line2, FALSE);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
}
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
gimp_canvas_handle_set_position (private->arc,
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
private->x[0], private->y[0]);
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
gimp_canvas_handle_set_angles (private->arc, angle1, angle2);
gimp_canvas_item_set_visible (private->arc,
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
private->n_points > 1 &&
draw_arc == private->n_points - 1 &&
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
fabs (angle2) > EPSILON);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
arc_line_length = (ARC_RADIUS + (GIMP_CANVAS_HANDLE_SIZE_CROSS >> 1)) /
hypot (private->radius2.x * shell->scale_x,
private->radius2.y * shell->scale_y);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
gimp_canvas_line_set (private->arc_line,
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
private->x[0],
private->y[0],
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
private->x[0] + private->radius2.x * arc_line_length,
private->y[0] + private->radius2.y * arc_line_length);
gimp_canvas_item_set_visible (private->arc_line,
app: in GimpToolCompass, add visual distinction between angle lines When using a GimpToolCompass in 3-point mode, add a small gap after the angle arc to the line corresponding to the "second" non-origin point, so that it's visually distinguishable from the line corresponding to the "first" point. This has significance for the measure tool, since it determines the direction of the rotation when straightening the image (the first point is rotated toward the second point.)
2018-07-16 14:13:26 +08:00
(private->n_points == 2 || draw_arc_line) &&
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
fabs (angle2) > EPSILON);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
gimp_canvas_handle_set_position (private->handles[0],
private->x[0], private->y[0]);
gimp_canvas_item_set_visible (private->handles[0],
private->n_points > 0);
gimp_canvas_handle_set_position (private->handles[1],
private->x[1], private->y[1]);
gimp_canvas_item_set_visible (private->handles[1],
private->n_points > 1);
gimp_canvas_handle_set_position (private->handles[2],
private->x[2], private->y[2]);
gimp_canvas_item_set_visible (private->handles[2],
private->n_points > 2);
gimp_tool_compass_update_hilight (compass);
}
app: change return value of GimpToolWidget::button_press() from gboolean to gint so widgets can return which handle was clicked. The values boolean semantics stay the same so if(retval) gives the same result. This is useful for the upcoming transform tool widgets.
2017-06-17 02:55:02 +08:00
gint
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
gimp_tool_compass_button_press (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->private;
private->function = CREATING;
private->mouse_x = coords->x;
private->mouse_y = coords->y;
/* if the cursor is in one of the handles, the new function will be
* moving or adding a new point or guide
*/
if (private->point != -1)
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
if (state & (toggle_mask | GDK_MOD1_MASK))
{
gboolean create_hguide = (state & toggle_mask);
gboolean create_vguide = (state & GDK_MOD1_MASK);
g_signal_emit (compass, compass_signals[CREATE_GUIDES], 0,
private->x[private->point],
private->y[private->point],
create_hguide,
create_vguide);
private->function = GUIDING;
}
else
{
if (private->n_points == 1 || (state & extend_mask))
private->function = ADDING;
else
private->function = MOVING;
}
}
/* adding to the middle point makes no sense */
if (private->point == 0 &&
private->function == ADDING &&
private->n_points == 3)
{
private->function = MOVING;
}
/* if the function is still CREATING, we are outside the handles */
if (private->function == CREATING)
{
if (private->n_points > 1 && (state & GDK_MOD1_MASK))
{
private->function = MOVING_ALL;
private->last_x = coords->x;
private->last_y = coords->y;
}
}
if (private->function == CREATING)
{
/* set the first point and go into ADDING mode */
g_object_set (compass,
"n-points", 1,
"x1", (gint) (coords->x + 0.5),
"y1", (gint) (coords->y + 0.5),
"x2", 0,
"y2", 0,
"x3", 0,
"y3", 0,
NULL);
private->point = 0;
private->function = ADDING;
}
app: change return value of GimpToolWidget::button_press() from gboolean to gint so widgets can return which handle was clicked. The values boolean semantics stay the same so if(retval) gives the same result. This is useful for the upcoming transform tool widgets.
2017-06-17 02:55:02 +08:00
return 1;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
}
void
gimp_tool_compass_button_release (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->private;
private->function = FINISHED;
}
void
gimp_tool_compass_motion (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->private;
gint new_n_points;
gint new_x[3];
gint new_y[3];
gint dx, dy;
gint tmp;
private->mouse_x = coords->x;
private->mouse_y = coords->y;
/* A few comments here, because this routine looks quite weird at first ...
*
* The goal is to keep point 0, called the start point, to be
* always the one in the middle or, if there are only two points,
* the one that is fixed. The angle is then always measured at
* this point.
*/
new_n_points = private->n_points;
new_x[0] = private->x[0];
new_y[0] = private->y[0];
new_x[1] = private->x[1];
new_y[1] = private->y[1];
new_x[2] = private->x[2];
new_y[2] = private->y[2];
switch (private->function)
{
case ADDING:
switch (private->point)
{
case 0:
/* we are adding to the start point */
break;
case 1:
/* we are adding to the end point, make it the new start point */
new_x[0] = private->x[1];
new_y[0] = private->y[1];
new_x[1] = private->x[0];
new_y[1] = private->y[0];
break;
case 2:
/* we are adding to the third point, make it the new start point */
new_x[1] = private->x[0];
new_y[1] = private->y[0];
new_x[0] = private->x[2];
new_y[0] = private->y[2];
break;
default:
break;
}
new_n_points = MIN (new_n_points + 1, 3);
private->point = new_n_points - 1;
private->function = MOVING;
/* don't break here! */
case MOVING:
/* if we are moving the start point and only have two, make it
* the end point
*/
if (new_n_points == 2 && private->point == 0)
{
tmp = new_x[0];
new_x[0] = new_x[1];
new_x[1] = tmp;
tmp = new_y[0];
new_y[0] = new_y[1];
new_y[1] = tmp;
private->point = 1;
}
new_x[private->point] = ROUND (coords->x);
new_y[private->point] = ROUND (coords->y);
if (state & gimp_get_constrain_behavior_mask ())
{
gdouble x = new_x[private->point];
gdouble y = new_y[private->point];
app: constrain line angles in display space, not image space Add an offset_angle parameter to gimp_constrain_line(), which offsets the radial lines by a given angle. Add gimpdisplayshell-utils.[ch], with two new functions: - gimp_display_shell_get_constrained_line_offset_angle(): Returns the offset angle to be passed to gimp_constrain_line(), in order to constrain line angles in display space, according to the shell's rotation angle and flip mode. - gimp_display_shell_constrain_line(): A convenience function which calls gimp_constrain_line() with the said offset angle. Use the new functions in all instances where we constrain line angles, so that angles are constrained in display space, rather than image space. The only exception is GimpEditSelectionTool, which keeps constraining angles in image space, since it's not entirely obvious that we want to constrain angles of dragged layers/selections in display space.
2017-12-22 18:56:11 +08:00
gimp_display_shell_constrain_line (gimp_tool_widget_get_shell (widget),
new_x[0], new_y[0],
&x, &y,
GIMP_CONSTRAIN_LINE_15_DEGREES);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
new_x[private->point] = ROUND (x);
new_y[private->point] = ROUND (y);
}
g_object_set (compass,
"n-points", new_n_points,
"x1", new_x[0],
"y1", new_y[0],
"x2", new_x[1],
"y2", new_y[1],
"x3", new_x[2],
"y3", new_y[2],
NULL);
break;
case MOVING_ALL:
dx = ROUND (coords->x) - private->last_x;
dy = ROUND (coords->y) - private->last_y;
g_object_set (compass,
"x1", new_x[0] + dx,
"y1", new_y[0] + dy,
"x2", new_x[1] + dx,
"y2", new_y[1] + dy,
"x3", new_x[2] + dx,
"y3", new_y[2] + dy,
NULL);
private->last_x = ROUND (coords->x);
private->last_y = ROUND (coords->y);
break;
default:
break;
}
}
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_compass_hit (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
if (gimp_tool_compass_get_point (compass, coords) >= 0)
return GIMP_HIT_DIRECT;
else
return GIMP_HIT_INDIRECT;
}
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
void
gimp_tool_compass_hover (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->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
gint point;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
private->mouse_x = coords->x;
private->mouse_y = coords->y;
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
point = gimp_tool_compass_get_point (compass, coords);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +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
if (point >= 0)
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gchar *status;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +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
if (state & toggle_mask)
{
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
if (state & GDK_MOD1_MASK)
{
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
status = gimp_suggest_modifiers (_("Click to place "
"vertical and "
"horizontal guides"),
0,
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
NULL, NULL, NULL);
}
else
{
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
status = gimp_suggest_modifiers (_("Click to place a "
"horizontal guide"),
GDK_MOD1_MASK & ~state,
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
NULL, NULL, NULL);
}
}
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
else if (state & GDK_MOD1_MASK)
{
status = gimp_suggest_modifiers (_("Click to place a "
"vertical guide"),
toggle_mask & ~state,
NULL, NULL, NULL);
}
else if ((state & extend_mask) &&
! ((point == 0) && (private->n_points == 3)))
{
status = gimp_suggest_modifiers (_("Click-Drag to add a "
"new point"),
(toggle_mask |
GDK_MOD1_MASK) & ~state,
NULL, NULL, NULL);
}
else
{
if ((point == 0) && (private->n_points == 3))
state |= extend_mask;
status = gimp_suggest_modifiers (_("Click-Drag to move this "
"point"),
(extend_mask |
toggle_mask |
GDK_MOD1_MASK) & ~state,
NULL, NULL, NULL);
}
gimp_tool_widget_set_status (widget, status);
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +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
g_free (status);
}
else
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
{
if ((private->n_points > 1) && (state & GDK_MOD1_MASK))
{
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,
_("Click-Drag to move all points"));
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +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: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
}
}
if (point != private->point)
{
private->point = point;
gimp_tool_compass_update_hilight (compass);
}
}
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_compass_leave_notify (GimpToolWidget *widget)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->private;
if (private->point != -1)
{
private->point = -1;
gimp_tool_compass_update_hilight (compass);
}
GIMP_TOOL_WIDGET_CLASS (parent_class)->leave_notify (widget);
}
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
static void
gimp_tool_compass_motion_modifier (GimpToolWidget *widget,
GdkModifierType key,
gboolean press,
GdkModifierType state)
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->private;
if (key == gimp_get_constrain_behavior_mask () &&
private->function == MOVING)
{
gint new_x[3];
gint new_y[3];
gdouble x = private->mouse_x;
gdouble y = private->mouse_y;
new_x[0] = private->x[0];
new_y[0] = private->y[0];
new_x[1] = private->x[1];
new_y[1] = private->y[1];
new_x[2] = private->x[2];
new_y[2] = private->y[2];
if (press)
app: constrain line angles in display space, not image space Add an offset_angle parameter to gimp_constrain_line(), which offsets the radial lines by a given angle. Add gimpdisplayshell-utils.[ch], with two new functions: - gimp_display_shell_get_constrained_line_offset_angle(): Returns the offset angle to be passed to gimp_constrain_line(), in order to constrain line angles in display space, according to the shell's rotation angle and flip mode. - gimp_display_shell_constrain_line(): A convenience function which calls gimp_constrain_line() with the said offset angle. Use the new functions in all instances where we constrain line angles, so that angles are constrained in display space, rather than image space. The only exception is GimpEditSelectionTool, which keeps constraining angles in image space, since it's not entirely obvious that we want to constrain angles of dragged layers/selections in display space.
2017-12-22 18:56:11 +08:00
{
gimp_display_shell_constrain_line (gimp_tool_widget_get_shell (widget),
private->x[0], private->y[0],
&x, &y,
GIMP_CONSTRAIN_LINE_15_DEGREES);
}
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
new_x[private->point] = ROUND (x);
new_y[private->point] = ROUND (y);
g_object_set (compass,
"x1", new_x[0],
"y1", new_y[0],
"x2", new_x[1],
"y2", new_y[1],
"x3", new_x[2],
"y3", new_y[2],
NULL);
}
}
static gboolean
gimp_tool_compass_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 GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
{
GimpToolCompass *compass = GIMP_TOOL_COMPASS (widget);
GimpToolCompassPrivate *private = compass->private;
if (private->point != -1)
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
if (state & toggle_mask)
{
if (state & GDK_MOD1_MASK)
{
*cursor = GIMP_CURSOR_CORNER_BOTTOM_RIGHT;
return TRUE;
}
else
{
*cursor = GIMP_CURSOR_SIDE_BOTTOM;
return TRUE;
}
}
else if (state & GDK_MOD1_MASK)
{
*cursor = GIMP_CURSOR_SIDE_RIGHT;
return TRUE;
}
else if ((state & extend_mask) &&
! ((private->point == 0) &&
(private->n_points == 3)))
{
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_PLUS;
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
return TRUE;
}
else
{
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 GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
return TRUE;
}
}
else
{
if ((private->n_points > 1) && (state & GDK_MOD1_MASK))
{
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 GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
return TRUE;
}
}
return FALSE;
}
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 gint
gimp_tool_compass_get_point (GimpToolCompass *compass,
const GimpCoords *coords)
{
GimpToolCompassPrivate *private = compass->private;
gint i;
for (i = 0; i < private->n_points; i++)
{
if (gimp_canvas_item_hit (private->handles[i],
coords->x, coords->y))
{
return i;
}
}
return -1;
}
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
static void
gimp_tool_compass_update_hilight (GimpToolCompass *compass)
{
GimpToolCompassPrivate *private = compass->private;
gint i;
for (i = 0; i < private->n_points; i++)
{
if (private->handles[i])
{
gimp_canvas_item_set_highlight (private->handles[i],
private->point == i);
}
}
}
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
static void
gimp_tool_compass_update_angle (GimpToolCompass *compass,
GimpCompassOrientation orientation,
gboolean flip)
{
GimpToolWidget *widget = GIMP_TOOL_WIDGET (compass);
GimpToolCompassPrivate *private = compass->private;
GimpDisplayShell *shell = gimp_tool_widget_get_shell (widget);
GimpImage *image = gimp_display_get_image (shell->display);
GimpVector2 radius1;
GimpVector2 radius2;
gdouble xres;
gdouble yres;
gimp_image_get_resolution (image, &xres, &yres);
private->radius1.x = private->x[1] - private->x[0];
private->radius1.y = private->y[1] - private->y[0];
if (private->n_points == 3)
{
private->radius2.x = private->x[2] - private->x[0];
private->radius2.y = private->y[2] - private->y[0];
}
else
{
gdouble angle = -shell->rotate_angle * G_PI / 180.0;
if (orientation == GIMP_COMPASS_ORIENTATION_VERTICAL)
angle -= G_PI / 2.0;
if (flip)
angle += G_PI;
if (shell->flip_horizontally)
angle = G_PI - angle;
if (shell->flip_vertically)
angle = -angle;
private->radius2.x = cos (angle);
private->radius2.y = sin (angle);
if (! shell->dot_for_dot)
{
private->radius2.x *= xres;
private->radius2.y *= yres;
gimp_vector2_normalize (&private->radius2);
}
}
radius1 = private->radius1;
radius2 = private->radius2;
private->pixel_angle = atan2 (gimp_vector2_cross_product (&radius1, &radius2).x,
gimp_vector2_inner_product (&radius1, &radius2));
radius1.x /= xres;
radius1.y /= yres;
radius2.x /= xres;
radius2.y /= yres;
private->unit_angle = atan2 (gimp_vector2_cross_product (&radius1, &radius2).x,
gimp_vector2_inner_product (&radius1, &radius2));
if (shell->dot_for_dot)
private->display_angle = private->pixel_angle;
else
private->display_angle = private->unit_angle;
if (private->n_points == 2)
{
if (! flip && fabs (private->display_angle) > G_PI / 2.0 + EPSILON)
{
gimp_tool_compass_update_angle (compass, orientation, TRUE);
}
else if (orientation == GIMP_COMPASS_ORIENTATION_AUTO &&
fabs (private->display_angle) > G_PI / 4.0 + EPSILON)
{
gimp_tool_compass_update_angle (compass,
GIMP_COMPASS_ORIENTATION_VERTICAL,
FALSE);
}
}
}
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
/* public functions */
GimpToolWidget *
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
gimp_tool_compass_new (GimpDisplayShell *shell,
GimpCompassOrientation orientation,
gint n_points,
gint x1,
gint y1,
gint x2,
gint y2,
gint x3,
gint y3)
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
{
g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), NULL);
return g_object_new (GIMP_TYPE_TOOL_COMPASS,
app: add "orientation" property to GimpToolCompass + improvements Add an "orientation" property to GimpToolCompass, which can be one of "auto", "horizontal", or "vertical", and which controls the orientation of the line against which the angle is measured, when not in 3-point mode (previously, the line would always be horizontal.) When "orientation" is "auto", the orientation is automatically set to either horizontal or vertical, such that the measured angle is <= 45 deg. Keep the line horizontal, or vertical, in display-space, rather than in image-space, so that the compass works correctly even when the canvas is rotated and/or flipped. Fix the compass's behavior when the image's horizontal and vertical resolutions are different, both with and without dot-for-dot. Add "pixel-angle" and "unit-angle" read-only properties, which return the measured angle either with or without taking the image's resolution into account, respectively. These properties will be used by the measure tool in the next commit, instead of having it implement its own angle calculation.
2018-07-16 06:07:54 +08:00
"shell", shell,
"orientation", orientation,
"n-points", n_points,
"x1", x1,
"y1", y1,
"x2", x2,
"y2", y2,
app: add GimpToolCompass, which is the entire canvas GUI of the measure tool
2017-06-12 05:38:55 +08:00
NULL);
}