gimp/app/tools/gimprectangletool.c

/* 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 <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include "libgimpmath/gimpmath.h"
#include "libgimpconfig/gimpconfig.h"
#include "libgimpbase/gimpbase.h"
#include "libgimpwidgets/gimpwidgets.h"

#include "tools-types.h"

#include "core/gimpchannel.h"
#include "core/gimpchannel-select.h"
#include "core/gimpimage.h"
#include "core/gimpimage-crop.h"
#include "core/gimptoolinfo.h"
#include "core/gimpunit.h"
#include "core/gimp-utils.h"

#include "widgets/gimphelp-ids.h"
#include "widgets/gimpwidgets-utils.h"

#include "display/gimpcanvas.h"
#include "display/gimpdisplay.h"
#include "display/gimpdisplayshell.h"
#include "display/gimpdisplayshell-transform.h"

#include "gimpselectiontool.h"
#include "gimpselectionoptions.h"
#include "gimprectangletool.h"
#include "gimprectangleoptions.h"
#include "gimptoolcontrol.h"

#include "gimp-intl.h"


/*  speed of key movement  */
#define ARROW_VELOCITY 25

static void     gimp_rectangle_tool_class_init     (GimpRectangleToolClass *klass);
static void     gimp_rectangle_tool_init           (GimpRectangleTool      *rectangle_tool);

static GObject * gimp_rectangle_tool_constructor   (GType              type,
                                                    guint              n_params,
                                                    GObjectConstructParam *params);
static void     gimp_rectangle_tool_finalize       (GObject           *object);
static gboolean gimp_rectangle_tool_initialize     (GimpTool          *tool,
                                                    GimpDisplay       *gdisp);
static void     gimp_rectangle_tool_control        (GimpTool          *tool,
                                                    GimpToolAction     action,
                                                    GimpDisplay       *gdisp);
static void     gimp_rectangle_tool_button_press   (GimpTool          *tool,
                                                    GimpCoords        *coords,
                                                    guint32            time,
                                                    GdkModifierType    state,
                                                    GimpDisplay       *gdisp);
static void     gimp_rectangle_tool_button_release (GimpTool          *tool,
                                                    GimpCoords        *coords,
                                                    guint32            time,
                                                    GdkModifierType    state,
                                                    GimpDisplay       *gdisp);
static void     gimp_rectangle_tool_motion         (GimpTool          *tool,
                                                    GimpCoords        *coords,
                                                    guint32            time,
                                                    GdkModifierType    state,
                                                    GimpDisplay       *gdisp);
static gboolean gimp_rectangle_tool_key_press      (GimpTool          *tool,
                                                    GdkEventKey       *kevent,
                                                    GimpDisplay       *gdisp);
static void     gimp_rectangle_tool_modifier_key   (GimpTool          *tool,
                                                    GdkModifierType    key,
                                                    gboolean           press,
                                                    GdkModifierType    state,
                                                    GimpDisplay       *gdisp);
static void     gimp_rectangle_tool_oper_update    (GimpTool          *tool,
                                                    GimpCoords        *coords,
                                                    GdkModifierType    state,
                                                    GimpDisplay       *gdisp);
static void     gimp_rectangle_tool_cursor_update  (GimpTool          *tool,
                                                    GimpCoords        *coords,
                                                    GdkModifierType    state,
                                                    GimpDisplay       *gdisp);

static void     gimp_rectangle_tool_draw           (GimpDrawTool      *draw_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 gboolean rectangle_tool_execute             (GimpRectangleTool *rect_tool,
                                                    gint               x,
                                                    gint               y,
                                                    gint               w,
                                                    gint               h);

static gboolean gimp_rectangle_tool_real_execute   (GimpRectangleTool *rect_tool,
                                                    gint               x,
                                                    gint               y,
                                                    gint               w,
                                                    gint               h);
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);

static GimpDrawToolClass *parent_class = NULL;


/*  public functions  */

GType
gimp_rectangle_tool_get_type (void)
{
  static GType tool_type = 0;

  if (! tool_type)
    {
      static const GTypeInfo tool_info =
      {
        sizeof (GimpRectangleToolClass),
        (GBaseInitFunc) NULL,
        (GBaseFinalizeFunc) NULL,
        (GClassInitFunc) gimp_rectangle_tool_class_init,
        NULL,           /* class_finalize */
        NULL,           /* class_data     */
        sizeof (GimpRectangleTool),
        0,              /* n_preallocs    */
        (GInstanceInitFunc) gimp_rectangle_tool_init,
      };

      tool_type = g_type_register_static (GIMP_TYPE_SELECTION_TOOL,
                                          "GimpRectangleTool",
                                          &tool_info, 0);
    }

  return tool_type;
}

