summaryrefslogtreecommitdiffstats
path: root/app/tools/gimpmeasuretool.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
commit3c57dd931145d43f2b0aef96c4d178135956bf91 (patch)
tree3de698981e9f0cc2c4f9569b19a5f3595e741f6b /app/tools/gimpmeasuretool.c
parentInitial commit. (diff)
downloadgimp-3c57dd931145d43f2b0aef96c4d178135956bf91.tar.xz
gimp-3c57dd931145d43f2b0aef96c4d178135956bf91.zip
Adding upstream version 2.10.36.upstream/2.10.36
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--app/tools/gimpmeasuretool.c890
1 files changed, 890 insertions, 0 deletions
diff --git a/app/tools/gimpmeasuretool.c b/app/tools/gimpmeasuretool.c
new file mode 100644
index 0000000..ade4d8c
--- /dev/null
+++ b/app/tools/gimpmeasuretool.c
@@ -0,0 +1,890 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * 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
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpmath/gimpmath.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "tools-types.h"
+
+#include "core/gimpimage.h"
+#include "core/gimpimage-guides.h"
+#include "core/gimpimage-undo.h"
+#include "core/gimpimage-undo-push.h"
+#include "core/gimpprogress.h"
+#include "core/gimp-transform-utils.h"
+
+#include "widgets/gimphelp-ids.h"
+#include "widgets/gimpwidgets-utils.h"
+
+#include "display/gimpdisplay.h"
+#include "display/gimpdisplayshell.h"
+#include "display/gimpdisplayshell-appearance.h"
+#include "display/gimptoolcompass.h"
+#include "display/gimptoolgui.h"
+
+#include "gimpmeasureoptions.h"
+#include "gimpmeasuretool.h"
+#include "gimptoolcontrol.h"
+
+#include "gimp-intl.h"
+
+
+/* local function prototypes */
+
+static void gimp_measure_tool_control (GimpTool *tool,
+ GimpToolAction action,
+ GimpDisplay *display);
+static void gimp_measure_tool_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display);
+static void gimp_measure_tool_button_press (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonPressType press_type,
+ GimpDisplay *display);
+static void gimp_measure_tool_button_release (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonReleaseType release_type,
+ GimpDisplay *display);
+static void gimp_measure_tool_motion (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpDisplay *display);
+
+static void gimp_measure_tool_recalc_matrix (GimpTransformTool *tr_tool);
+static gchar * gimp_measure_tool_get_undo_desc (GimpTransformTool *tr_tool);
+
+static void gimp_measure_tool_compass_changed (GimpToolWidget *widget,
+ GimpMeasureTool *measure);
+static void gimp_measure_tool_compass_response(GimpToolWidget *widget,
+ gint response_id,
+ GimpMeasureTool *measure);
+static void gimp_measure_tool_compass_status (GimpToolWidget *widget,
+ const gchar *status,
+ GimpMeasureTool *measure);
+static void gimp_measure_tool_compass_create_guides
+ (GimpToolWidget *widget,
+ gint x,
+ gint y,
+ gboolean horizontal,
+ gboolean vertical,
+ GimpMeasureTool *measure);
+
+static void gimp_measure_tool_start (GimpMeasureTool *measure,
+ GimpDisplay *display,
+ const GimpCoords *coords);
+static void gimp_measure_tool_halt (GimpMeasureTool *measure);
+
+static GimpToolGui * gimp_measure_tool_dialog_new (GimpMeasureTool *measure);
+static void gimp_measure_tool_dialog_update (GimpMeasureTool *measure,
+ GimpDisplay *display);
+
+static void gimp_measure_tool_straighten_button_clicked
+ (GtkWidget *button,
+ GimpMeasureTool *measure);
+
+G_DEFINE_TYPE (GimpMeasureTool, gimp_measure_tool, GIMP_TYPE_TRANSFORM_TOOL)
+
+#define parent_class gimp_measure_tool_parent_class
+
+
+void
+gimp_measure_tool_register (GimpToolRegisterCallback callback,
+ gpointer data)
+{
+ (* callback) (GIMP_TYPE_MEASURE_TOOL,
+ GIMP_TYPE_MEASURE_OPTIONS,
+ gimp_measure_options_gui,
+ 0,
+ "gimp-measure-tool",
+ _("Measure"),
+ _("Measure Tool: Measure distances and angles"),
+ N_("_Measure"), "<shift>M",
+ NULL, GIMP_HELP_TOOL_MEASURE,
+ GIMP_ICON_TOOL_MEASURE,
+ data);
+}
+
+static void
+gimp_measure_tool_class_init (GimpMeasureToolClass *klass)
+{
+ GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
+ GimpTransformToolClass *tr_class = GIMP_TRANSFORM_TOOL_CLASS (klass);
+
+ tool_class->control = gimp_measure_tool_control;
+ tool_class->modifier_key = gimp_measure_tool_modifier_key;
+ tool_class->button_press = gimp_measure_tool_button_press;
+ tool_class->button_release = gimp_measure_tool_button_release;
+ tool_class->motion = gimp_measure_tool_motion;
+
+ tr_class->recalc_matrix = gimp_measure_tool_recalc_matrix;
+ tr_class->get_undo_desc = gimp_measure_tool_get_undo_desc;
+
+ tr_class->undo_desc = C_("undo-type", "Straighten");
+ tr_class->progress_text = _("Straightening");
+}
+
+static void
+gimp_measure_tool_init (GimpMeasureTool *measure)
+{
+ GimpTool *tool = GIMP_TOOL (measure);
+
+ gimp_tool_control_set_handle_empty_image (tool->control, TRUE);
+ gimp_tool_control_set_active_modifiers (tool->control,
+ GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE);
+ gimp_tool_control_set_precision (tool->control,
+ GIMP_CURSOR_PRECISION_PIXEL_BORDER);
+ gimp_tool_control_set_cursor (tool->control,
+ GIMP_CURSOR_CROSSHAIR_SMALL);
+ gimp_tool_control_set_tool_cursor (tool->control,
+ GIMP_TOOL_CURSOR_MEASURE);
+
+ gimp_draw_tool_set_default_status (GIMP_DRAW_TOOL (tool),
+ _("Click-Drag to create a line"));
+}
+
+static void
+gimp_measure_tool_control (GimpTool *tool,
+ GimpToolAction action,
+ GimpDisplay *display)
+{
+ GimpMeasureTool *measure = GIMP_MEASURE_TOOL (tool);
+
+ switch (action)
+ {
+ case GIMP_TOOL_ACTION_PAUSE:
+ case GIMP_TOOL_ACTION_RESUME:
+ break;
+
+ case GIMP_TOOL_ACTION_HALT:
+ gimp_measure_tool_halt (measure);
+ break;
+
+ case GIMP_TOOL_ACTION_COMMIT:
+ break;
+ }
+
+ GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
+}
+
+static void
+gimp_measure_tool_modifier_key (GimpTool *tool,
+ GdkModifierType key,
+ gboolean press,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ GimpMeasureOptions *options = GIMP_MEASURE_TOOL_GET_OPTIONS (tool);
+
+ if (key == gimp_get_toggle_behavior_mask ())
+ {
+ switch (options->orientation)
+ {
+ case GIMP_COMPASS_ORIENTATION_HORIZONTAL:
+ g_object_set (options,
+ "orientation", GIMP_COMPASS_ORIENTATION_VERTICAL,
+ NULL);
+ break;
+
+ case GIMP_COMPASS_ORIENTATION_VERTICAL:
+ g_object_set (options,
+ "orientation", GIMP_COMPASS_ORIENTATION_HORIZONTAL,
+ NULL);
+ break;
+
+ default:
+ break;
+ }
+ }
+}
+
+static void
+gimp_measure_tool_button_press (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonPressType press_type,
+ GimpDisplay *display)
+{
+ GimpMeasureTool *measure = GIMP_MEASURE_TOOL (tool);
+ GimpMeasureOptions *options = GIMP_MEASURE_TOOL_GET_OPTIONS (tool);
+ GimpDisplayShell *shell = gimp_display_get_shell (display);
+ GimpImage *image = gimp_display_get_image (display);
+
+ if (tool->display && display != tool->display)
+ gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display);
+
+ if (! measure->widget)
+ {
+ measure->supress_guides = TRUE;
+
+ gimp_measure_tool_start (measure, display, coords);
+
+ gimp_tool_widget_hover (measure->widget, coords, state, TRUE);
+ }
+
+ if (gimp_tool_widget_button_press (measure->widget, coords, time, state,
+ press_type))
+ {
+ measure->grab_widget = measure->widget;
+ }
+
+ /* create the info window if necessary */
+ if (! measure->gui)
+ {
+ if (options->use_info_window ||
+ ! gimp_display_shell_get_show_statusbar (shell))
+ {
+ measure->gui = gimp_measure_tool_dialog_new (measure);
+ g_object_add_weak_pointer (G_OBJECT (measure->gui),
+ (gpointer) &measure->gui);
+ }
+ }
+
+ if (measure->gui)
+ {
+ gimp_tool_gui_set_shell (measure->gui, shell);
+ gimp_tool_gui_set_viewable (measure->gui, GIMP_VIEWABLE (image));
+
+ gimp_measure_tool_dialog_update (measure, display);
+ }
+
+ gimp_tool_control_activate (tool->control);
+}
+
+static void
+gimp_measure_tool_button_release (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpButtonReleaseType release_type,
+ GimpDisplay *display)
+{
+ GimpMeasureTool *measure = GIMP_MEASURE_TOOL (tool);
+
+ gimp_tool_control_halt (tool->control);
+
+ if (measure->grab_widget)
+ {
+ gimp_tool_widget_button_release (measure->grab_widget,
+ coords, time, state, release_type);
+ measure->grab_widget = NULL;
+ }
+
+ measure->supress_guides = FALSE;
+}
+
+static void
+gimp_measure_tool_motion (GimpTool *tool,
+ const GimpCoords *coords,
+ guint32 time,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ GimpMeasureTool *measure = GIMP_MEASURE_TOOL (tool);
+
+ if (measure->grab_widget)
+ {
+ gimp_tool_widget_motion (measure->grab_widget, coords, time, state);
+ }
+}
+
+static void
+gimp_measure_tool_recalc_matrix (GimpTransformTool *tr_tool)
+{
+ GimpMeasureTool *measure = GIMP_MEASURE_TOOL (tr_tool);
+ gdouble angle;
+
+ if (measure->n_points < 2)
+ {
+ tr_tool->transform_valid = FALSE;
+
+ return;
+ }
+
+ g_object_get (measure->widget,
+ "pixel-angle", &angle,
+ NULL);
+
+ gimp_matrix3_identity (&tr_tool->transform);
+ gimp_transform_matrix_rotate_center (&tr_tool->transform,
+ measure->x[0], measure->y[0],
+ angle);
+
+ tr_tool->transform_valid = TRUE;
+}
+
+static gchar *
+gimp_measure_tool_get_undo_desc (GimpTransformTool *tr_tool)
+{
+ GimpMeasureTool *measure = GIMP_MEASURE_TOOL (tr_tool);
+ GimpCompassOrientation orientation;
+ gdouble angle;
+
+ g_object_get (measure->widget,
+ "effective-orientation", &orientation,
+ "pixel-angle", &angle,
+ NULL);
+
+ angle = gimp_rad_to_deg (fabs (angle));
+
+ switch (orientation)
+ {
+ case GIMP_COMPASS_ORIENTATION_AUTO:
+ return g_strdup_printf (C_("undo-type",
+ "Straighten by %-3.3g°"),
+ angle);
+
+ case GIMP_COMPASS_ORIENTATION_HORIZONTAL:
+ return g_strdup_printf (C_("undo-type",
+ "Straighten Horizontally by %-3.3g°"),
+ angle);
+
+ case GIMP_COMPASS_ORIENTATION_VERTICAL:
+ return g_strdup_printf (C_("undo-type",
+ "Straighten Vertically by %-3.3g°"),
+ angle);
+ }
+
+ g_return_val_if_reached (NULL);
+}
+
+static void
+gimp_measure_tool_compass_changed (GimpToolWidget *widget,
+ GimpMeasureTool *measure)
+{
+ GimpMeasureOptions *options = GIMP_MEASURE_TOOL_GET_OPTIONS (measure);
+
+ g_object_get (widget,
+ "n-points", &measure->n_points,
+ "x1", &measure->x[0],
+ "y1", &measure->y[0],
+ "x2", &measure->x[1],
+ "y2", &measure->y[1],
+ "x3", &measure->x[2],
+ "y3", &measure->y[2],
+ NULL);
+
+ gtk_widget_set_sensitive (options->straighten_button, measure->n_points >= 2);
+ gimp_measure_tool_dialog_update (measure, GIMP_TOOL (measure)->display);
+}
+
+static void
+gimp_measure_tool_compass_response (GimpToolWidget *widget,
+ gint response_id,
+ GimpMeasureTool *measure)
+{
+ GimpTool *tool = GIMP_TOOL (measure);
+
+ if (response_id == GIMP_TOOL_WIDGET_RESPONSE_CANCEL)
+ gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display);
+}
+
+static void
+gimp_measure_tool_compass_status (GimpToolWidget *widget,
+ const gchar *status,
+ GimpMeasureTool *measure)
+{
+ GimpTool *tool = GIMP_TOOL (measure);
+
+ if (! status)
+ {
+ /* replace status bar hint by distance and angle */
+ gimp_measure_tool_dialog_update (measure, tool->display);
+ }
+}
+
+static void
+gimp_measure_tool_compass_create_guides (GimpToolWidget *widget,
+ gint x,
+ gint y,
+ gboolean horizontal,
+ gboolean vertical,
+ GimpMeasureTool *measure)
+{
+ GimpDisplay *display = GIMP_TOOL (measure)->display;
+ GimpImage *image = gimp_display_get_image (display);
+
+ if (measure->supress_guides)
+ return;
+
+ if (x < 0 || x > gimp_image_get_width (image))
+ vertical = FALSE;
+
+ if (y < 0 || y > gimp_image_get_height (image))
+ horizontal = FALSE;
+
+ if (horizontal || vertical)
+ {
+ if (horizontal && vertical)
+ gimp_image_undo_group_start (image,
+ GIMP_UNDO_GROUP_GUIDE,
+ _("Add Guides"));
+
+ if (horizontal)
+ gimp_image_add_hguide (image, y, TRUE);
+
+ if (vertical)
+ gimp_image_add_vguide (image, x, TRUE);
+
+ if (horizontal && vertical)
+ gimp_image_undo_group_end (image);
+
+ gimp_image_flush (image);
+ }
+}
+
+static void
+gimp_measure_tool_start (GimpMeasureTool *measure,
+ GimpDisplay *display,
+ const GimpCoords *coords)
+{
+ GimpTool *tool = GIMP_TOOL (measure);
+ GimpDisplayShell *shell = gimp_display_get_shell (display);
+ GimpMeasureOptions *options = GIMP_MEASURE_TOOL_GET_OPTIONS (tool);
+
+ measure->n_points = 1;
+ measure->x[0] = coords->x;
+ measure->y[0] = coords->y;
+ measure->x[1] = 0;
+ measure->y[1] = 0;
+ measure->x[2] = 0;
+ measure->y[2] = 0;
+
+ measure->widget = gimp_tool_compass_new (shell,
+ options->orientation,
+ measure->n_points,
+ measure->x[0],
+ measure->y[0],
+ measure->x[1],
+ measure->y[1],
+ measure->x[2],
+ measure->y[2]);
+
+ gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (tool), measure->widget);
+
+ g_object_bind_property (options, "orientation",
+ measure->widget, "orientation",
+ G_BINDING_DEFAULT);
+
+ g_signal_connect (measure->widget, "changed",
+ G_CALLBACK (gimp_measure_tool_compass_changed),
+ measure);
+ g_signal_connect (measure->widget, "response",
+ G_CALLBACK (gimp_measure_tool_compass_response),
+ measure);
+ g_signal_connect (measure->widget, "status",
+ G_CALLBACK (gimp_measure_tool_compass_status),
+ measure);
+ g_signal_connect (measure->widget, "create-guides",
+ G_CALLBACK (gimp_measure_tool_compass_create_guides),
+ measure);
+ g_signal_connect (options->straighten_button, "clicked",
+ G_CALLBACK (gimp_measure_tool_straighten_button_clicked),
+ measure);
+
+ tool->display = display;
+
+ gimp_draw_tool_start (GIMP_DRAW_TOOL (measure), display);
+}
+
+static void
+gimp_measure_tool_halt (GimpMeasureTool *measure)
+{
+ GimpMeasureOptions *options = GIMP_MEASURE_TOOL_GET_OPTIONS (measure);
+ GimpTool *tool = GIMP_TOOL (measure);
+
+ if (options->straighten_button)
+ {
+ gtk_widget_set_sensitive (options->straighten_button, FALSE);
+
+ g_signal_handlers_disconnect_by_func (
+ options->straighten_button,
+ G_CALLBACK (gimp_measure_tool_straighten_button_clicked),
+ measure);
+ }
+
+ if (tool->display)
+ gimp_tool_pop_status (tool, tool->display);
+
+ if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (measure)))
+ gimp_draw_tool_stop (GIMP_DRAW_TOOL (measure));
+
+ gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (tool), NULL);
+ g_clear_object (&measure->widget);
+
+ g_clear_object (&measure->gui);
+
+ tool->display = NULL;
+}
+
+static void
+gimp_measure_tool_dialog_update (GimpMeasureTool *measure,
+ GimpDisplay *display)
+{
+ GimpDisplayShell *shell = gimp_display_get_shell (display);
+ GimpImage *image = gimp_display_get_image (display);
+ gint ax, ay;
+ gint bx, by;
+ gint pixel_width;
+ gint pixel_height;
+ gdouble unit_width;
+ gdouble unit_height;
+ gdouble pixel_distance;
+ gdouble unit_distance;
+ gdouble inch_distance;
+ gdouble pixel_angle;
+ gdouble unit_angle;
+ gdouble xres;
+ gdouble yres;
+ gchar format[128];
+ gint unit_distance_digits = 0;
+ gint unit_width_digits;
+ gint unit_height_digits;
+
+ /* calculate distance and angle */
+ ax = measure->x[1] - measure->x[0];
+ ay = measure->y[1] - measure->y[0];
+
+ if (measure->n_points == 3)
+ {
+ bx = measure->x[2] - measure->x[0];
+ by = measure->y[2] - measure->y[0];
+ }
+ else
+ {
+ bx = 0;
+ by = 0;
+ }
+
+ pixel_width = ABS (ax - bx);
+ pixel_height = ABS (ay - by);
+
+ gimp_image_get_resolution (image, &xres, &yres);
+
+ unit_width = gimp_pixels_to_units (pixel_width, shell->unit, xres);
+ unit_height = gimp_pixels_to_units (pixel_height, shell->unit, yres);
+
+ pixel_distance = sqrt (SQR (ax - bx) + SQR (ay - by));
+ inch_distance = sqrt (SQR ((gdouble) (ax - bx) / xres) +
+ SQR ((gdouble) (ay - by) / yres));
+ unit_distance = gimp_unit_get_factor (shell->unit) * inch_distance;
+
+ g_object_get (measure->widget,
+ "pixel-angle", &pixel_angle,
+ "unit-angle", &unit_angle,
+ NULL);
+
+ pixel_angle = fabs (pixel_angle * 180.0 / G_PI);
+ unit_angle = fabs (unit_angle * 180.0 / G_PI);
+
+ /* Compute minimum digits to display accurate values, so that
+ * every pixel shows a different value in unit.
+ */
+ if (inch_distance)
+ unit_distance_digits = gimp_unit_get_scaled_digits (shell->unit,
+ pixel_distance /
+ inch_distance);
+ unit_width_digits = gimp_unit_get_scaled_digits (shell->unit, xres);
+ unit_height_digits = gimp_unit_get_scaled_digits (shell->unit, yres);
+
+ if (shell->unit == GIMP_UNIT_PIXEL)
+ {
+ gimp_tool_replace_status (GIMP_TOOL (measure), display,
+ "%.1f %s, %.2f\302\260 (%d × %d)",
+ pixel_distance, _("pixels"), pixel_angle,
+ pixel_width, pixel_height);
+ }
+ else
+ {
+ g_snprintf (format, sizeof (format),
+ "%%.%df %s, %%.2f\302\260 (%%.%df × %%.%df)",
+ unit_distance_digits,
+ gimp_unit_get_plural (shell->unit),
+ unit_width_digits,
+ unit_height_digits);
+
+ gimp_tool_replace_status (GIMP_TOOL (measure), display, format,
+ unit_distance, unit_angle,
+ unit_width, unit_height);
+ }
+
+ if (measure->gui)
+ {
+ gchar buf[128];
+
+ /* Distance */
+ g_snprintf (buf, sizeof (buf), "%.1f", pixel_distance);
+ gtk_label_set_text (GTK_LABEL (measure->distance_label[0]), buf);
+
+ if (shell->unit != GIMP_UNIT_PIXEL)
+ {
+ g_snprintf (format, sizeof (format), "%%.%df",
+ unit_distance_digits);
+ g_snprintf (buf, sizeof (buf), format, unit_distance);
+ gtk_label_set_text (GTK_LABEL (measure->distance_label[1]), buf);
+
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[0]),
+ gimp_unit_get_plural (shell->unit));
+ }
+ else
+ {
+ gtk_label_set_text (GTK_LABEL (measure->distance_label[1]), NULL);
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[0]), NULL);
+ }
+
+ /* Angle */
+ g_snprintf (buf, sizeof (buf), "%.2f", pixel_angle);
+ gtk_label_set_text (GTK_LABEL (measure->angle_label[0]), buf);
+
+ if (fabs (unit_angle - pixel_angle) > 0.01)
+ {
+ g_snprintf (buf, sizeof (buf), "%.2f", unit_angle);
+ gtk_label_set_text (GTK_LABEL (measure->angle_label[1]), buf);
+
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[1]), "\302\260");
+ }
+ else
+ {
+ gtk_label_set_text (GTK_LABEL (measure->angle_label[1]), NULL);
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[1]), NULL);
+ }
+
+ /* Width */
+ g_snprintf (buf, sizeof (buf), "%d", pixel_width);
+ gtk_label_set_text (GTK_LABEL (measure->width_label[0]), buf);
+
+ if (shell->unit != GIMP_UNIT_PIXEL)
+ {
+ g_snprintf (format, sizeof (format), "%%.%df",
+ unit_width_digits);
+ g_snprintf (buf, sizeof (buf), format, unit_width);
+ gtk_label_set_text (GTK_LABEL (measure->width_label[1]), buf);
+
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[2]),
+ gimp_unit_get_plural (shell->unit));
+ }
+ else
+ {
+ gtk_label_set_text (GTK_LABEL (measure->width_label[1]), NULL);
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[2]), NULL);
+ }
+
+ g_snprintf (buf, sizeof (buf), "%d", pixel_height);
+ gtk_label_set_text (GTK_LABEL (measure->height_label[0]), buf);
+
+ /* Height */
+ if (shell->unit != GIMP_UNIT_PIXEL)
+ {
+ g_snprintf (format, sizeof (format), "%%.%df",
+ unit_height_digits);
+ g_snprintf (buf, sizeof (buf), format, unit_height);
+ gtk_label_set_text (GTK_LABEL (measure->height_label[1]), buf);
+
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[3]),
+ gimp_unit_get_plural (shell->unit));
+ }
+ else
+ {
+ gtk_label_set_text (GTK_LABEL (measure->height_label[1]), NULL);
+ gtk_label_set_text (GTK_LABEL (measure->unit_label[3]), NULL);
+ }
+
+ gimp_tool_gui_show (measure->gui);
+ }
+}
+
+static GimpToolGui *
+gimp_measure_tool_dialog_new (GimpMeasureTool *measure)
+{
+ GimpTool *tool = GIMP_TOOL (measure);
+ GimpDisplayShell *shell;
+ GimpToolGui *gui;
+ GtkWidget *table;
+ GtkWidget *label;
+
+ g_return_val_if_fail (tool->display != NULL, NULL);
+
+ shell = gimp_display_get_shell (tool->display);
+
+ gui = gimp_tool_gui_new (tool->tool_info,
+ NULL,
+ _("Measure Distances and Angles"),
+ NULL, NULL,
+ gtk_widget_get_screen (GTK_WIDGET (shell)),
+ gimp_widget_get_monitor (GTK_WIDGET (shell)),
+ TRUE,
+
+ _("_Close"), GTK_RESPONSE_CLOSE,
+
+ NULL);
+
+ gimp_tool_gui_set_auto_overlay (gui, TRUE);
+ gimp_tool_gui_set_focus_on_map (gui, FALSE);
+
+ g_signal_connect (gui, "response",
+ G_CALLBACK (g_object_unref),
+ NULL);
+
+ table = gtk_table_new (4, 5, TRUE);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (gui)), table,
+ TRUE, TRUE, 0);
+ gtk_widget_show (table);
+
+
+ label = gtk_label_new (_("Distance:"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
+ gtk_widget_show (label);
+
+ measure->distance_label[0] = label = gtk_label_new ("0.0");
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 0, 1);
+ gtk_widget_show (label);
+
+ label = gtk_label_new (_("pixels"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, 0, 1);
+ gtk_widget_show (label);
+
+ measure->distance_label[1] = label = gtk_label_new ("0.0");
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 3, 4, 0, 1);
+ gtk_widget_show (label);
+
+ measure->unit_label[0] = label = gtk_label_new (NULL);
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 4, 5, 0, 1);
+ gtk_widget_show (label);
+
+
+ label = gtk_label_new (_("Angle:"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
+ gtk_widget_show (label);
+
+ measure->angle_label[0] = label = gtk_label_new ("0.0");
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 1, 2);
+ gtk_widget_show (label);
+
+ label = gtk_label_new ("\302\260");
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, 1, 2);
+ gtk_widget_show (label);
+
+ measure->angle_label[1] = label = gtk_label_new (NULL);
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 3, 4, 1, 2);
+ gtk_widget_show (label);
+
+ measure->unit_label[1] = label = gtk_label_new (NULL);
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 4, 5, 1, 2);
+ gtk_widget_show (label);
+
+
+ label = gtk_label_new (_("Width:"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 2, 3);
+ gtk_widget_show (label);
+
+ measure->width_label[0] = label = gtk_label_new ("0.0");
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 2, 3);
+ gtk_widget_show (label);
+
+ label = gtk_label_new (_("pixels"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, 2, 3);
+ gtk_widget_show (label);
+
+ measure->width_label[1] = label = gtk_label_new ("0.0");
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 3, 4, 2, 3);
+ gtk_widget_show (label);
+
+ measure->unit_label[2] = label = gtk_label_new (NULL);
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 4, 5, 2, 3);
+ gtk_widget_show (label);
+
+
+ label = gtk_label_new (_("Height:"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 3, 4);
+ gtk_widget_show (label);
+
+ measure->height_label[0] = label = gtk_label_new ("0.0");
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 3, 4);
+ gtk_widget_show (label);
+
+ label = gtk_label_new (_("pixels"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, 3, 4);
+ gtk_widget_show (label);
+
+ measure->height_label[1] = label = gtk_label_new ("0.0");
+ gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+ gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 3, 4, 3, 4);
+ gtk_widget_show (label);
+
+ measure->unit_label[3] = label = gtk_label_new (NULL);
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_table_attach_defaults (GTK_TABLE (table), label, 4, 5, 3, 4);
+ gtk_widget_show (label);
+
+ return gui;
+}
+
+static void
+gimp_measure_tool_straighten_button_clicked (GtkWidget *button,
+ GimpMeasureTool *measure)
+{
+ GimpTool *tool = GIMP_TOOL (measure);
+ GimpTransformTool *tr_tool = GIMP_TRANSFORM_TOOL (measure);
+
+ if (gimp_transform_tool_transform (tr_tool, tool->display))
+ gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display);
+}