/* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * 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 2 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, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "config.h" #include #include #include "libgimpbase/gimpbase.h" #include "libgimpwidgets/gimpwidgets.h" #include "tools-types.h" #include "core/gimpchannel.h" #include "core/gimpimage.h" #include "core/gimpimage-crop.h" #include "core/gimppickable.h" #include "core/gimptoolinfo.h" #include "display/gimpcanvas.h" #include "display/gimpdisplay.h" #include "display/gimpdisplayshell.h" #include "display/gimpdisplayshell-transform.h" #include "gimpdrawtool.h" #include "gimprectangleoptions.h" #include "gimprectangletool.h" #include "gimptoolcontrol.h" #include "gimp-intl.h" /* speed of key movement */ #define ARROW_VELOCITY 25 #define GIMP_RECTANGLE_TOOL_GET_PRIVATE(obj) (gimp_rectangle_tool_get_private ((GimpRectangleTool *) (obj))) typedef struct _GimpRectangleToolPrivate GimpRectangleToolPrivate; struct _GimpRectangleToolPrivate { GtkWidget *controls; GtkWidget *dimensions_entry; gint startx; /* starting x coord */ gint starty; /* starting y coord */ gint lastx; /* previous x coord */ gint lasty; /* previous y coord */ gint pressx; /* x where button pressed */ gint pressy; /* y where button pressed */ gint x1, y1; /* upper left hand coordinate */ gint x2, y2; /* lower right hand coords */ guint function; /* moving or resizing */ gint dx1, dy1; /* display coords */ gint dx2, dy2; /* */ gint dcw, dch; /* width and height of edges */ gdouble origx, origy; gdouble sizew, sizeh; }; static void gimp_rectangle_tool_iface_base_init (GimpRectangleToolInterface *rectangle_tool_iface); static GimpRectangleToolPrivate * gimp_rectangle_tool_get_private (GimpRectangleTool *tool); /* Rectangle helper functions */ static void rectangle_recalc (GimpRectangleTool *rectangle); static void rectangle_tool_start (GimpRectangleTool *rectangle); /* Rectangle dialog functions */ static void rectangle_info_update (GimpRectangleTool *rectangle); static void rectangle_response (GtkWidget *widget, gint response_id, GimpRectangleTool *rectangle); static void rectangle_selection_callback (GtkWidget *widget, GimpRectangleTool *rectangle); static void rectangle_automatic_callback (GtkWidget *widget, GimpRectangleTool *rectangle); static void rectangle_dimensions_changed (GtkWidget *widget, GimpRectangleTool *rectangle); static void gimp_rectangle_tool_update_options (GimpRectangleTool *rectangle, GimpDisplay *gdisp); static GtkWidget * gimp_rectangle_controls (GimpRectangleTool *rectangle); static void gimp_rectangle_tool_zero_controls (GimpRectangleTool *rectangle); GType gimp_rectangle_tool_interface_get_type (void) { static GType rectangle_tool_iface_type = 0; if (!rectangle_tool_iface_type) { static const GTypeInfo rectangle_tool_iface_info = { sizeof (GimpRectangleToolInterface), (GBaseInitFunc) gimp_rectangle_tool_iface_base_init, (GBaseFinalizeFunc) NULL, }; rectangle_tool_iface_type = g_type_register_static (G_TYPE_INTERFACE, "GimpRectangleToolInterface", &rectangle_tool_iface_info, 0); } return rectangle_tool_iface_type; } static void gimp_rectangle_tool_iface_base_init (GimpRectangleToolInterface *tool_iface) { static gboolean initialized = FALSE; if (! initialized) { g_object_interface_install_property (tool_iface, g_param_spec_object ("controls", NULL, NULL, GTK_TYPE_WIDGET, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_object ("dimensions-entry", NULL, NULL, GTK_TYPE_WIDGET, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("startx", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("starty", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("lastx", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("lasty", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("pressx", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("pressy", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("x1", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("y1", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("x2", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("y2", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_uint ("function", NULL, NULL, RECT_CREATING, RECT_EXECUTING, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("dx1", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("dy1", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("dx2", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("dy2", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("dcw", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_int ("dch", NULL, NULL, 0, GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_double ("origx", NULL, NULL, 0.0, GIMP_MAX_IMAGE_SIZE, 0.0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_double ("origy", NULL, NULL, 0.0, GIMP_MAX_IMAGE_SIZE, 0.0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_double ("sizew", NULL, NULL, 0.0, GIMP_MAX_IMAGE_SIZE, 0.0, G_PARAM_READWRITE)); g_object_interface_install_property (tool_iface, g_param_spec_double ("sizeh", NULL, NULL, 0.0, GIMP_MAX_IMAGE_SIZE, 0.0, G_PARAM_READWRITE)); initialized = TRUE; } } static void gimp_rectangle_tool_private_finalize (GimpRectangleToolPrivate *private) { g_free (private); } static GimpRectangleToolPrivate * gimp_rectangle_tool_get_private (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; static GQuark private_key = 0; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), NULL); if (! private_key) private_key = g_quark_from_static_string ("gimp-rectangle-tool-private"); private = g_object_get_qdata ((GObject *) tool, private_key); if (! private) { private = g_new0 (GimpRectangleToolPrivate, 1); g_object_set_qdata_full ((GObject *) tool, private_key, private, (GDestroyNotify) gimp_rectangle_tool_private_finalize); } return private; } /** * gimp_rectangle_tool_install_properties: * @klass: the class structure for a type deriving from #GObject * * Installs the necessary properties for a class implementing * #GimpToolOptions. A #GimpRectangleToolProp property is installed * for each property, using the values from the #GimpRectangleToolProp * enumeration. The caller must make sure itself that the enumeration * values don't collide with some other property values they * are using (that's what %GIMP_RECTANGLE_TOOL_PROP_LAST is good for). **/ void gimp_rectangle_tool_install_properties (GObjectClass *klass) { g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_CONTROLS, "controls"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_DIMENSIONS_ENTRY, "dimensions-entry"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_STARTX, "startx"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_STARTY, "starty"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_LASTX, "lastx"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_LASTY, "lasty"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_PRESSX, "pressx"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_PRESSY, "pressy"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_X1, "x1"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_Y1, "y1"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_X2, "x2"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_Y2, "y2"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_FUNCTION, "function"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_DX1, "dx1"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_DY1, "dy1"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_DX2, "dx2"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_DY2, "dy2"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_DCW, "dcw"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_DCH, "dch"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_ORIGX, "origx"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_ORIGY, "origy"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_SIZEW, "sizew"); g_object_class_override_property (klass, GIMP_RECTANGLE_TOOL_PROP_SIZEH, "sizeh"); } void gimp_rectangle_tool_set_controls (GimpRectangleTool *tool, GtkWidget *controls) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->controls = controls; g_object_notify (G_OBJECT (tool), "controls"); } GtkWidget * gimp_rectangle_tool_get_controls (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), NULL); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->controls; } void gimp_rectangle_tool_set_entry (GimpRectangleTool *tool, GtkWidget *entry) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->dimensions_entry = entry; g_object_notify (G_OBJECT (tool), "dimensions-entry"); } GtkWidget * gimp_rectangle_tool_get_entry (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), NULL); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->dimensions_entry; } void gimp_rectangle_tool_set_startx (GimpRectangleTool *tool, gint startx) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->startx = startx; g_object_notify (G_OBJECT (tool), "startx"); } gint gimp_rectangle_tool_get_startx (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->startx; } void gimp_rectangle_tool_set_starty (GimpRectangleTool *tool, gint starty) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->starty = starty; g_object_notify (G_OBJECT (tool), "starty"); } gint gimp_rectangle_tool_get_starty (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->starty; } void gimp_rectangle_tool_set_lastx (GimpRectangleTool *tool, gint lastx) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->lastx = lastx; g_object_notify (G_OBJECT (tool), "lastx"); } gint gimp_rectangle_tool_get_lastx (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->lastx; } void gimp_rectangle_tool_set_lasty (GimpRectangleTool *tool, gint lasty) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->lasty = lasty; g_object_notify (G_OBJECT (tool), "lasty"); } gint gimp_rectangle_tool_get_lasty (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->lasty; } void gimp_rectangle_tool_set_pressx (GimpRectangleTool *tool, gint pressx) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->pressx = pressx; g_object_notify (G_OBJECT (tool), "pressx"); } gint gimp_rectangle_tool_get_pressx (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->pressx; } void gimp_rectangle_tool_set_pressy (GimpRectangleTool *tool, gint pressy) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->pressy = pressy; g_object_notify (G_OBJECT (tool), "pressy"); } gint gimp_rectangle_tool_get_pressy (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->pressy; } void gimp_rectangle_tool_set_x1 (GimpRectangleTool *tool, gint x1) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->x1 = x1; g_object_notify (G_OBJECT (tool), "x1"); } gint gimp_rectangle_tool_get_x1 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->x1; } void gimp_rectangle_tool_set_y1 (GimpRectangleTool *tool, gint y1) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->y1 = y1; g_object_notify (G_OBJECT (tool), "y1"); } gint gimp_rectangle_tool_get_y1 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->y1; } void gimp_rectangle_tool_set_x2 (GimpRectangleTool *tool, gint x2) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->x2 = x2; g_object_notify (G_OBJECT (tool), "x2"); } gint gimp_rectangle_tool_get_x2 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->x2; } void gimp_rectangle_tool_set_y2 (GimpRectangleTool *tool, gint y2) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->y2 = y2; g_object_notify (G_OBJECT (tool), "y2"); } gint gimp_rectangle_tool_get_y2 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->y2; } void gimp_rectangle_tool_set_function (GimpRectangleTool *tool, guint function) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->function = function; g_object_notify (G_OBJECT (tool), "function"); } guint gimp_rectangle_tool_get_function (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->function; } void gimp_rectangle_tool_set_dx1 (GimpRectangleTool *tool, gint dx1) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->dx1 = dx1; g_object_notify (G_OBJECT (tool), "dx1"); } gint gimp_rectangle_tool_get_dx1 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->dx1; } void gimp_rectangle_tool_set_dy1 (GimpRectangleTool *tool, gint dy1) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->dy1 = dy1; g_object_notify (G_OBJECT (tool), "dy1"); } gint gimp_rectangle_tool_get_dy1 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->dy1; } void gimp_rectangle_tool_set_dx2 (GimpRectangleTool *tool, gint dx2) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->dx2 = dx2; g_object_notify (G_OBJECT (tool), "dx2"); } gint gimp_rectangle_tool_get_dx2 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->dx2; } void gimp_rectangle_tool_set_dy2 (GimpRectangleTool *tool, gint dy2) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->dy2 = dy2; g_object_notify (G_OBJECT (tool), "dy2"); } gint gimp_rectangle_tool_get_dy2 (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->dy2; } void gimp_rectangle_tool_set_dcw (GimpRectangleTool *tool, gint dcw) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->dcw = dcw; g_object_notify (G_OBJECT (tool), "dcw"); } gint gimp_rectangle_tool_get_dcw (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->dcw; } void gimp_rectangle_tool_set_dch (GimpRectangleTool *tool, gint dch) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->dch = dch; g_object_notify (G_OBJECT (tool), "dch"); } gint gimp_rectangle_tool_get_dch (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->dch; } void gimp_rectangle_tool_set_origx (GimpRectangleTool *tool, gdouble origx) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->origx = origx; g_object_notify (G_OBJECT (tool), "origx"); } gdouble gimp_rectangle_tool_get_origx (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0.0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->origx; } void gimp_rectangle_tool_set_origy (GimpRectangleTool *tool, gdouble origy) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->origy = origy; g_object_notify (G_OBJECT (tool), "origy"); } gdouble gimp_rectangle_tool_get_origy (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0.0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->origy; } void gimp_rectangle_tool_set_sizew (GimpRectangleTool *tool, gdouble sizew) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->sizew = sizew; g_object_notify (G_OBJECT (tool), "sizew"); } gdouble gimp_rectangle_tool_get_sizew (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0.0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->sizew; } void gimp_rectangle_tool_set_sizeh (GimpRectangleTool *tool, gdouble sizeh) { GimpRectangleToolPrivate *private; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); private->sizeh = sizeh; g_object_notify (G_OBJECT (tool), "sizeh"); } gdouble gimp_rectangle_tool_get_sizeh (GimpRectangleTool *tool) { GimpRectangleToolPrivate *private; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), 0.0); private = GIMP_RECTANGLE_TOOL_GET_PRIVATE (tool); return private->sizeh; } void gimp_rectangle_tool_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpRectangleTool *tool = GIMP_RECTANGLE_TOOL (object); switch (property_id) { case GIMP_RECTANGLE_TOOL_PROP_CONTROLS: gimp_rectangle_tool_set_controls (tool, g_value_get_object (value)); break; case GIMP_RECTANGLE_TOOL_PROP_DIMENSIONS_ENTRY: gimp_rectangle_tool_set_entry (tool, g_value_get_object (value)); break; case GIMP_RECTANGLE_TOOL_PROP_STARTX: gimp_rectangle_tool_set_startx (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_STARTY: gimp_rectangle_tool_set_starty (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_LASTX: gimp_rectangle_tool_set_lastx (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_LASTY: gimp_rectangle_tool_set_lasty (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_PRESSX: gimp_rectangle_tool_set_pressx (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_PRESSY: gimp_rectangle_tool_set_pressy (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_X1: gimp_rectangle_tool_set_x1 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_Y1: gimp_rectangle_tool_set_y1 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_X2: gimp_rectangle_tool_set_x2 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_Y2: gimp_rectangle_tool_set_y2 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_FUNCTION: gimp_rectangle_tool_set_function (tool, g_value_get_uint (value)); break; case GIMP_RECTANGLE_TOOL_PROP_DX1: gimp_rectangle_tool_set_dx1 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_DY1: gimp_rectangle_tool_set_dy1 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_DX2: gimp_rectangle_tool_set_dx2 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_DY2: gimp_rectangle_tool_set_dy2 (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_DCW: gimp_rectangle_tool_set_dcw (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_DCH: gimp_rectangle_tool_set_dch (tool, g_value_get_int (value)); break; case GIMP_RECTANGLE_TOOL_PROP_ORIGX: gimp_rectangle_tool_set_origx (tool, g_value_get_double (value)); break; case GIMP_RECTANGLE_TOOL_PROP_ORIGY: gimp_rectangle_tool_set_origy (tool, g_value_get_double (value)); break; case GIMP_RECTANGLE_TOOL_PROP_SIZEW: gimp_rectangle_tool_set_sizew (tool, g_value_get_double (value)); break; case GIMP_RECTANGLE_TOOL_PROP_SIZEH: gimp_rectangle_tool_set_sizeh (tool, g_value_get_double (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } void gimp_rectangle_tool_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpRectangleTool *tool = GIMP_RECTANGLE_TOOL (object); switch (property_id) { case GIMP_RECTANGLE_TOOL_PROP_CONTROLS: g_value_set_object (value, gimp_rectangle_tool_get_controls (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_DIMENSIONS_ENTRY: g_value_set_object (value, gimp_rectangle_tool_get_entry (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_STARTX: g_value_set_int (value, gimp_rectangle_tool_get_startx (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_STARTY: g_value_set_int (value, gimp_rectangle_tool_get_starty (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_LASTX: g_value_set_int (value, gimp_rectangle_tool_get_lastx (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_LASTY: g_value_set_int (value, gimp_rectangle_tool_get_lasty (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_PRESSX: g_value_set_int (value, gimp_rectangle_tool_get_pressx (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_PRESSY: g_value_set_int (value, gimp_rectangle_tool_get_pressy (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_X1: g_value_set_int (value, gimp_rectangle_tool_get_x1 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_Y1: g_value_set_int (value, gimp_rectangle_tool_get_y1 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_X2: g_value_set_int (value, gimp_rectangle_tool_get_x2 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_Y2: g_value_set_int (value, gimp_rectangle_tool_get_y2 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_FUNCTION: g_value_set_uint (value, gimp_rectangle_tool_get_function (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_DX1: g_value_set_int (value, gimp_rectangle_tool_get_dx1 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_DY1: g_value_set_int (value, gimp_rectangle_tool_get_dy1 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_DX2: g_value_set_int (value, gimp_rectangle_tool_get_dx2 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_DY2: g_value_set_int (value, gimp_rectangle_tool_get_dy2 (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_DCW: g_value_set_int (value, gimp_rectangle_tool_get_dcw (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_DCH: g_value_set_int (value, gimp_rectangle_tool_get_dch (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_ORIGX: g_value_set_double (value, gimp_rectangle_tool_get_origx (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_ORIGY: g_value_set_double (value, gimp_rectangle_tool_get_origy (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_SIZEW: g_value_set_double (value, gimp_rectangle_tool_get_sizew (tool)); break; case GIMP_RECTANGLE_TOOL_PROP_SIZEH: g_value_set_double (value, gimp_rectangle_tool_get_sizeh (tool)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } void gimp_rectangle_tool_constructor (GObject *object) { GimpTool *tool; GimpRectangleTool *rectangle; GtkContainer *controls_container; GtkWidget *controls; GObject *options; tool = GIMP_TOOL (object); rectangle = GIMP_RECTANGLE_TOOL (object); tool->gdisp = NULL; g_assert (GIMP_IS_TOOL_INFO (tool->tool_info)); options = G_OBJECT (tool->tool_info->tool_options); controls_container = GTK_CONTAINER (g_object_get_data (options, "controls-container")); controls = gimp_rectangle_controls (rectangle); g_object_set (tool, "controls", controls, NULL); gtk_container_add (controls_container, controls); } void gimp_rectangle_tool_dispose (GObject *object) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (object); GtkWidget *controls; g_object_get (rectangle, "controls", &controls, NULL); if (controls) { gtk_widget_destroy (controls); g_free (controls); g_object_set (rectangle, "controls", NULL, NULL); } } gboolean gimp_rectangle_tool_initialize (GimpTool *tool, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); GimpSizeEntry *entry; g_object_get (rectangle, "dimensions-entry", &entry, NULL); if (gdisp != tool->gdisp) { gint width = gimp_image_get_width (gdisp->gimage); gint height = gimp_image_get_height (gdisp->gimage); GimpUnit unit; gdouble xres; gdouble yres; gimp_size_entry_set_refval_boundaries (entry, 0, 0, height); gimp_size_entry_set_refval_boundaries (entry, 1, 0, width); gimp_size_entry_set_refval_boundaries (entry, 2, 0, width); gimp_size_entry_set_refval_boundaries (entry, 3, 0, height); gimp_size_entry_set_size (entry, 0, 0, height); gimp_size_entry_set_size (entry, 1, 0, width); gimp_size_entry_set_size (entry, 2, 0, width); gimp_size_entry_set_size (entry, 3, 0, height); gimp_image_get_resolution (gdisp->gimage, &xres, &yres); gimp_size_entry_set_resolution (entry, 0, yres, TRUE); gimp_size_entry_set_resolution (entry, 1, xres, TRUE); gimp_size_entry_set_resolution (entry, 2, xres, TRUE); gimp_size_entry_set_resolution (entry, 3, yres, TRUE); unit = gimp_display_shell_get_unit (GIMP_DISPLAY_SHELL (gdisp->shell)); gimp_size_entry_set_unit (entry, unit); } return TRUE; } void gimp_rectangle_tool_control (GimpTool *tool, GimpToolAction action, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); switch (action) { case PAUSE: break; case RESUME: rectangle_recalc (rectangle); break; case HALT: rectangle_response (NULL, GTK_RESPONSE_CANCEL, rectangle); break; default: break; } } void gimp_rectangle_tool_button_press (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); if (gdisp != tool->gdisp) { if (gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_stop (draw_tool); g_object_set (rectangle, "function", RECT_CREATING, NULL); gimp_tool_control_set_snap_offsets (tool->control, 0, 0, 0, 0); tool->gdisp = gdisp; g_object_set (rectangle, "x1", ROUND (coords->x), "y1", ROUND (coords->y), "x2", ROUND (coords->x), "y2", ROUND (coords->y), NULL); rectangle_tool_start (rectangle); } g_object_set (rectangle, "pressx", ROUND (coords->x), "pressy", ROUND (coords->y), "lastx", ROUND (coords->x), "lasty", ROUND (coords->y), "startx", ROUND (coords->x), "starty", ROUND (coords->y), NULL); gimp_tool_control_activate (tool->control); } void gimp_rectangle_tool_button_release (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); gint lastx, lasty; gint pressx, pressy; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); gimp_tool_control_halt (tool->control); gimp_tool_pop_status (tool, gdisp); if (! (state & GDK_BUTTON3_MASK)) { g_object_get (rectangle, "lastx", &lastx, "lasty", &lasty, "pressx", &pressx, "pressy", &pressy, NULL); if (lastx == pressx && lasty == pressy) { rectangle_response (NULL, GIMP_RECTANGLE_MODE_EXECUTE, rectangle); } rectangle_info_update (rectangle); } } void gimp_rectangle_tool_motion (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); GimpRectangleOptions *options; guint function; gint x1, y1, x2, y2; gint curx, cury; gint inc_x, inc_y; gint lastx, lasty; gint min_x, min_y, max_x, max_y; gint rx1, ry1, rx2, ry2; gboolean fixed_width; gboolean fixed_height; gboolean fixed_aspect; gboolean fixed_center; gdouble width, height; gdouble center_x, center_y; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); /* This is the only case when the motion events should be ignored-- we're just waiting for the button release event to execute */ g_object_get (rectangle, "function", &function, NULL); if (function == RECT_EXECUTING) return; curx = ROUND (coords->x); cury = ROUND (coords->y); g_object_get (rectangle, "startx", &x1, "starty", &y1, NULL); x2 = curx; y2 = cury; inc_x = (x2 - x1); inc_y = (y2 - y1); /* If there have been no changes... return */ g_object_get (rectangle, "lastx", &lastx, "lasty", &lasty, NULL); if (lastx == x2 && lasty == y2) return; options = GIMP_RECTANGLE_OPTIONS (tool->tool_info->tool_options); g_object_get (options, "new-fixed-width", &fixed_width, "new-fixed-height", &fixed_height, "fixed-aspect", &fixed_aspect, "fixed-center", &fixed_center, NULL); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); min_x = min_y = 0; max_x = gdisp->gimage->width; max_y = gdisp->gimage->height; g_object_get (options, "width", &width, "height", &height, "center-x", ¢er_x, "center-y", ¢er_y, NULL); g_object_get (rectangle, "x1", &rx1, "y1", &ry1, "x2", &rx2, "y2", &ry2, NULL); switch (function) { case RECT_CREATING: if (x1 < 0) x1 = 0; if (x2 > max_x) x2 = max_x; break; case RECT_RESIZING_UPPER_LEFT: case RECT_RESIZING_LOWER_LEFT: case RECT_RESIZING_LEFT: x1 = rx1 + inc_x; if (fixed_width) { x2 = x1 + width; if (x1 < 0) { x1 = 0; x2 = width; } if (x2 > max_x) { x2 = max_x; x1 = max_x - width; } } else if (fixed_center) { x2 = x1 + 2 * (center_x - x1); if (x1 < 0) { x1 = 0; x2 = 2 * center_x; } if (x2 > max_x) { x2 = max_x; x1 = max_x - 2 * (max_x - center_x); } } else { x2 = MAX (x1, rx2); if (x1 < 0) x1 = 0; } g_object_set (rectangle, "startx", curx, NULL); break; case RECT_RESIZING_UPPER_RIGHT: case RECT_RESIZING_LOWER_RIGHT: case RECT_RESIZING_RIGHT: x2 = rx2 + inc_x; if (fixed_width) { x1 = x2 - width; if (x2 > max_x) { x2 = max_x; x1 = max_x - width; } if (x1 < 0) { x1 = 0; x2 = width; } } else if (fixed_center) { x1 = x2 - 2 * (x2 - center_x); if (x2 > max_x) { x2 = max_x; x1 = max_x - 2 * (max_x - center_x); } if (x1 < 0) { x1 = 0; x2 = 2 * center_x; } } else { x1 = MIN (rx1, x2); if (x2 > max_x) x2 = max_x; } g_object_set (rectangle, "startx", curx, NULL); break; case RECT_RESIZING_BOTTOM: case RECT_RESIZING_TOP: x1 = rx1; x2 = rx2; g_object_set (rectangle, "startx", curx, NULL); break; case RECT_MOVING: if (rx1 + inc_x < 0 || rx2 + inc_x > max_x) { x1 = rx1; x2 = rx2; } else { x1 = rx1 + inc_x; x2 = rx2 + inc_x; } g_object_set (rectangle, "startx", curx, NULL); break; } switch (function) { case RECT_CREATING: if (y1 < 0) y1 = 0; if (y2 > max_y) y2 = max_y; break; case RECT_RESIZING_UPPER_LEFT: case RECT_RESIZING_UPPER_RIGHT: case RECT_RESIZING_TOP: y1 = ry1 + inc_y; if (fixed_height) { y2 = y1 + height; if (y1 < 0) { y1 = 0; y2 = height; } if (y2 > max_y) { y2 = max_y; y1 = max_y - height; } } else if (fixed_center) { y2 = y1 + 2 * (center_y - y1); if (y1 < 0) { y1 = 0; y2 = 2 * center_y; } if (y2 > max_y) { y2 = max_y; y1 = max_y - 2 * (max_y - center_y); } } else { y2 = MAX (y1, ry2); if (y1 < 0) y1 = 0; } g_object_set (rectangle, "starty", cury, NULL); break; case RECT_RESIZING_LOWER_LEFT: case RECT_RESIZING_LOWER_RIGHT: case RECT_RESIZING_BOTTOM: y2 = ry2 + inc_y; if (fixed_height) { y1 = y2 - height; if (y2 > max_y) { y2 = max_y; y1 = max_y - height; } if (y1 < 0) { y1 = 0; y2 = height; } } else if (fixed_center) { y1 = y2 - 2 * (y2 - center_y); if (y2 > max_y) { y2 = max_y; y1 = max_y - 2 * (max_y - center_y); } if (y1 < 0) { y1 = 0; y2 = 2 * center_y; } } else { y1 = MIN (ry1, y2); if (y2 > max_y) y2 = max_y; } g_object_set (rectangle, "starty", cury, NULL); break; case RECT_RESIZING_RIGHT: case RECT_RESIZING_LEFT: y1 = ry1; y2 = ry2; g_object_set (rectangle, "starty", cury, NULL); break; case RECT_MOVING: if (ry1 + inc_y < 0 || ry2 + inc_y > max_y) { y1 = ry1; y2 = ry2; } else { y1 = ry1 + inc_y; y2 = ry2 + inc_y; } g_object_set (rectangle, "starty", cury, NULL); break; } /* make sure that the coords are in bounds */ g_object_set (rectangle, "x1", MIN (x1, x2), "y1", MIN (y1, y2), "x2", MAX (x1, x2), "y2", MAX (y1, y2), "lastx", curx, "lasty", cury, NULL); if (fixed_aspect) { gdouble aspect; g_object_get (options, "aspect", &aspect, NULL); if (aspect > max_y) aspect = max_y; if (aspect < 1.0 / max_x) aspect = 1.0 / max_x; switch (function) { case RECT_RESIZING_UPPER_LEFT: case RECT_RESIZING_LEFT: ry2 = ry1 + aspect * (rx2 - rx1); if (ry2 > max_y) { g_object_set (rectangle, "y2", max_y, "x2", rx1 + (max_y - ry1) / aspect, NULL); } else g_object_set (rectangle, "y2", ry2, NULL); break; case RECT_RESIZING_UPPER_RIGHT: case RECT_RESIZING_RIGHT: ry2 = ry1 + aspect * (rx2 - rx1); if (ry2 > max_y) { g_object_set (rectangle, "y2", max_y, "x1", rx2 - (max_y - ry1) / aspect, NULL); } else g_object_set (rectangle, "y2", ry2, NULL); break; case RECT_RESIZING_LOWER_LEFT: ry1 = ry2 - aspect * (rx2 - rx1); if (ry1 < 0) { g_object_set (rectangle, "y1", 0, "x2", rx1 + (ry2 - 0) / aspect, NULL); } else g_object_set (rectangle, "y1", ry1, NULL); break; case RECT_RESIZING_LOWER_RIGHT: ry1 = ry2 - aspect * (rx2 - rx1); if (ry1 < 0) { g_object_set (rectangle, "y1", 0, "x1", rx2 - (ry2 - 0) / aspect, NULL); } else g_object_set (rectangle, "y1", ry1, NULL); break; case RECT_RESIZING_TOP: rx2 = rx1 + (ry2 - ry1) / aspect; if (rx2 > max_x) { g_object_set (rectangle, "x2", max_x, "y2", ry1 + aspect * (max_x - rx1), NULL); } else g_object_set (rectangle, "x2", rx2, NULL); break; case RECT_RESIZING_BOTTOM: rx2 = rx1 + (ry2 - ry1) / aspect; if (rx2 > max_x) { g_object_set (rectangle, "x2", max_x, "y1", ry2 - aspect * (max_x - rx1), NULL); } else g_object_set (rectangle, "x2", rx2, NULL); break; default: break; } } /* recalculate the coordinates for rectangle_draw based on the new values */ rectangle_recalc (rectangle); g_object_get (rectangle, "x1", &rx1, "y1", &ry1, "x2", &rx2, "y2", &ry2, NULL); switch (function) { case RECT_RESIZING_UPPER_LEFT: gimp_tool_control_set_snap_offsets (tool->control, rx1 - coords->x, ry1 - coords->y, 0, 0); break; case RECT_RESIZING_UPPER_RIGHT: gimp_tool_control_set_snap_offsets (tool->control, rx2 - coords->x, ry1 - coords->y, 0, 0); break; case RECT_RESIZING_LOWER_LEFT: gimp_tool_control_set_snap_offsets (tool->control, rx1 - coords->x, ry2 - coords->y, 0, 0); break; case RECT_RESIZING_LOWER_RIGHT: gimp_tool_control_set_snap_offsets (tool->control, rx2 - coords->x, ry2 - coords->y, 0, 0); break; case RECT_RESIZING_LEFT: gimp_tool_control_set_snap_offsets (tool->control, rx1 - coords->x, 0, 0, 0); break; case RECT_RESIZING_RIGHT: gimp_tool_control_set_snap_offsets (tool->control, rx2 - coords->x, 0, 0, 0); break; case RECT_RESIZING_TOP: gimp_tool_control_set_snap_offsets (tool->control, 0, ry1 - coords->y, 0, 0); break; case RECT_RESIZING_BOTTOM: gimp_tool_control_set_snap_offsets (tool->control, 0, ry2 - coords->y, 0, 0); break; case RECT_MOVING: gimp_tool_control_set_snap_offsets (tool->control, rx1 - coords->x, ry1 - coords->y, rx2 - rx1, ry2 - ry1); break; default: break; } gimp_rectangle_tool_update_options (rectangle, gdisp); if (function == RECT_CREATING || function == RECT_RESIZING_UPPER_LEFT || function == RECT_RESIZING_LOWER_RIGHT) { gimp_tool_pop_status (tool, gdisp); gimp_tool_push_status_coords (tool, gdisp, _("Rectangle: "), rx2 - rx1, " x ", ry2 - ry1); } if (function == RECT_CREATING) { if (inc_x < 0 && inc_y < 0) function = RECT_RESIZING_UPPER_LEFT; else if (inc_x < 0 && inc_y > 0) function = RECT_RESIZING_LOWER_LEFT; else if (inc_x > 0 && inc_y < 0) function = RECT_RESIZING_UPPER_RIGHT; else if (inc_x > 0 && inc_y > 0) function = RECT_RESIZING_LOWER_RIGHT; g_object_set (rectangle, "function", function, NULL); } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); } gboolean gimp_rectangle_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); gint inc_x, inc_y; gint min_x, min_y; gint max_x, max_y; gint x1, y1, x2, y2; g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (tool), FALSE); if (gdisp != tool->gdisp) return FALSE; inc_x = inc_y = 0; switch (kevent->keyval) { case GDK_Up: inc_y = -1; break; case GDK_Left: inc_x = -1; break; case GDK_Right: inc_x = 1; break; case GDK_Down: inc_y = 1; break; case GDK_KP_Enter: case GDK_Return: rectangle_response (NULL, GIMP_RECTANGLE_MODE_EXECUTE, rectangle); return TRUE; case GDK_Escape: rectangle_response (NULL, GTK_RESPONSE_CANCEL, rectangle); return TRUE; default: return FALSE; } /* If the shift key is down, move by an accelerated increment */ if (kevent->state & GDK_SHIFT_MASK) { inc_y *= ARROW_VELOCITY; inc_x *= ARROW_VELOCITY; } gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); min_x = min_y = 0; max_x = gdisp->gimage->width; max_y = gdisp->gimage->height; g_object_get (rectangle, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, NULL); g_object_set (rectangle, "x1", x1 + inc_x, "y1", y1 + inc_y, "x2", x2 + inc_x, "y2", y2 + inc_y, NULL); rectangle_recalc (rectangle); gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); return TRUE; } void gimp_rectangle_tool_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *gdisp) { } void gimp_rectangle_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gint x1, y1, x2, y2; gint dcw, dch; gboolean inside_x; gboolean inside_y; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); if (tool->gdisp != gdisp) { return; } g_object_get (rectangle, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, "dcw", &dcw, "dch", &dch, NULL); inside_x = coords->x > x1 && coords->x < x2; inside_y = coords->y > y1 && coords->y < y2; if (gimp_draw_tool_on_handle (draw_tool, gdisp, coords->x, coords->y, GIMP_HANDLE_SQUARE, x1, y1, dcw, dch, GTK_ANCHOR_NORTH_WEST, FALSE)) { g_object_set (rectangle, "function", RECT_RESIZING_UPPER_LEFT, NULL); gimp_tool_control_set_snap_offsets (tool->control, x1 - coords->x, y1 - coords->y, 0, 0); } else if (gimp_draw_tool_on_handle (draw_tool, gdisp, coords->x, coords->y, GIMP_HANDLE_SQUARE, x2, y2, dcw, dch, GTK_ANCHOR_SOUTH_EAST, FALSE)) { g_object_set (rectangle, "function", RECT_RESIZING_LOWER_RIGHT, NULL); gimp_tool_control_set_snap_offsets (tool->control, x2 - coords->x, y2 - coords->y, 0, 0); } else if (gimp_draw_tool_on_handle (draw_tool, gdisp, coords->x, coords->y, GIMP_HANDLE_SQUARE, x2, y1, dcw, dch, GTK_ANCHOR_NORTH_EAST, FALSE)) { g_object_set (rectangle, "function", RECT_RESIZING_UPPER_RIGHT, NULL); gimp_tool_control_set_snap_offsets (tool->control, x2 - coords->x, y1 - coords->y, 0, 0); } else if (gimp_draw_tool_on_handle (draw_tool, gdisp, coords->x, coords->y, GIMP_HANDLE_SQUARE, x1, y2, dcw, dch, GTK_ANCHOR_SOUTH_WEST, FALSE)) { g_object_set (rectangle, "function", RECT_RESIZING_LOWER_LEFT, NULL); gimp_tool_control_set_snap_offsets (tool->control, x1 - coords->x, y2 - coords->y, 0, 0); } else if ( (fabs (coords->x - x1) < dcw) && inside_y) { g_object_set (rectangle, "function", RECT_RESIZING_LEFT, NULL); gimp_tool_control_set_snap_offsets (tool->control, x1 - coords->x, 0, 0, 0); } else if ( (fabs (coords->x - x2) < dcw) && inside_y) { g_object_set (rectangle, "function", RECT_RESIZING_RIGHT, NULL); gimp_tool_control_set_snap_offsets (tool->control, x2 - coords->x, 0, 0, 0); } else if ( (fabs (coords->y - y1) < dch) && inside_x) { g_object_set (rectangle, "function", RECT_RESIZING_TOP, NULL); gimp_tool_control_set_snap_offsets (tool->control, 0, y1 - coords->y, 0, 0); } else if ( (fabs (coords->y - y2) < dch) && inside_x) { g_object_set (rectangle, "function", RECT_RESIZING_BOTTOM, NULL); gimp_tool_control_set_snap_offsets (tool->control, 0, y2 - coords->y, 0, 0); } else if (inside_x && inside_y) { g_object_set (rectangle, "function", RECT_MOVING, NULL); } /* otherwise, the new function will be creating, since we want * to start a new rectangle */ else { g_object_set (rectangle, "function", RECT_CREATING, NULL); gimp_tool_control_set_snap_offsets (tool->control, 0, 0, 0, 0); } } void gimp_rectangle_tool_cursor_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, GimpDisplay *gdisp) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool); GimpCursorType cursor = GDK_CROSSHAIR; GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; GimpToolCursorType tool_cursor; guint function; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); tool_cursor = gimp_tool_control_get_tool_cursor (tool->control); if (tool->gdisp == gdisp && ! (state & GDK_BUTTON1_MASK)) { g_object_get (rectangle, "function", &function, NULL); switch (function) { case RECT_CREATING: cursor = GDK_CROSSHAIR; break; case RECT_MOVING: cursor = GDK_FLEUR; break; case RECT_RESIZING_UPPER_LEFT: cursor = GDK_TOP_LEFT_CORNER; break; case RECT_RESIZING_UPPER_RIGHT: cursor = GDK_TOP_RIGHT_CORNER; break; case RECT_RESIZING_LOWER_LEFT: cursor = GDK_BOTTOM_LEFT_CORNER; break; case RECT_RESIZING_LOWER_RIGHT: cursor = GDK_BOTTOM_RIGHT_CORNER; break; case RECT_RESIZING_LEFT: cursor = GDK_LEFT_SIDE; break; case RECT_RESIZING_RIGHT: cursor = GDK_RIGHT_SIDE; break; case RECT_RESIZING_TOP: cursor = GDK_TOP_SIDE; break; case RECT_RESIZING_BOTTOM: cursor = GDK_BOTTOM_SIDE; break; default: break; } } gimp_tool_control_set_cursor (tool->control, cursor); gimp_tool_control_set_tool_cursor (tool->control, tool_cursor); gimp_tool_control_set_cursor_modifier (tool->control, modifier); gimp_tool_set_cursor (tool, gdisp, gimp_tool_control_get_cursor (tool->control), gimp_tool_control_get_tool_cursor (tool->control), gimp_tool_control_get_cursor_modifier (tool->control)); } void gimp_rectangle_tool_draw (GimpDrawTool *draw) { GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (draw); GimpTool *tool = GIMP_TOOL (draw); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (tool->gdisp->shell); GimpCanvas *canvas = GIMP_CANVAS (shell->canvas); gint dx1, dy1, dx2, dy2; g_return_if_fail (GIMP_IS_RECTANGLE_TOOL (tool)); g_object_get (rectangle, "dx1", &dx1, "dy1", &dy1, "dx2", &dx2, "dy2", &dy2, NULL); gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR, dx1, dy1, dx2, dy1); gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR, dx1, dy1, dx1, dy2); gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR, dx2, dy2, dx1, dy2); gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR, dx2, dy2, dx2, dy1); } static void rectangle_recalc (GimpRectangleTool *rectangle) { GimpTool *tool = GIMP_TOOL (rectangle); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (tool->gdisp->shell); GimpRectangleOptions *options; gint dx1, dy1; gint dx2, dy2; gboolean highlight; gint x1, y1; gint x2, y2; options = GIMP_RECTANGLE_OPTIONS (tool->tool_info->tool_options); if (! tool->gdisp) return; g_object_get (options, "highlight", &highlight, NULL); g_object_get (rectangle, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, NULL); if (highlight) { GdkRectangle rect; rect.x = x1; rect.y = y1; rect.width = x2 - x1; rect.height = y2 - y1; gimp_display_shell_set_highlight (shell, &rect); } gimp_display_shell_transform_xy (shell, x1, y1, &dx1, &dy1, FALSE); gimp_display_shell_transform_xy (shell, x2, y2, &dx2, &dy2, FALSE); g_object_set (rectangle, "dx1", dx1, "dy1", dy1, "dx2", dx2, "dy2", dy2, NULL); #define SRW 10 #define SRH 10 g_object_set (rectangle, "dcw", ((dx2 - dx1) < SRW) ? (dx2 - dx1) : SRW, "dch", ((dy2 - dy1) < SRH) ? (dy2 - dy1) : SRH, NULL); #undef SRW #undef SRH rectangle_info_update (rectangle); } static void rectangle_tool_start (GimpRectangleTool *rectangle) { GimpTool *tool = GIMP_TOOL (rectangle); rectangle_recalc (rectangle); /* initialize the statusbar display */ gimp_tool_push_status_coords (tool, tool->gdisp, _("Rectangle: "), 0, " x ", 0); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), tool->gdisp); } static void rectangle_info_update (GimpRectangleTool *rectangle) { gint x1, y1, x2, y2; g_object_get (rectangle, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, NULL); g_object_set (rectangle, "origx", (gdouble) x1, NULL); g_object_set (rectangle, "origy", (gdouble) y1, NULL); g_object_set (rectangle, "sizew", (gdouble) (x2 - x1), NULL); g_object_set (rectangle, "sizeh", (gdouble) (y2 - y1), NULL); } static void rectangle_response (GtkWidget *widget, gint response_id, GimpRectangleTool *rectangle) { GimpTool *tool = GIMP_TOOL (rectangle); gboolean finish = TRUE; gint x1, y1, x2, y2; if (response_id == GIMP_RECTANGLE_MODE_EXECUTE) { g_object_get (rectangle, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, NULL); gimp_draw_tool_pause (GIMP_DRAW_TOOL (rectangle)); finish = gimp_rectangle_tool_execute (GIMP_RECTANGLE_TOOL (tool), x1, y1, x2 - x1, y2 - y1); rectangle_recalc (rectangle); gimp_draw_tool_resume (GIMP_DRAW_TOOL (rectangle)); } if (finish) { gimp_display_shell_set_highlight (GIMP_DISPLAY_SHELL (tool->gdisp->shell), NULL); if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (rectangle))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (rectangle)); if (gimp_tool_control_is_active (tool->control)) gimp_tool_control_halt (tool->control); gimp_image_flush (tool->gdisp->gimage); tool->gdisp = NULL; tool->drawable = NULL; } } static void rectangle_selection_callback (GtkWidget *widget, GimpRectangleTool *rectangle) { GimpDisplay *gdisp; gint x1, y1; gint x2, y2; gdisp = GIMP_TOOL (rectangle)->gdisp; gimp_draw_tool_pause (GIMP_DRAW_TOOL (rectangle)); if (gimp_channel_bounds (gimp_image_get_mask (gdisp->gimage), &x1, &y1, &x2, &y2)) { g_object_set (rectangle, "x1", x1, "y1", y1, "x2", x2, "y2", y2, NULL); } else { g_object_set (rectangle, "x1", 0, "y1", 0, "x2", gdisp->gimage->width, "y2", gdisp->gimage->height, NULL); } rectangle_recalc (rectangle); gimp_draw_tool_resume (GIMP_DRAW_TOOL (rectangle)); } static void rectangle_automatic_callback (GtkWidget *widget, GimpRectangleTool *rectangle) { GimpDisplay *gdisp; gint offset_x, offset_y; gint width, height; gint rx1, ry1, rx2, ry2; gint x1, y1, x2, y2; gint shrunk_x1; gint shrunk_y1; gint shrunk_x2; gint shrunk_y2; gdisp = GIMP_TOOL (rectangle)->gdisp; width = gdisp->gimage->width; height = gdisp->gimage->height; offset_x = 0; offset_y = 0; g_object_get (rectangle, "x1", &rx1, "y1", &ry1, "x2", &rx2, "y2", &ry2, NULL); x1 = rx1 - offset_x > 0 ? rx1 - offset_x : 0; x2 = rx2 - offset_x < width ? rx2 - offset_x : width; y1 = ry1 - offset_y > 0 ? ry1 - offset_y : 0; y2 = ry2 - offset_y < height ? ry2 - offset_y : height; if (gimp_image_crop_auto_shrink (gdisp->gimage, x1, y1, x2, y2, FALSE, &shrunk_x1, &shrunk_y1, &shrunk_x2, &shrunk_y2)) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (rectangle)); g_object_set (rectangle, "x1", offset_x + shrunk_x1, "y1", offset_y + shrunk_y1, "x2", offset_x + shrunk_x2, "y2", offset_y + shrunk_y2, NULL); rectangle_recalc (rectangle); gimp_draw_tool_resume (GIMP_DRAW_TOOL (rectangle)); } } static void rectangle_dimensions_changed (GtkWidget *widget, GimpRectangleTool *rectangle) { GimpSizeEntry *entry = GIMP_SIZE_ENTRY (widget); gint rx1, ry1, rx2, ry2; gdouble x1, y1, x2, y2; GimpCoords coords; if (! GIMP_TOOL (rectangle)->gdisp) return; g_object_get (rectangle, "x1", &rx1, "y1", &ry1, "x2", &rx2, "y2", &ry2, NULL); x1 = gimp_size_entry_get_refval (entry, 2); y1 = gimp_size_entry_get_refval (entry, 3); x2 = gimp_size_entry_get_refval (entry, 1); y2 = gimp_size_entry_get_refval (entry, 0); if (x1 != rx1) { coords.x = x1; coords.y = y1; g_object_set (rectangle, "function", RECT_RESIZING_LEFT, "startx", rx1, "starty", ry1, NULL); } else if (y1 != ry1) { coords.x = x1; coords.y = y1; g_object_set (rectangle, "function", RECT_RESIZING_TOP, "startx", rx1, "starty", ry1, NULL); } else if (x2 != rx2) { coords.x = x2; coords.y = y2; g_object_set (rectangle, "function", RECT_RESIZING_RIGHT, "startx", rx2, "starty", ry2, NULL); } else if (y2 != ry2) { coords.x = x2; coords.y = y2; g_object_set (rectangle, "function", RECT_RESIZING_BOTTOM, "startx", rx2, "starty", ry2, NULL); } else return; /* use the motion handler to handle this, to avoid duplicating a bunch of code */ gimp_rectangle_tool_motion (GIMP_TOOL (rectangle), &coords, 0, 0, GIMP_TOOL (rectangle)->gdisp); } gboolean gimp_rectangle_tool_execute (GimpRectangleTool *rectangle, gint x, gint y, gint w, gint h) { GimpRectangleToolInterface *tool_iface = GIMP_RECTANGLE_TOOL_GET_INTERFACE (rectangle); GimpTool *tool = GIMP_TOOL (rectangle); guint function; gint pressx, pressy; gint rx1, ry1, rx2, ry2; gboolean rectangle_exists; GimpChannel *selection_mask; gint val; gboolean selected; GimpImage *gimage; gint x1, y1; gint x2, y2; g_return_val_if_fail (tool_iface->execute, FALSE); g_object_get (rectangle, "function", &function, "pressx", &pressx, "pressy", &pressy, NULL); rectangle_exists = (function != RECT_CREATING); gimage = tool->gdisp->gimage; selection_mask = gimp_image_get_mask (gimage); val = gimp_pickable_get_opacity_at (GIMP_PICKABLE (selection_mask), pressx, pressy); selected = (val > 127); if (rectangle_exists && selected) { if (gimp_channel_bounds (selection_mask, &x1, &y1, &x2, &y2)) { g_object_set (rectangle, "x1", x1, "y1", y1, "x2", x2, "y2", y2, NULL); } else { g_object_set (rectangle, "x1", 0, "y1", 0, "x2", gimage->width, "y2", gimage->height, NULL); } return FALSE; } g_object_get (rectangle, "x1", &rx1, "y1", &ry1, "x2", &rx2, "y2", &ry2, NULL); tool_iface->execute (rectangle, rx1, ry1, rx2 - rx1, ry2 - ry1); return TRUE; } static void gimp_rectangle_tool_update_options (GimpRectangleTool *rectangle, GimpDisplay *gdisp) { GimpDisplayShell *shell; gdouble width; gdouble height; gdouble aspect; gdouble center_x, center_y; GimpSizeEntry *entry; gint x1, y1, x2, y2; GimpRectangleOptions *options; shell = GIMP_DISPLAY_SHELL (gdisp->shell); g_object_get (rectangle, "dimensions-entry", &entry, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, NULL); options = GIMP_RECTANGLE_OPTIONS (GIMP_TOOL (rectangle)->tool_info->tool_options); width = x2 - x1; height = y2 - y1; if (width > 0.01) aspect = height / width; else aspect = 0; center_x = (x1 + x2) / 2; center_y = (y1 + y2) / 2; g_signal_handlers_block_by_func (entry, rectangle_dimensions_changed, rectangle); gimp_size_entry_set_refval (entry, 0, y2); gimp_size_entry_set_refval (entry, 1, x2); gimp_size_entry_set_refval (entry, 2, x1); gimp_size_entry_set_refval (entry, 3, y1); g_object_set (options, "width", width, NULL); g_object_set (options, "height", height, NULL); g_object_set (options, "aspect", aspect, NULL); g_object_set (options, "center-x", center_x, "center-y", center_y, NULL); g_signal_handlers_unblock_by_func (entry, rectangle_dimensions_changed, rectangle); } static GtkWidget * gimp_rectangle_controls (GimpRectangleTool *rectangle) { GtkWidget *vbox; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *entry; vbox = gtk_vbox_new (FALSE, 0); entry = gimp_size_entry_new (2, GIMP_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, 4, GIMP_SIZE_ENTRY_UPDATE_SIZE); g_object_set (rectangle, "dimensions-entry", entry, NULL); gtk_table_set_row_spacings (GTK_TABLE (entry), 3); gtk_table_set_col_spacings (GTK_TABLE (entry), 3); spinbutton = gimp_spin_button_new (&adjustment, 1, 0, 1, 1, 10, 1, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 4); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), spinbutton, 1, 2, 2, 3); gtk_widget_show (spinbutton); spinbutton = gimp_spin_button_new (&adjustment, 1, 0, 1, 1, 10, 1, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 4); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), spinbutton, 2, 3, 2, 3); gtk_widget_show (spinbutton); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("1 "), 1, 0, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("2 "), 2, 0, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("X"), 0, 1, 0.5); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("Y"), 0, 2, 0.5); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); g_signal_connect (entry, "value-changed", G_CALLBACK (rectangle_dimensions_changed), rectangle); gtk_widget_show (entry); gimp_rectangle_tool_zero_controls (rectangle); gtk_widget_show (vbox); return vbox; } static void gimp_rectangle_tool_zero_controls (GimpRectangleTool *rectangle) { GimpSizeEntry *entry; g_object_get (rectangle, "dimensions-entry", &entry, NULL); gimp_size_entry_set_refval (entry, 0, 0); gimp_size_entry_set_refval (entry, 1, 0); gimp_size_entry_set_refval (entry, 2, 0); gimp_size_entry_set_refval (entry, 3, 0); }