static void
gimp_rectangle_tool_class_init (GimpRectangleToolClass *klass)
{
  GObjectClass      *object_class    = G_OBJECT_CLASS (klass);
  GimpToolClass     *tool_class      = GIMP_TOOL_CLASS (klass);
  GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  object_class->constructor  = gimp_rectangle_tool_constructor;
  object_class->finalize     = gimp_rectangle_tool_finalize;

  tool_class->initialize     = gimp_rectangle_tool_initialize;
  tool_class->control        = gimp_rectangle_tool_control;
  tool_class->button_press   = gimp_rectangle_tool_button_press;
  tool_class->button_release = gimp_rectangle_tool_button_release;
  tool_class->motion         = gimp_rectangle_tool_motion;
  tool_class->key_press      = gimp_rectangle_tool_key_press;
  tool_class->modifier_key   = gimp_rectangle_tool_modifier_key;
  tool_class->oper_update    = gimp_rectangle_tool_oper_update;
  tool_class->cursor_update  = gimp_rectangle_tool_cursor_update;

  draw_tool_class->draw      = gimp_rectangle_tool_draw;
  klass->execute             = gimp_rectangle_tool_real_execute;
}

static void
gimp_rectangle_tool_init (GimpRectangleTool *rectangle)
{
  GimpTool     *tool                = GIMP_TOOL (rectangle);

  gimp_tool_control_set_preserve    (tool->control, FALSE);
  gimp_tool_control_set_dirty_mask  (tool->control, GIMP_DIRTY_IMAGE_SIZE);

  rectangle->selection_tool   = FALSE;
  rectangle->controls         = NULL;
  rectangle->dimensions_entry = NULL;
}

static GObject *
gimp_rectangle_tool_constructor (GType                  type,
                                 guint                  n_params,
                                 GObjectConstructParam *params)
{
  GObject           *object;
  GimpTool          *tool;
  GimpRectangleTool *rectangle;
  GtkContainer *controls_container;
  GObject           *options;

  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);

  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"));

  rectangle->controls = gimp_rectangle_controls (rectangle);
  gtk_container_add (controls_container, rectangle->controls);

  return object;
}

static void
gimp_rectangle_tool_finalize (GObject *object)
{
  GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (object);

  if (rectangle->controls)
    {
      gtk_widget_destroy (rectangle->controls);
      rectangle->controls = NULL;
    }

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static gboolean
gimp_rectangle_tool_initialize (GimpTool    *tool,
                                GimpDisplay *gdisp)
{
  GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool);
  GimpSizeEntry     *entry;

  entry = GIMP_SIZE_ENTRY (rectangle->dimensions_entry);

  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;
}

static 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;
    }

  GIMP_TOOL_CLASS (parent_class)->control (tool, action, gdisp);
}

static 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);
  GimpRectangleOptions  *options;

  options = GIMP_RECTANGLE_OPTIONS (tool->tool_info->tool_options);

  if (gdisp != tool->gdisp)
    {
      if (gimp_draw_tool_is_active (draw_tool))
        gimp_draw_tool_stop (draw_tool);

      rectangle->function = RECT_CREATING;
      gimp_tool_control_set_snap_offsets (tool->control, 0, 0, 0, 0);

      tool->gdisp = gdisp;

      rectangle->x2 = rectangle->x1 = ROUND (coords->x);
      rectangle->y2 = rectangle->y1 = ROUND (coords->y);

      rectangle_tool_start (rectangle);
    }

  rectangle->pressx = rectangle->lastx = rectangle->startx = ROUND (coords->x);
  rectangle->pressy = rectangle->lasty = rectangle->starty = ROUND (coords->y);

  gimp_tool_control_activate (tool->control);
}

static void
gimp_rectangle_tool_button_release (GimpTool        *tool,
                                    GimpCoords      *coords,
                                    guint32          time,
                                    GdkModifierType  state,
                                    GimpDisplay     *gdisp)
{
  GimpRectangleTool     *rectangle = GIMP_RECTANGLE_TOOL (tool);
  GimpRectangleOptions  *options;

  options = GIMP_RECTANGLE_OPTIONS (tool->tool_info->tool_options);

  gimp_tool_control_halt (tool->control);
  gimp_tool_pop_status (tool, gdisp);

  if (! (state & GDK_BUTTON3_MASK))
    {
      if ( (rectangle->lastx == rectangle->pressx) &&
           (rectangle->lasty == rectangle->pressy))
        {
          rectangle_response (NULL, GIMP_RECTANGLE_MODE_EXECUTE, rectangle);
        }

      rectangle_info_update (rectangle);
    }
}

static void
gimp_rectangle_tool_motion (GimpTool        *tool,
                            GimpCoords      *coords,
                            guint32          time,
                            GdkModifierType  state,
                            GimpDisplay     *gdisp)
{
  GimpRectangleTool *rectangle = GIMP_RECTANGLE_TOOL (tool);
  GimpRectangleOptions  *options;
  gint               x1, y1, x2, y2;
  gint               curx, cury;
  gint               inc_x, inc_y;
  gint               min_x, min_y, max_x, max_y;
  gboolean           fixed_width;
  gboolean           fixed_height;
  gboolean           fixed_aspect;
  gboolean           fixed_center;

  /*  This is the only case when the motion events should be ignored--
      we're just waiting for the button release event to execute  */
  if (rectangle->function == RECT_EXECUTING)
    return;

  curx = ROUND (coords->x);
  cury = ROUND (coords->y);

  x1 = rectangle->startx;
  y1 = rectangle->starty;
  x2 = curx;
  y2 = cury;

  if (rectangle->function == RECT_CREATING)
    {
      if (x1 > x2 && y1 > y2)
        rectangle->function = RECT_RESIZING_UPPER_LEFT;
      else if (x1 > x2 && y1 < y2)
        rectangle->function = RECT_RESIZING_LOWER_LEFT;
      else if (x1 < x2 && y1 > y2)
        rectangle->function = RECT_RESIZING_UPPER_RIGHT;
      else if (x1 < x2 && y1 < y2)
        rectangle->function = RECT_RESIZING_LOWER_RIGHT;
    }

  inc_x = (x2 - x1);
  inc_y = (y2 - y1);

  /*  If there have been no changes... return  */
  if (rectangle->lastx == x2 && rectangle->lasty == y2)
    return;

  options = GIMP_RECTANGLE_OPTIONS (tool->tool_info->tool_options);
  fixed_width  = options->fixed_width;
  fixed_height = options->fixed_height;
  fixed_aspect = options->fixed_aspect;
  fixed_center = options->fixed_center;

  gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));

  min_x = min_y = 0;
  max_x = gdisp->gimage->width;
  max_y = gdisp->gimage->height;

  switch (rectangle->function)
    {
    case RECT_CREATING:
      break;

    case RECT_RESIZING_UPPER_LEFT:
    case RECT_RESIZING_LOWER_LEFT:
    case RECT_RESIZING_LEFT:
      x1 = rectangle->x1 + inc_x;
      if (fixed_width)
        {
          x2 = x1 + options->width;
          if (x1 < 0)
            {
              x1 = 0;
              x2 = options->width;
            }
          if (x2 > max_x)
            {
              x2 = max_x;
              x1 = max_x - options->width;
            }
        }
      else if (fixed_center)
        {
          x2 = x1 + 2 * (options->center_x - x1);
          if (x1 < 0)
            {
              x1 = 0;
              x2 = 2 * options->center_x;
            }
          if (x2 > max_x)
            {
              x2 = max_x;
              x1 = max_x - 2 * (max_x - options->center_x);
            }
        }
      else
        {
          x2 = MAX (x1, rectangle->x2);
        }
      rectangle->startx = curx;
      break;

    case RECT_RESIZING_UPPER_RIGHT:
    case RECT_RESIZING_LOWER_RIGHT:
    case RECT_RESIZING_RIGHT:
      x2 = rectangle->x2 + inc_x;
      if (fixed_width)
        {
          x1 = x2 - options->width;
          if (x2 > max_x)
            {
              x2 = max_x;
              x1 = max_x - options->width;
            }
          if (x1 < 0)
            {
              x1 = 0;
              x2 = options->width;
            }
        }
      else if (fixed_center)
        {
          x1 = x2 - 2 * (x2 - options->center_x);
          if (x2 > max_x)
            {
              x2 = max_x;
              x1 = max_x - 2 * (max_x - options->center_x);
            }
          if (x1 < 0)
            {
              x1 = 0;
              x2 = 2 * options->center_x;
            }
        }
      else
        {
          x1 = MIN (rectangle->x1, x2);
        }
      rectangle->startx = curx;
      break;

    case RECT_RESIZING_BOTTOM:
    case RECT_RESIZING_TOP:
      x1 = rectangle->x1;
      x2 = rectangle->x2;
      rectangle->startx = curx;
      break;

    case RECT_MOVING:
      if (fixed_width &&
          (rectangle->x1 + inc_x < 0 ||
           rectangle->x2 + inc_x > max_x))
        {
          x1 = rectangle->x1;
          x2 = rectangle->x2;
        }
      else
        {
          x1 = rectangle->x1 + inc_x;
          x2 = rectangle->x2 + inc_x;
        }
      rectangle->startx = curx;
      break;
    }

  switch (rectangle->function)
    {
    case RECT_CREATING:
      break;

    case RECT_RESIZING_UPPER_LEFT:
    case RECT_RESIZING_UPPER_RIGHT:
    case RECT_RESIZING_TOP:
      y1 = rectangle->y1 + inc_y;
      if (fixed_height)
        {
          y2 = y1 + options->height;
          if (y1 < 0)
            {
              y1 = 0;
              y2 = options->height;
            }
          if (y2 > max_y)
            {
              y2 = max_y;
              y1 = max_y - options->height;
            }
        }
      else if (fixed_center)
        {
          y2 = y1 + 2 * (options->center_y - y1);
          if (y1 < 0)
            {
              y1 = 0;
              y2 = 2 * options->center_y;
            }
          if (y2 > max_y)
            {
              y2 = max_y;
              y1 = max_y - 2 * (max_y - options->center_y);
            }
        }
      else
        {
          y2 = MAX (y1, rectangle->y2);
        }
      rectangle->starty = cury;
      break;

    case RECT_RESIZING_LOWER_LEFT:
    case RECT_RESIZING_LOWER_RIGHT:
    case RECT_RESIZING_BOTTOM:
      y2 = rectangle->y2 + inc_y;
      if (fixed_height)
        {
          y1 = y2 - options->height;
          if (y2 > max_y)
            {
              y2 = max_y;
              y1 = max_y - options->height;
            }
          if (y1 < 0)
            {
              y1 = 0;
              y2 = options->height;
            }
        }
      else if (fixed_center)
        {
          y1 = y2 - 2 * (y2 - options->center_y);
          if (y2 > max_y)
            {
              y2 = max_y;
              y1 = max_y - 2 * (max_y - options->center_y);
            }
          if (y1 < 0)
            {
              y1 = 0;
              y2 = 2 * options->center_y;
            }
        }
      else
        {
          y1 = MIN (rectangle->y1, y2);
        }
      rectangle->starty = cury;
      break;

    case RECT_RESIZING_RIGHT:
    case RECT_RESIZING_LEFT:
      y1 = rectangle->y1;
      y2 = rectangle->y2;
      rectangle->starty = cury;
      break;

    case RECT_MOVING:
      if (fixed_height &&
          (rectangle->y1 + inc_y < 0 ||
          rectangle->y2 + inc_y > max_y))
        {
          y1 = rectangle->y1;
          y2 = rectangle->y2;
        }
      else
        {
          y1 = rectangle->y1 + inc_y;
          y2 = rectangle->y2 + inc_y;
        }
      rectangle->starty = cury;
      break;
    }

  /*  make sure that the coords are in bounds  */
  rectangle->x1 = MIN (x1, x2);
  rectangle->y1 = MIN (y1, y2);
  rectangle->x2 = MAX (x1, x2);
  rectangle->y2 = MAX (y1, y2);

  rectangle->lastx = curx;
  rectangle->lasty = cury;

  if (fixed_aspect)
    {
      gdouble aspect = options->aspect;

      if (aspect > max_y)
        aspect = max_y;
      if (aspect < 1.0 / max_x)
        aspect = 1.0 / max_x;

      switch (rectangle->function)
        {
        case RECT_RESIZING_UPPER_LEFT:
        case RECT_RESIZING_LEFT:
          rectangle->y2 = rectangle->y1 + aspect * (rectangle->x2 - rectangle->x1);
          if (rectangle->y2 > max_y)
            {
              rectangle->y2 = max_y;
              rectangle->x2 = rectangle->x1 + (rectangle->y2 - rectangle->y1) / aspect;
            }
          break;

        case RECT_RESIZING_UPPER_RIGHT:
        case RECT_RESIZING_RIGHT:
          rectangle->y2 = rectangle->y1 + aspect * (rectangle->x2 - rectangle->x1);
          if (rectangle->y2 > max_y)
            {
              rectangle->y2 = max_y;
              rectangle->x1 = rectangle->x2 - (rectangle->y2 - rectangle->y1) / aspect;
            }
          break;

        case RECT_RESIZING_LOWER_LEFT:
          rectangle->y1 = rectangle->y2 - aspect * (rectangle->x2 - rectangle->x1);
          if (rectangle->y1 < 0)
            {
              rectangle->y1 = 0;
              rectangle->x2 = rectangle->x1 + (rectangle->y2 - rectangle->y1) / aspect;
            }
          break;

        case RECT_RESIZING_LOWER_RIGHT:
          rectangle->y1 = rectangle->y2 - aspect * (rectangle->x2 - rectangle->x1);
          if (rectangle->y1 < 0)
            {
              rectangle->y1 = 0;
              rectangle->x1 = rectangle->x2 - (rectangle->y2 - rectangle->y1) / aspect;
            }
          break;

        case RECT_RESIZING_TOP:
          rectangle->x2 = rectangle->x1 + (rectangle->y2 - rectangle->y1) / aspect;
          if (rectangle->x2 > max_x)
            {
              rectangle->x2 = max_x;
              rectangle->y2 = rectangle->y1 + aspect * (rectangle->x2 - rectangle->x1);
            }
          break;

        case RECT_RESIZING_BOTTOM:
          rectangle->x2 = rectangle->x1 + (rectangle->y2 - rectangle->y1) / aspect;
          if (rectangle->x2 > max_x)
            {
              rectangle->x2 = max_x;
              rectangle->y1 = rectangle->y2 - aspect * (rectangle->x2 - rectangle->x1);
            }
          break;

        default:
          break;
        }
    }

  /*  recalculate the coordinates for rectangle_draw based on the new values  */
  rectangle_recalc (rectangle);

  switch (rectangle->function)
    {
    case RECT_RESIZING_UPPER_LEFT:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x1 - coords->x,
                                          rectangle->y1 - coords->y,
                                          0, 0);
      break;

    case RECT_RESIZING_UPPER_RIGHT:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x2 - coords->x,
                                          rectangle->y1 - coords->y,
                                          0, 0);
      break;

    case RECT_RESIZING_LOWER_LEFT:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x1 - coords->x,
                                          rectangle->y2 - coords->y,
                                          0, 0);
      break;

    case RECT_RESIZING_LOWER_RIGHT:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x2 - coords->x,
                                          rectangle->y2 - coords->y,
                                          0, 0);
      break;

    case RECT_RESIZING_LEFT:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x1 - coords->x, 0, 0, 0);
      break;

    case RECT_RESIZING_RIGHT:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x2 - coords->x, 0, 0, 0);
      break;

    case RECT_RESIZING_TOP:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          0, rectangle->y1 - coords->y, 0, 0);
      break;

    case RECT_RESIZING_BOTTOM:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          0, rectangle->y2 - coords->y, 0, 0);
      break;

    case RECT_MOVING:
      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x1 - coords->x,
                                          rectangle->y1 - coords->y,
                                          rectangle->x2 - rectangle->x1,
                                          rectangle->y2 - rectangle->y1);
      break;

    default:
      break;
    }

  gimp_rectangle_tool_update_options (rectangle, gdisp);

  if (rectangle->function == RECT_CREATING      ||
      rectangle->function == RECT_RESIZING_UPPER_LEFT ||
      rectangle->function == RECT_RESIZING_LOWER_RIGHT)
    {
      gimp_tool_pop_status (tool, gdisp);
      gimp_tool_push_status_coords (tool, gdisp,
                                    _("Rectangle: "),
                                    rectangle->x2 - rectangle->x1,
                                    " x ",
                                    rectangle->y2 - rectangle->y1);
    }

  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}

static 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;

  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;

  rectangle->x1 += inc_x;
  rectangle->x2 += inc_x;
  rectangle->y1 += inc_y;
  rectangle->y2 += inc_y;

  rectangle_recalc (rectangle);

  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));

  return TRUE;
}

static void
gimp_rectangle_tool_modifier_key (GimpTool        *tool,
                                  GdkModifierType  key,
                                  gboolean         press,
                                  GdkModifierType  state,
                                  GimpDisplay     *gdisp)
{
}

static 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);
  gboolean           inside_x;
  gboolean           inside_y;

  if (tool->gdisp != gdisp)
    {
      if (rectangle->selection_tool)
        GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, gdisp);

      return;
    }

  inside_x = coords->x > rectangle->x1 && coords->x < rectangle->x2;
  inside_y = coords->y > rectangle->y1 && coords->y < rectangle->y2;

  if (gimp_draw_tool_on_handle (draw_tool, gdisp,
                                coords->x, coords->y,
                                GIMP_HANDLE_SQUARE,
                                rectangle->x1, rectangle->y1,
                                rectangle->dcw, rectangle->dch,
                                GTK_ANCHOR_NORTH_WEST,
                                FALSE))
    {
      rectangle->function = RECT_RESIZING_UPPER_LEFT;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x1 - coords->x,
                                          rectangle->y1 - coords->y,
                                          0, 0);
    }
  else if (gimp_draw_tool_on_handle (draw_tool, gdisp,
                                     coords->x, coords->y,
                                     GIMP_HANDLE_SQUARE,
                                     rectangle->x2, rectangle->y2,
                                     rectangle->dcw, rectangle->dch,
                                     GTK_ANCHOR_SOUTH_EAST,
                                     FALSE))
    {
      rectangle->function = RECT_RESIZING_LOWER_RIGHT;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x2 - coords->x,
                                          rectangle->y2 - coords->y,
                                          0, 0);
    }
  else if  (gimp_draw_tool_on_handle (draw_tool, gdisp,
                                      coords->x, coords->y,
                                      GIMP_HANDLE_SQUARE,
                                      rectangle->x2, rectangle->y1,
                                      rectangle->dcw, rectangle->dch,
                                      GTK_ANCHOR_NORTH_EAST,
                                      FALSE))
    {
      rectangle->function = RECT_RESIZING_UPPER_RIGHT;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x2 - coords->x,
                                          rectangle->y1 - coords->y,
                                          0, 0);
    }
  else if (gimp_draw_tool_on_handle (draw_tool, gdisp,
                                     coords->x, coords->y,
                                     GIMP_HANDLE_SQUARE,
                                     rectangle->x1, rectangle->y2,
                                     rectangle->dcw, rectangle->dch,
                                     GTK_ANCHOR_SOUTH_WEST,
                                     FALSE))
    {
      rectangle->function = RECT_RESIZING_LOWER_LEFT;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x1 - coords->x,
                                          rectangle->y2 - coords->y,
                                          0, 0);
    }
  else if ( (fabs (coords->x - rectangle->x1) < rectangle->dcw) && inside_y)
    {
      rectangle->function = RECT_RESIZING_LEFT;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x1 - coords->x, 0, 0, 0);

    }
  else if ( (fabs (coords->x - rectangle->x2) < rectangle->dcw) && inside_y)
    {
      rectangle->function = RECT_RESIZING_RIGHT;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          rectangle->x2 - coords->x, 0, 0, 0);

    }
  else if ( (fabs (coords->y - rectangle->y1) < rectangle->dch) && inside_x)
    {
      rectangle->function = RECT_RESIZING_TOP;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          0, rectangle->y1 - coords->y, 0, 0);

    }
  else if ( (fabs (coords->y - rectangle->y2) < rectangle->dch) && inside_x)
    {
      rectangle->function = RECT_RESIZING_BOTTOM;

      gimp_tool_control_set_snap_offsets (tool->control,
                                          0, rectangle->y2 - coords->y, 0, 0);

    }
  else if (inside_x && inside_y)
    {
      rectangle->function = RECT_MOVING;
    }
  /*  otherwise, the new function will be creating, since we want
   *  to start a new rectangle
   */
  else
    {
      rectangle->function = RECT_CREATING;

      gimp_tool_control_set_snap_offsets (tool->control, 0, 0, 0, 0);
    }

}

static void
gimp_rectangle_tool_cursor_update (GimpTool        *tool,
                                   GimpCoords      *coords,
                                   GdkModifierType  state,
                                   GimpDisplay     *gdisp)
{
  GimpRectangleTool     *rectangle   = GIMP_RECTANGLE_TOOL (tool);
  GimpRectangleOptions  *options;
  GimpCursorType         cursor      = GDK_CROSSHAIR;
  GimpCursorModifier     modifier    = GIMP_CURSOR_MODIFIER_NONE;
  GimpToolCursorType     tool_cursor;

  tool_cursor = gimp_tool_control_get_tool_cursor (tool->control);

  options = GIMP_RECTANGLE_OPTIONS (tool->tool_info->tool_options);

  if (tool->gdisp == gdisp && ! (state & GDK_BUTTON1_MASK))
    {
      switch (rectangle->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));
}

static 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);

  gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR,
                         rectangle->dx1, rectangle->dy1,
                         rectangle->dx2, rectangle->dy1);
  gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR,
                         rectangle->dx1, rectangle->dy1,
                         rectangle->dx1, rectangle->dy2);
  gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR,
                         rectangle->dx2, rectangle->dy2,
                         rectangle->dx1, rectangle->dy2);
  gimp_canvas_draw_line (canvas, GIMP_CANVAS_STYLE_XOR,
                         rectangle->dx2, rectangle->dy2,
                         rectangle->dx2, rectangle->dy1);
}

static void
rectangle_recalc (GimpRectangleTool *rectangle)
{
  GimpTool              *tool     = GIMP_TOOL (rectangle);
  GimpDisplayShell      *shell    = GIMP_DISPLAY_SHELL (tool->gdisp->shell);
  GimpRectangleOptions  *options;

  options = GIMP_RECTANGLE_OPTIONS (tool->tool_info->tool_options);

  if (! tool->gdisp)
    return;

  if (options->highlight)
    {
      GdkRectangle rect;

      rect.x      = rectangle->x1;
      rect.y      = rectangle->y1;
      rect.width  = rectangle->x2 - rectangle->x1;
      rect.height = rectangle->y2 - rectangle->y1;

      gimp_display_shell_set_highlight (shell, &rect);
    }

  gimp_display_shell_transform_xy (shell,
                                   rectangle->x1, rectangle->y1,
                                   &rectangle->dx1, &rectangle->dy1,
                                   FALSE);
  gimp_display_shell_transform_xy (shell,
                                   rectangle->x2, rectangle->y2,
                                   &rectangle->dx2, &rectangle->dy2,
                                   FALSE);

#define SRW 10
#define SRH 10

  rectangle->dcw = ((rectangle->dx2 - rectangle->dx1) < SRW) ?
    (rectangle->dx2 - rectangle->dx1) : SRW;

  rectangle->dch = ((rectangle->dy2 - rectangle->dy1) < SRH) ?
    (rectangle->dy2 - rectangle->dy1) : SRH;

#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)
{
  rectangle->orig_vals[0] = rectangle->x1;
  rectangle->orig_vals[1] = rectangle->y1;
  rectangle->size_vals[0] = rectangle->x2 - rectangle->x1;
  rectangle->size_vals[1] = rectangle->y2 - rectangle->y1;

}

static void
rectangle_response (GtkWidget         *widget,
                    gint               response_id,
                    GimpRectangleTool *rectangle)
{
  GimpTool *tool = GIMP_TOOL (rectangle);
  gboolean  finish;

  gimp_draw_tool_pause (GIMP_DRAW_TOOL (rectangle));

  finish = rectangle_tool_execute (GIMP_RECTANGLE_TOOL (tool),
                                   rectangle->x1, rectangle->y1,
                                   rectangle->x2 - rectangle->x1,
                                   rectangle->y2 - rectangle->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 (GIMP_TOOL (rectangle)->control))
        gimp_tool_control_halt (GIMP_TOOL (rectangle)->control);

      gimp_image_flush (tool->gdisp->gimage);

      tool->gdisp    = NULL;
      tool->drawable = NULL;

    }
}

static void
rectangle_selection_callback (GtkWidget         *widget,
                              GimpRectangleTool *rectangle)
{
  GimpRectangleOptions *options;
  GimpDisplay          *gdisp;

  options = GIMP_RECTANGLE_OPTIONS (GIMP_TOOL (rectangle)->tool_info->tool_options);
  gdisp   = GIMP_TOOL (rectangle)->gdisp;

  gimp_draw_tool_pause (GIMP_DRAW_TOOL (rectangle));

  if (! gimp_channel_bounds (gimp_image_get_mask (gdisp->gimage),
                             &rectangle->x1, &rectangle->y1,
                             &rectangle->x2, &rectangle->y2))
    {
      rectangle->x1 = rectangle->y1 = 0;
      rectangle->x2 = gdisp->gimage->width;
      rectangle->y2 = gdisp->gimage->height;
    }

  rectangle_recalc (rectangle);

  gimp_draw_tool_resume (GIMP_DRAW_TOOL (rectangle));
}

static void
rectangle_automatic_callback (GtkWidget         *widget,
                              GimpRectangleTool *rectangle)
{
  GimpRectangleOptions *options;
  GimpDisplay          *gdisp;
  gint                  offset_x, offset_y;
  gint                  width, height;
  gint                  x1, y1, x2, y2;
  gint                  shrunk_x1;
  gint                  shrunk_y1;
  gint                  shrunk_x2;
  gint                  shrunk_y2;

  options = GIMP_RECTANGLE_OPTIONS (GIMP_TOOL (rectangle)->tool_info->tool_options);
  gdisp   = GIMP_TOOL (rectangle)->gdisp;

  width    = gdisp->gimage->width;
  height   = gdisp->gimage->height;
  offset_x = 0;
  offset_y = 0;

  x1 = rectangle->x1 - offset_x  > 0      ? rectangle->x1 - offset_x : 0;
  x2 = rectangle->x2 - offset_x  < width  ? rectangle->x2 - offset_x : width;
  y1 = rectangle->y1 - offset_y  > 0      ? rectangle->y1 - offset_y : 0;
  y2 = rectangle->y2 - offset_y  < height ? rectangle->y2 - 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));

      rectangle->x1 = offset_x + shrunk_x1;
      rectangle->x2 = offset_x + shrunk_x2;
      rectangle->y1 = offset_y + shrunk_y1;
      rectangle->y2 = offset_y + shrunk_y2;

      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);
  gdouble         x1, y1, x2, y2;
  GimpCoords      coords;

  if (! GIMP_TOOL (rectangle)->gdisp)
    return;

  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 != rectangle->x1)
    {
      rectangle->function = RECT_RESIZING_LEFT;
      coords.x = x1;
      coords.y = y1;
      rectangle->startx = rectangle->x1;
      rectangle->starty = rectangle->y1;
    }
  else if (y1 != rectangle->y1)
    {
      rectangle->function = RECT_RESIZING_TOP;
      coords.x = x1;
      coords.y = y1;
      rectangle->startx = rectangle->x1;
      rectangle->starty = rectangle->y1;
    }
  else if (x2 != rectangle->x2)
    {
      rectangle->function = RECT_RESIZING_RIGHT;
      coords.x = x2;
      coords.y = y2;
      rectangle->startx = rectangle->x2;
      rectangle->starty = rectangle->y2;
    }
  else if (y2 != rectangle->y2)
    {
      rectangle->function = RECT_RESIZING_BOTTOM;
      coords.x = x2;
      coords.y = y2;
      rectangle->startx = rectangle->x2;
      rectangle->starty = rectangle->y2;
    }
  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);
}

void
rectangle_width_changed (GimpRectangleTool *rectangle,
                         gint               new_width)
{
  gimp_draw_tool_pause (GIMP_DRAW_TOOL (rectangle));

  rectangle->x2 = rectangle->x1 + new_width;

  rectangle_recalc (rectangle);

  gimp_draw_tool_resume (GIMP_DRAW_TOOL (rectangle));
}

static gboolean
rectangle_tool_execute (GimpRectangleTool *rect_tool,
                        gint               x,
                        gint               y,
                        gint               w,
                        gint               h)
{
  GimpTool             *tool;
  GimpSelectionOptions *options;

  g_return_val_if_fail (GIMP_IS_RECTANGLE_TOOL (rect_tool), FALSE);

  tool    = GIMP_TOOL (rect_tool);
  options = GIMP_SELECTION_OPTIONS (tool->tool_info->tool_options);

  if (options->auto_shrink)
    {
      gint off_x = 0;
      gint off_y = 0;
      gint x2, y2;

      if (! gimp_rectangle_intersect (x, y, w, h,
                                      0, 0,
                                      tool->gdisp->gimage->width,
                                      tool->gdisp->gimage->height,
                                      &x, &y, &w, &h))
        {
          return FALSE;
        }

      if (! options->shrink_merged)
        {
          GimpItem *item;
          gint      width, height;

          item = GIMP_ITEM (gimp_image_active_drawable (tool->gdisp->gimage));

          gimp_item_offsets (item, &off_x, &off_y);
          width  = gimp_item_width  (item);
          height = gimp_item_height (item);

          if (! gimp_rectangle_intersect (x, y, w, h,
                                          off_x, off_y, width, height,
                                          &x, &y, &w, &h))
            {
              return FALSE;
            }

          x -= off_x;
          y -= off_y;
        }

      if (gimp_image_crop_auto_shrink (tool->gdisp->gimage,
                                       x, y,
                                       x + w, y + h,
                                       ! options->shrink_merged,
                                       &x, &y,
                                       &x2, &y2))
        {
          w = x2 - x;
          h = y2 - y;
        }

      x += off_x;
      y += off_y;
    }

  return GIMP_RECTANGLE_TOOL_GET_CLASS (rect_tool)->execute (rect_tool, x, y, w, h);
}

static gboolean
gimp_rectangle_tool_real_execute (GimpRectangleTool *rectangle,
                                  gint               x,
                                  gint               y,
                                  gint               w,
                                  gint               h)
{
  GimpTool    *tool             = GIMP_TOOL (rectangle);
  gboolean     rectangle_exists = (rectangle->function != RECT_CREATING);
  GimpChannel *selection_mask;
  gint         val;
  gboolean     selected;
  GimpImage   *gimage;

  gimage = tool->gdisp->gimage;
  selection_mask = gimp_image_get_mask (gimage);
  val = gimp_channel_value (selection_mask,
                            rectangle->pressx, rectangle->pressy);

  selected = (val > 127);

  if (rectangle_exists && selected)
    {
      if (! gimp_channel_bounds (selection_mask,
                                 &rectangle->x1, &rectangle->y1,
                                 &rectangle->x2, &rectangle->y2))
        {
          rectangle->x1 = 0;
          rectangle->y1 = 0;
          rectangle->x2 = gimage->width;
          rectangle->y2 = gimage->height;
        }

      return FALSE;
    }

  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;
  GimpRectangleOptions *options;
  shell = GIMP_DISPLAY_SHELL (gdisp->shell);

  entry   = GIMP_SIZE_ENTRY (rectangle->dimensions_entry);
  options = GIMP_RECTANGLE_OPTIONS (GIMP_TOOL (rectangle)->tool_info->tool_options);

  width  = rectangle->x2 - rectangle->x1;
  height = rectangle->y2 - rectangle->y1;

  if (width > 0.01)
    aspect = height / width;
  else
    aspect = 0;

  center_x = (rectangle->x1 + rectangle->x2) / 2;
  center_y = (rectangle->y1 + rectangle->y2) / 2;

  g_signal_handlers_block_by_func (rectangle->dimensions_entry,
                                   rectangle_dimensions_changed,
                                   rectangle);

  gimp_size_entry_set_refval (entry, 0, rectangle->y2);
  gimp_size_entry_set_refval (entry, 1, rectangle->x2);
  gimp_size_entry_set_refval (entry, 2, rectangle->x1);
  gimp_size_entry_set_refval (entry, 3, rectangle->y1);

  if (!options->fixed_width)
    g_object_set (options, "width",  width, NULL);

  if (!options->fixed_height)
    g_object_set (options, "height", height, NULL);

  if (!options->fixed_aspect)
    g_object_set (options, "aspect", aspect, NULL);

  if (!options->fixed_center)
    g_object_set (options,
                  "center-x", center_x,
                  "center-y", center_y,
                  NULL);

  g_signal_handlers_unblock_by_func (rectangle->dimensions_entry,
                                     rectangle_dimensions_changed,
                                     rectangle);
}

static GtkWidget *
gimp_rectangle_controls (GimpRectangleTool *rectangle)
{
  GtkWidget            *vbox;
  GtkObject            *adjustment;
  GtkWidget            *spinbutton;
  GimpRectangleOptions *options;
  GtkWidget            *entry;

  options = GIMP_RECTANGLE_OPTIONS (GIMP_TOOL (rectangle)->tool_info->tool_options);

  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);
  rectangle->dimensions_entry = entry;

  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 = GIMP_SIZE_ENTRY (rectangle->dimensions_entry);

  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);
}