Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1266 insertions, 0 deletions

diff --git a/app/tools/gimprectangleoptions.c b/app/tools/gimprectangleoptions.c
new file mode 100644
index 0000000..aff6870
--- /dev/null
+++ b/app/tools/gimprectangleoptions.c
@@ -0,0 +1,1266 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995-1999 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "tools-types.h"
+
+#include "core/gimpimage.h"
+#include "core/gimptooloptions.h"
+
+#include "widgets/gimppropwidgets.h"
+
+#include "gimprectangleoptions.h"
+#include "gimptooloptions-gui.h"
+
+#include "gimp-intl.h"
+
+
+#define SB_WIDTH 5
+
+
+enum
+{
+  COLUMN_LEFT_NUMBER,
+  COLUMN_RIGHT_NUMBER,
+  COLUMN_TEXT,
+  N_COLUMNS
+};
+
+
+/*  local function prototypes  */
+
+static void     gimp_rectangle_options_fixed_rule_changed     (GtkWidget                   *combo_box,
+                                                               GimpRectangleOptionsPrivate *private);
+
+static void     gimp_rectangle_options_string_current_updates (GimpNumberPairEntry         *entry,
+                                                               GParamSpec                  *param,
+                                                               GimpRectangleOptions        *rectangle_options);
+static void     gimp_rectangle_options_setup_ratio_completion (GimpRectangleOptions        *rectangle_options,
+                                                               GtkWidget                   *entry,
+                                                               GtkListStore                *history);
+
+static gboolean gimp_number_pair_entry_history_select         (GtkEntryCompletion          *completion,
+                                                               GtkTreeModel                *model,
+                                                               GtkTreeIter                 *iter,
+                                                               GimpNumberPairEntry         *entry);
+
+static void     gimp_number_pair_entry_history_add            (GtkWidget                   *entry,
+                                                               GtkTreeModel                *model);
+
+
+G_DEFINE_INTERFACE (GimpRectangleOptions, gimp_rectangle_options, GIMP_TYPE_TOOL_OPTIONS)
+
+
+static void
+gimp_rectangle_options_default_init (GimpRectangleOptionsInterface *iface)
+{
+  g_object_interface_install_property (iface,
+                                       g_param_spec_boolean ("auto-shrink",
+                                                             NULL,
+                                                             _("Automatically shrink to the nearest "
+                                                               "rectangular shape in a layer"),
+                                                             FALSE,
+                                                             GIMP_CONFIG_PARAM_FLAGS |
+                                                             GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_boolean ("shrink-merged",
+                                                             _("Shrink merged"),
+                                                             _("Use all visible layers when shrinking "
+                                                               "the selection"),
+                                                             FALSE,
+                                                             GIMP_CONFIG_PARAM_FLAGS |
+                                                             GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_enum ("guide",
+                                                          NULL,
+                                                          _("Composition guides such as rule of thirds"),
+                                                          GIMP_TYPE_GUIDES_TYPE,
+                                                          GIMP_GUIDES_NONE,
+                                                          GIMP_CONFIG_PARAM_FLAGS |
+                                                          GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("x",
+                                                            NULL,
+                                                            _("X coordinate of top left corner"),
+                                                            -GIMP_MAX_IMAGE_SIZE,
+                                                            GIMP_MAX_IMAGE_SIZE,
+                                                            0.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("y",
+                                                            NULL,
+                                                            _("Y coordinate of top left corner"),
+                                                            -GIMP_MAX_IMAGE_SIZE,
+                                                            GIMP_MAX_IMAGE_SIZE,
+                                                            0.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("width",
+                                                            NULL,
+                                                            _("Width of selection"),
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            0.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("height",
+                                                            NULL,
+                                                            _("Height of selection"),
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            0.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       gimp_param_spec_unit ("position-unit",
+                                                             NULL,
+                                                             _("Unit of top left corner coordinate"),
+                                                             TRUE, TRUE,
+                                                             GIMP_UNIT_PIXEL,
+                                                             GIMP_PARAM_READWRITE |
+                                                             G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       gimp_param_spec_unit ("size-unit",
+                                                             NULL,
+                                                             _("Unit of selection size"),
+                                                             TRUE, TRUE,
+                                                             GIMP_UNIT_PIXEL,
+                                                             GIMP_PARAM_READWRITE |
+                                                             G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_boolean ("fixed-rule-active",
+                                                             NULL,
+                                                             _("Enable lock of aspect ratio, "
+                                                               "width, height or size"),
+                                                             FALSE,
+                                                             GIMP_CONFIG_PARAM_FLAGS |
+                                                             GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_enum ("fixed-rule",
+                                                          NULL,
+                                                          _("Choose what has to be locked"),
+                                                          GIMP_TYPE_RECTANGLE_FIXED_RULE,
+                                                          GIMP_RECTANGLE_FIXED_ASPECT,
+                                                          GIMP_CONFIG_PARAM_FLAGS |
+                                                          GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("desired-fixed-width",
+                                                            NULL,
+                                                            _("Custom fixed width"),
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            100.0,
+                                                            GIMP_CONFIG_PARAM_FLAGS |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("desired-fixed-height",
+                                                            NULL,
+                                                            _("Custom fixed height"),
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            100.0,
+                                                            GIMP_CONFIG_PARAM_FLAGS |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("desired-fixed-size-width",
+                                                            NULL, NULL,
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            100.0,
+                                                            GIMP_CONFIG_PARAM_FLAGS |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("desired-fixed-size-height",
+                                                            NULL, NULL,
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            100.0,
+                                                            GIMP_CONFIG_PARAM_FLAGS |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("default-fixed-size-width",
+                                                            NULL, NULL,
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            100.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("default-fixed-size-height",
+                                                            NULL, NULL,
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            100.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_boolean ("overridden-fixed-size",
+                                                             NULL, NULL,
+                                                             FALSE,
+                                                             GIMP_CONFIG_PARAM_FLAGS |
+                                                             GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("aspect-numerator",
+                                                            NULL, NULL,
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            1.0,
+                                                            GIMP_CONFIG_PARAM_FLAGS |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("aspect-denominator",
+                                                            NULL, NULL,
+                                                            0.0, GIMP_MAX_IMAGE_SIZE,
+                                                            1.0,
+                                                            GIMP_CONFIG_PARAM_FLAGS |
+                                                            GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("default-aspect-numerator",
+                                                            NULL, NULL,
+                                                            0.001, GIMP_MAX_IMAGE_SIZE,
+                                                            1.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_double ("default-aspect-denominator",
+                                                            NULL, NULL,
+                                                            0.001, GIMP_MAX_IMAGE_SIZE,
+                                                            1.0,
+                                                            GIMP_PARAM_READWRITE |
+                                                            G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_boolean ("overridden-fixed-aspect",
+                                                             NULL, NULL,
+                                                             FALSE,
+                                                             GIMP_CONFIG_PARAM_FLAGS |
+                                                             GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_boolean ("use-string-current",
+                                                             NULL, NULL,
+                                                             FALSE,
+                                                             GIMP_PARAM_READWRITE |
+                                                             GIMP_PARAM_STATIC_STRINGS));
+
+  g_object_interface_install_property (iface,
+                                       gimp_param_spec_unit ("fixed-unit",
+                                                             NULL,
+                                                             _("Unit of fixed width, height or size"),
+                                                             TRUE, TRUE,
+                                                             GIMP_UNIT_PIXEL,
+                                                             GIMP_PARAM_READWRITE |
+                                                             G_PARAM_CONSTRUCT));
+
+  g_object_interface_install_property (iface,
+                                       g_param_spec_boolean ("fixed-center",
+                                                             _("Expand from center"),
+                                                             _("Expand selection from center outwards"),
+                                                             FALSE,
+                                                             GIMP_CONFIG_PARAM_FLAGS |
+                                                             GIMP_PARAM_STATIC_STRINGS));
+}
+
+static void
+gimp_rectangle_options_private_finalize (GimpRectangleOptionsPrivate *private)
+{
+  g_clear_object (&private->aspect_history);
+  g_clear_object (&private->size_history);
+
+  g_slice_free (GimpRectangleOptionsPrivate, private);
+}
+
+GimpRectangleOptionsPrivate *
+gimp_rectangle_options_get_private (GimpRectangleOptions *options)
+{
+  GimpRectangleOptionsPrivate *private;
+
+  static GQuark private_key = 0;
+
+  g_return_val_if_fail (GIMP_IS_RECTANGLE_OPTIONS (options), NULL);
+
+  if (! private_key)
+    private_key = g_quark_from_static_string ("gimp-rectangle-options-private");
+
+  private = g_object_get_qdata (G_OBJECT (options), private_key);
+
+  if (! private)
+    {
+      private = g_slice_new0 (GimpRectangleOptionsPrivate);
+
+      private->aspect_history = gtk_list_store_new (N_COLUMNS,
+                                                    G_TYPE_DOUBLE,
+                                                    G_TYPE_DOUBLE,
+                                                    G_TYPE_STRING);
+
+      private->size_history = gtk_list_store_new (N_COLUMNS,
+                                                  G_TYPE_DOUBLE,
+                                                  G_TYPE_DOUBLE,
+                                                  G_TYPE_STRING);
+
+      g_object_set_qdata_full (G_OBJECT (options), private_key, private,
+                               (GDestroyNotify) gimp_rectangle_options_private_finalize);
+    }
+
+  return private;
+}
+
+/**
+ * gimp_rectangle_options_install_properties:
+ * @klass: the class structure for a type deriving from #GObject
+ *
+ * Installs the necessary properties for a class implementing
+ * #GimpRectangleOptions. A #GimpRectangleOptionsProp property is installed
+ * for each property, using the values from the #GimpRectangleOptionsProp
+ * 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_OPTIONS_PROP_LAST is good for).
+ **/
+void
+gimp_rectangle_options_install_properties (GObjectClass *klass)
+{
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_AUTO_SHRINK,
+                                    "auto-shrink");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_SHRINK_MERGED,
+                                    "shrink-merged");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_GUIDE,
+                                    "guide");
+
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_X,
+                                    "x");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_Y,
+                                    "y");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_WIDTH,
+                                    "width");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_HEIGHT,
+                                    "height");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_POSITION_UNIT,
+                                    "position-unit");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_SIZE_UNIT,
+                                    "size-unit");
+
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_FIXED_RULE_ACTIVE,
+                                    "fixed-rule-active");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_FIXED_RULE,
+                                    "fixed-rule");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_WIDTH,
+                                    "desired-fixed-width");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_HEIGHT,
+                                    "desired-fixed-height");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_SIZE_WIDTH,
+                                    "desired-fixed-size-width");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_SIZE_HEIGHT,
+                                    "desired-fixed-size-height");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_FIXED_SIZE_WIDTH,
+                                    "default-fixed-size-width");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_FIXED_SIZE_HEIGHT,
+                                    "default-fixed-size-height");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_OVERRIDDEN_FIXED_SIZE,
+                                    "overridden-fixed-size");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_ASPECT_NUMERATOR,
+                                    "aspect-numerator");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_ASPECT_DENOMINATOR,
+                                    "aspect-denominator");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_ASPECT_NUMERATOR,
+                                    "default-aspect-numerator");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_ASPECT_DENOMINATOR,
+                                    "default-aspect-denominator");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_OVERRIDDEN_FIXED_ASPECT,
+                                    "overridden-fixed-aspect");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_USE_STRING_CURRENT,
+                                    "use-string-current");
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_FIXED_UNIT,
+                                    "fixed-unit");
+
+  g_object_class_override_property (klass,
+                                    GIMP_RECTANGLE_OPTIONS_PROP_FIXED_CENTER,
+                                    "fixed-center");
+}
+
+void
+gimp_rectangle_options_set_property (GObject      *object,
+                                     guint         property_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec)
+{
+  GimpRectangleOptions        *options  = GIMP_RECTANGLE_OPTIONS (object);
+  GimpRectangleOptionsPrivate *private;
+
+  private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (options);
+
+  switch (property_id)
+    {
+    case GIMP_RECTANGLE_OPTIONS_PROP_AUTO_SHRINK:
+      private->auto_shrink = g_value_get_boolean (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_SHRINK_MERGED:
+      private->shrink_merged = g_value_get_boolean (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT:
+      private->highlight = g_value_get_boolean (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT_OPACITY:
+      private->highlight_opacity = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_GUIDE:
+      private->guide = g_value_get_enum (value);
+      break;
+
+    case GIMP_RECTANGLE_OPTIONS_PROP_X:
+      private->x = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_Y:
+      private->y = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_WIDTH:
+      private->width = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_HEIGHT:
+      private->height = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_POSITION_UNIT:
+      private->position_unit = g_value_get_int (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_SIZE_UNIT:
+      private->size_unit = g_value_get_int (value);
+      break;
+
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_RULE_ACTIVE:
+      private->fixed_rule_active = g_value_get_boolean (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_RULE:
+      private->fixed_rule = g_value_get_enum (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_WIDTH:
+      private->desired_fixed_width = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_HEIGHT:
+      private->desired_fixed_height = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_SIZE_WIDTH:
+      private->desired_fixed_size_width = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_SIZE_HEIGHT:
+      private->desired_fixed_size_height = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_FIXED_SIZE_WIDTH:
+      private->default_fixed_size_width = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_FIXED_SIZE_HEIGHT:
+      private->default_fixed_size_height = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_OVERRIDDEN_FIXED_SIZE:
+      private->overridden_fixed_size = g_value_get_boolean (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_ASPECT_NUMERATOR:
+      private->aspect_numerator = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_ASPECT_DENOMINATOR:
+      private->aspect_denominator = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_ASPECT_NUMERATOR:
+      private->default_aspect_numerator = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_ASPECT_DENOMINATOR:
+      private->default_aspect_denominator = g_value_get_double (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_OVERRIDDEN_FIXED_ASPECT:
+      private->overridden_fixed_aspect = g_value_get_boolean (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_USE_STRING_CURRENT:
+      private->use_string_current = g_value_get_boolean (value);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_UNIT:
+      private->fixed_unit = g_value_get_int (value);
+      break;
+
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_CENTER:
+      private->fixed_center = g_value_get_boolean (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+void
+gimp_rectangle_options_get_property (GObject      *object,
+                                     guint         property_id,
+                                     GValue       *value,
+                                     GParamSpec   *pspec)
+{
+  GimpRectangleOptions        *options  = GIMP_RECTANGLE_OPTIONS (object);
+  GimpRectangleOptionsPrivate *private;
+
+  private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (options);
+
+  switch (property_id)
+    {
+    case GIMP_RECTANGLE_OPTIONS_PROP_AUTO_SHRINK:
+      g_value_set_boolean (value, private->auto_shrink);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_SHRINK_MERGED:
+      g_value_set_boolean (value, private->shrink_merged);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT:
+      g_value_set_boolean (value, private->highlight);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT_OPACITY:
+      g_value_set_double (value, private->highlight_opacity);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_GUIDE:
+      g_value_set_enum (value, private->guide);
+      break;
+
+    case GIMP_RECTANGLE_OPTIONS_PROP_X:
+      g_value_set_double (value, private->x);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_Y:
+      g_value_set_double (value, private->y);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_WIDTH:
+      g_value_set_double (value, private->width);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_HEIGHT:
+      g_value_set_double (value, private->height);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_POSITION_UNIT:
+      g_value_set_int (value, private->position_unit);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_SIZE_UNIT:
+      g_value_set_int (value, private->size_unit);
+      break;
+
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_RULE_ACTIVE:
+      g_value_set_boolean (value, private->fixed_rule_active);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_RULE:
+      g_value_set_enum (value, private->fixed_rule);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_WIDTH:
+      g_value_set_double (value, private->desired_fixed_width);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_HEIGHT:
+      g_value_set_double (value, private->desired_fixed_height);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_SIZE_WIDTH:
+      g_value_set_double (value, private->desired_fixed_size_width);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DESIRED_FIXED_SIZE_HEIGHT:
+      g_value_set_double (value, private->desired_fixed_size_height);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_FIXED_SIZE_WIDTH:
+      g_value_set_double (value, private->default_fixed_size_width);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_FIXED_SIZE_HEIGHT:
+      g_value_set_double (value, private->default_fixed_size_height);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_OVERRIDDEN_FIXED_SIZE:
+      g_value_set_boolean (value, private->overridden_fixed_size);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_ASPECT_NUMERATOR:
+      g_value_set_double (value, private->aspect_numerator);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_ASPECT_DENOMINATOR:
+      g_value_set_double (value, private->aspect_denominator);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_ASPECT_NUMERATOR:
+      g_value_set_double (value, private->default_aspect_numerator);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_DEFAULT_ASPECT_DENOMINATOR:
+      g_value_set_double (value, private->default_aspect_denominator);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_OVERRIDDEN_FIXED_ASPECT:
+      g_value_set_boolean (value, private->overridden_fixed_aspect);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_USE_STRING_CURRENT:
+      g_value_set_boolean (value, private->use_string_current);
+      break;
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_UNIT:
+      g_value_set_int (value, private->fixed_unit);
+      break;
+
+    case GIMP_RECTANGLE_OPTIONS_PROP_FIXED_CENTER:
+      g_value_set_boolean (value, private->fixed_center);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+/**
+ * gimp_rectangle_options_get_size_entry:
+ * @rectangle_options:
+ *
+ * Returns: GtkEntry used to enter desired size of rectangle. For
+ *          testing purposes.
+ **/
+GtkWidget *
+gimp_rectangle_options_get_size_entry (GimpRectangleOptions *rectangle_options)
+{
+  GimpRectangleOptionsPrivate *private;
+
+  private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (rectangle_options);
+
+  return private->size_entry;
+}
+
+/**
+ * gimp_rectangle_options_fixed_rule_changed:
+ * @combo_box:
+ * @private:
+ *
+ * Updates tool options widgets depending on current fixed rule state.
+ */
+static void
+gimp_rectangle_options_fixed_rule_changed (GtkWidget                   *combo_box,
+                                           GimpRectangleOptionsPrivate *private)
+{
+  /* Setup sensitivity for Width and Height entries */
+
+  gtk_widget_set_sensitive (gimp_size_entry_get_help_widget (
+                              GIMP_SIZE_ENTRY (private->size_entry), 0),
+                            ! (private->fixed_rule_active &&
+                               (private->fixed_rule ==
+                                GIMP_RECTANGLE_FIXED_WIDTH ||
+                                private->fixed_rule ==
+                                GIMP_RECTANGLE_FIXED_SIZE)));
+
+  gtk_widget_set_sensitive (gimp_size_entry_get_help_widget (
+                              GIMP_SIZE_ENTRY (private->size_entry), 1),
+                            ! (private->fixed_rule_active &&
+                               (private->fixed_rule ==
+                                GIMP_RECTANGLE_FIXED_HEIGHT ||
+                                private->fixed_rule ==
+                                GIMP_RECTANGLE_FIXED_SIZE)));
+
+  /* Setup current fixed rule entries */
+
+  gtk_widget_hide (private->fixed_width_entry);
+  gtk_widget_hide (private->fixed_height_entry);
+  gtk_widget_hide (private->fixed_aspect_hbox);
+  gtk_widget_hide (private->fixed_size_hbox);
+
+  switch (private->fixed_rule)
+    {
+    case GIMP_RECTANGLE_FIXED_ASPECT:
+      gtk_widget_show (private->fixed_aspect_hbox);
+      break;
+
+    case GIMP_RECTANGLE_FIXED_WIDTH:
+      gtk_widget_show (private->fixed_width_entry);
+      break;
+
+    case GIMP_RECTANGLE_FIXED_HEIGHT:
+      gtk_widget_show (private->fixed_height_entry);
+      break;
+
+    case GIMP_RECTANGLE_FIXED_SIZE:
+      gtk_widget_show (private->fixed_size_hbox);
+      break;
+    }
+}
+
+static void
+gimp_rectangle_options_string_current_updates (GimpNumberPairEntry  *entry,
+                                               GParamSpec           *param,
+                                               GimpRectangleOptions *rectangle_options)
+{
+  GimpRectangleOptionsPrivate *private;
+  gboolean                     user_override;
+
+  private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (rectangle_options);
+
+  user_override = gimp_number_pair_entry_get_user_override (entry);
+
+  gimp_number_pair_entry_set_default_text (entry,
+                                           private->use_string_current ?
+                                           /* Current, as in what is currently in use. */
+                                           _("Current") : NULL);
+
+  gtk_widget_set_sensitive (private->aspect_button_box,
+                            ! private->use_string_current || user_override);
+}
+
+static GtkWidget *
+gimp_rectangle_options_prop_dimension_frame_new (GObject      *config,
+                                                 const gchar  *x_property_name,
+                                                 const gchar  *y_property_name,
+                                                 const gchar  *unit_property_name,
+                                                 const gchar  *table_label,
+                                                 GtkWidget   **entry)
+{
+  GimpUnit       unit_value;
+  GtkWidget     *frame;
+  GtkWidget     *hbox;
+  GtkWidget     *label;
+  GtkWidget     *menu;
+  GtkWidget     *spinbutton;
+  GtkAdjustment *adjustment;
+
+  g_object_get (config,
+                unit_property_name, &unit_value,
+                NULL);
+
+  frame = gimp_frame_new (NULL);
+
+  /*  title  */
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
+  gtk_frame_set_label_widget (GTK_FRAME (frame), hbox);
+  gtk_widget_show (hbox);
+
+  label = gtk_label_new (table_label);
+  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+  gtk_widget_show (label);
+
+  menu = gimp_prop_unit_combo_box_new (config, unit_property_name);
+  gtk_box_pack_end (GTK_BOX (hbox), menu, FALSE, FALSE, 0);
+  gtk_widget_show (menu);
+
+  /*  content  */
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+  gtk_container_add (GTK_CONTAINER (frame), hbox);
+  gtk_widget_show (hbox);
+
+  adjustment = (GtkAdjustment *) gtk_adjustment_new (1, 1, 1, 1, 10, 0);
+  spinbutton = gimp_spin_button_new (adjustment, 1.0, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), SB_WIDTH);
+
+  *entry = gimp_size_entry_new (1, unit_value, "%a", TRUE, TRUE, FALSE,
+                                SB_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE);
+  gtk_table_set_col_spacings (GTK_TABLE (*entry), 0);
+  gimp_size_entry_show_unit_menu (GIMP_SIZE_ENTRY (*entry), FALSE);
+  gtk_box_pack_end (GTK_BOX (hbox), *entry, TRUE, TRUE, 0);
+  gtk_widget_show (*entry);
+
+  gimp_size_entry_add_field (GIMP_SIZE_ENTRY (*entry),
+                             GTK_SPIN_BUTTON (spinbutton), NULL);
+  gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, TRUE, 0);
+  gtk_widget_show (spinbutton);
+
+  gimp_prop_coordinates_connect (config,
+                                 x_property_name, y_property_name,
+                                 unit_property_name,
+                                 *entry, NULL, 300, 300);
+
+  return frame;
+}
+
+GtkWidget *
+gimp_rectangle_options_gui (GimpToolOptions *tool_options)
+{
+  GimpRectangleOptionsPrivate *private;
+  GObject                     *config = G_OBJECT (tool_options);
+  GtkWidget                   *vbox   = gimp_tool_options_gui (tool_options);
+  GtkWidget                   *button;
+  GtkWidget                   *combo;
+  GtkWidget                   *frame;
+
+  private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (tool_options);
+
+  /* Fixed Center */
+  button = gimp_prop_check_button_new (config, "fixed-center", NULL);
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+  gtk_widget_show (button);
+
+  /* Rectangle fixed-rules (e.g. aspect or width). */
+  {
+    GtkWidget    *vbox2;
+    GtkWidget    *hbox;
+    GtkWidget    *entry;
+    GtkSizeGroup *size_group;
+    GList        *children;
+
+    frame = gimp_frame_new (NULL);
+    gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+    gtk_widget_show (frame);
+
+    /* Setup frame title widgets */
+
+    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+    gtk_frame_set_label_widget (GTK_FRAME (frame), hbox);
+    gtk_widget_show (hbox);
+
+    button = gimp_prop_check_button_new (config, "fixed-rule-active", NULL);
+    gtk_widget_destroy (gtk_bin_get_child (GTK_BIN (button)));
+    gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
+    gtk_widget_show (button);
+
+    g_signal_connect (button, "toggled",
+                      G_CALLBACK (gimp_rectangle_options_fixed_rule_changed),
+                      private);
+
+    combo = gimp_prop_enum_combo_box_new (config, "fixed-rule", 0, 0);
+    gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (combo), _("Fixed"));
+    g_object_set (combo, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
+    gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
+    gtk_widget_show (combo);
+
+    g_signal_connect (combo, "changed",
+                      G_CALLBACK (gimp_rectangle_options_fixed_rule_changed),
+                      private);
+
+    /* Setup frame content */
+
+    vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+    gtk_container_add (GTK_CONTAINER (frame), vbox2);
+    gtk_widget_show (vbox2);
+
+    size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+
+    /* Fixed aspect entry/buttons */
+    private->fixed_aspect_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+    gtk_box_pack_start (GTK_BOX (vbox2), private->fixed_aspect_hbox,
+                        FALSE, FALSE, 0);
+    gtk_size_group_add_widget (size_group, private->fixed_aspect_hbox);
+    g_object_unref (size_group);
+    /* don't show */
+
+    g_object_add_weak_pointer (G_OBJECT (private->fixed_aspect_hbox),
+                               (gpointer) &private->fixed_aspect_hbox);
+
+    entry = gimp_prop_number_pair_entry_new (config,
+                                             "aspect-numerator",
+                                             "aspect-denominator",
+                                             "default-aspect-numerator",
+                                             "default-aspect-denominator",
+                                             "overridden-fixed-aspect",
+                                             FALSE, TRUE,
+                                             ":/" "xX*",
+                                             TRUE,
+                                             0.001, GIMP_MAX_IMAGE_SIZE);
+    gtk_box_pack_start (GTK_BOX (private->fixed_aspect_hbox), entry,
+                        TRUE, TRUE, 0);
+    gtk_widget_show (entry);
+
+    g_signal_connect (entry, "notify::user-override",
+                      G_CALLBACK (gimp_rectangle_options_string_current_updates),
+                      config);
+    g_signal_connect_swapped (config, "notify::use-string-current",
+                              G_CALLBACK (gimp_rectangle_options_string_current_updates),
+                              entry);
+
+    gimp_rectangle_options_setup_ratio_completion (GIMP_RECTANGLE_OPTIONS (tool_options),
+                                                   entry,
+                                                   private->aspect_history);
+
+    private->aspect_button_box =
+      gimp_prop_enum_icon_box_new (G_OBJECT (entry),
+                                   "aspect", "gimp", -1, -1);
+    gtk_box_pack_start (GTK_BOX (private->fixed_aspect_hbox),
+                        private->aspect_button_box, FALSE, FALSE, 0);
+    gtk_widget_show (private->aspect_button_box);
+
+    g_object_add_weak_pointer (G_OBJECT (private->aspect_button_box),
+                               (gpointer) &private->aspect_button_box);
+
+    /* hide "square" */
+    children =
+      gtk_container_get_children (GTK_CONTAINER (private->aspect_button_box));
+    gtk_widget_hide (children->data);
+    g_list_free (children);
+
+    /* Fixed width entry */
+    private->fixed_width_entry =
+      gimp_prop_size_entry_new (config,
+                                "desired-fixed-width", TRUE, "fixed-unit", "%a",
+                                GIMP_SIZE_ENTRY_UPDATE_SIZE, 300);
+    gtk_box_pack_start (GTK_BOX (vbox2), private->fixed_width_entry,
+                        FALSE, FALSE, 0);
+    gtk_size_group_add_widget (size_group, private->fixed_width_entry);
+    /* don't show */
+
+    g_object_add_weak_pointer (G_OBJECT (private->fixed_width_entry),
+                               (gpointer) &private->fixed_width_entry);
+
+    /* Fixed height entry */
+    private->fixed_height_entry =
+      gimp_prop_size_entry_new (config,
+                                "desired-fixed-height", TRUE, "fixed-unit", "%a",
+                                GIMP_SIZE_ENTRY_UPDATE_SIZE, 300);
+    gtk_box_pack_start (GTK_BOX (vbox2), private->fixed_height_entry,
+                        FALSE, FALSE, 0);
+    gtk_size_group_add_widget (size_group, private->fixed_height_entry);
+    /* don't show */
+
+    g_object_add_weak_pointer (G_OBJECT (private->fixed_height_entry),
+                               (gpointer) &private->fixed_height_entry);
+
+    /* Fixed size entry */
+    private->fixed_size_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+    gtk_box_pack_start (GTK_BOX (vbox2), private->fixed_size_hbox,
+                        FALSE, FALSE, 0);
+    gtk_size_group_add_widget (size_group, private->fixed_size_hbox);
+    /* don't show */
+
+    g_object_add_weak_pointer (G_OBJECT (private->fixed_size_hbox),
+                               (gpointer) &private->fixed_size_hbox);
+
+    entry = gimp_prop_number_pair_entry_new (config,
+                                             "desired-fixed-size-width",
+                                             "desired-fixed-size-height",
+                                             "default-fixed-size-width",
+                                             "default-fixed-size-height",
+                                             "overridden-fixed-size",
+                                             TRUE, FALSE,
+                                             "xX*" ":/",
+                                             FALSE,
+                                             1, GIMP_MAX_IMAGE_SIZE);
+    gtk_box_pack_start (GTK_BOX (private->fixed_size_hbox), entry,
+                        TRUE, TRUE, 0);
+    gtk_widget_show (entry);
+
+    gimp_rectangle_options_setup_ratio_completion (GIMP_RECTANGLE_OPTIONS (tool_options),
+                                                   entry,
+                                                   private->size_history);
+
+    private->size_button_box =
+      gimp_prop_enum_icon_box_new (G_OBJECT (entry),
+                                   "aspect", "gimp", -1, -1);
+    gtk_box_pack_start (GTK_BOX (private->fixed_size_hbox),
+                        private->size_button_box, FALSE, FALSE, 0);
+    gtk_widget_show (private->size_button_box);
+
+    /* hide "square" */
+    children =
+      gtk_container_get_children (GTK_CONTAINER (private->size_button_box));
+    gtk_widget_hide (children->data);
+    g_list_free (children);
+  }
+
+  /* X, Y */
+  frame = gimp_rectangle_options_prop_dimension_frame_new (config,
+                                                           "x", "y",
+                                                           "position-unit",
+                                                           _("Position:"),
+                                                           &private->position_entry);
+  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  /* Width, Height */
+  frame = gimp_rectangle_options_prop_dimension_frame_new (config,
+                                                           "width", "height",
+                                                           "size-unit",
+                                                           _("Size:"),
+                                                           &private->size_entry);
+  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  /*  the Highlight frame  */
+  {
+    GtkWidget *scale;
+
+    scale = gimp_prop_spin_scale_new (config, "highlight-opacity", NULL,
+                                      0.01, 0.1, 0);
+    gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+
+    frame = gimp_prop_expanding_frame_new (config, "highlight", NULL,
+                                           scale, NULL);
+    gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+    gtk_widget_show (frame);
+  }
+
+  /*  Guide  */
+  combo = gimp_prop_enum_combo_box_new (config, "guide",
+                                        GIMP_GUIDES_NONE,
+                                        GIMP_GUIDES_DIAGONALS);
+  gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
+  gtk_widget_show (combo);
+
+  /*  Auto Shrink  */
+  private->auto_shrink_button = gtk_button_new_with_label (_("Auto Shrink"));
+  gtk_box_pack_start (GTK_BOX (vbox), private->auto_shrink_button,
+                      FALSE, FALSE, 0);
+  gtk_widget_set_sensitive (private->auto_shrink_button, FALSE);
+  gtk_widget_show (private->auto_shrink_button);
+
+  g_object_add_weak_pointer (G_OBJECT (private->auto_shrink_button),
+                             (gpointer) &private->auto_shrink_button);
+
+  button = gimp_prop_check_button_new (config, "shrink-merged", NULL);
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+  gtk_widget_show (button);
+
+  /* Setup initial fixed rule widgets */
+  gimp_rectangle_options_fixed_rule_changed (NULL, private);
+
+  return vbox;
+}
+
+void
+gimp_rectangle_options_connect (GimpRectangleOptions *options,
+                                GimpImage            *image,
+                                GCallback             shrink_callback,
+                                gpointer              shrink_object)
+{
+  GimpRectangleOptionsPrivate *options_private;
+  gdouble                      xres;
+  gdouble                      yres;
+
+  g_return_if_fail (GIMP_IS_RECTANGLE_OPTIONS (options));
+  g_return_if_fail (GIMP_IS_IMAGE (image));
+  g_return_if_fail (shrink_callback != NULL);
+  g_return_if_fail (shrink_object != NULL);
+
+  options_private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (options);
+
+  gimp_image_get_resolution (image, &xres, &yres);
+
+  if (options_private->fixed_width_entry)
+    {
+      GtkWidget *entry = options_private->fixed_width_entry;
+
+      gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, FALSE);
+      gimp_size_entry_set_size (GIMP_SIZE_ENTRY (entry), 0,
+                                0, gimp_image_get_width (image));
+    }
+
+  if (options_private->fixed_height_entry)
+    {
+      GtkWidget *entry = options_private->fixed_height_entry;
+
+      gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, yres, FALSE);
+      gimp_size_entry_set_size (GIMP_SIZE_ENTRY (entry), 0,
+                                0, gimp_image_get_height (image));
+    }
+
+  if (options_private->position_entry)
+    {
+      GtkWidget *entry = options_private->position_entry;
+
+      gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, FALSE);
+      gimp_size_entry_set_size (GIMP_SIZE_ENTRY (entry), 0,
+                                0, gimp_image_get_width (image));
+
+      gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, yres, FALSE);
+      gimp_size_entry_set_size (GIMP_SIZE_ENTRY (entry), 1,
+                                0, gimp_image_get_height (image));
+    }
+
+  if (options_private->size_entry)
+    {
+      GtkWidget *entry = options_private->size_entry;
+
+      gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, FALSE);
+      gimp_size_entry_set_size (GIMP_SIZE_ENTRY (entry), 0,
+                                0, gimp_image_get_width (image));
+
+      gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, yres, FALSE);
+      gimp_size_entry_set_size (GIMP_SIZE_ENTRY (entry), 1,
+                                0, gimp_image_get_height (image));
+    }
+
+  if (options_private->auto_shrink_button)
+    {
+      g_signal_connect_swapped (options_private->auto_shrink_button, "clicked",
+                                shrink_callback,
+                                shrink_object);
+
+      gtk_widget_set_sensitive (options_private->auto_shrink_button, TRUE);
+    }
+}
+
+void
+gimp_rectangle_options_disconnect (GimpRectangleOptions *options,
+                                   GCallback             shrink_callback,
+                                   gpointer              shrink_object)
+{
+  GimpRectangleOptionsPrivate *options_private;
+
+  g_return_if_fail (GIMP_IS_RECTANGLE_OPTIONS (options));
+  g_return_if_fail (shrink_callback != NULL);
+  g_return_if_fail (shrink_object != NULL);
+
+  options_private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (options);
+
+  if (options_private->auto_shrink_button)
+    {
+      gtk_widget_set_sensitive (options_private->auto_shrink_button, FALSE);
+
+      g_signal_handlers_disconnect_by_func (options_private->auto_shrink_button,
+                                            shrink_callback,
+                                            shrink_object);
+    }
+}
+
+/**
+ * gimp_rectangle_options_fixed_rule_active:
+ * @rectangle_options:
+ * @fixed_rule:
+ *
+ * Return value: %TRUE if @fixed_rule is active, %FALSE otherwise.
+ */
+gboolean
+gimp_rectangle_options_fixed_rule_active (GimpRectangleOptions   *rectangle_options,
+                                          GimpRectangleFixedRule  fixed_rule)
+{
+  GimpRectangleOptionsPrivate *private;
+
+  g_return_val_if_fail (GIMP_IS_RECTANGLE_OPTIONS (rectangle_options), FALSE);
+
+  private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (rectangle_options);
+
+  return private->fixed_rule_active &&
+         private->fixed_rule == fixed_rule;
+}
+
+static void
+gimp_rectangle_options_setup_ratio_completion (GimpRectangleOptions *rectangle_options,
+                                               GtkWidget            *entry,
+                                               GtkListStore         *history)
+{
+  GtkEntryCompletion *completion;
+
+  completion = g_object_new (GTK_TYPE_ENTRY_COMPLETION,
+                             "model", history,
+                             "inline-completion", TRUE,
+                             NULL);
+
+  gtk_entry_completion_set_text_column (completion, COLUMN_TEXT);
+  gtk_entry_set_completion (GTK_ENTRY (entry), completion);
+  g_object_unref (completion);
+
+  g_signal_connect (entry, "ratio-changed",
+                    G_CALLBACK (gimp_number_pair_entry_history_add),
+                    history);
+
+  g_signal_connect (completion, "match-selected",
+                    G_CALLBACK (gimp_number_pair_entry_history_select),
+                    entry);
+}
+
+static gboolean
+gimp_number_pair_entry_history_select (GtkEntryCompletion  *completion,
+                                       GtkTreeModel        *model,
+                                       GtkTreeIter         *iter,
+                                       GimpNumberPairEntry *entry)
+{
+  gdouble left_number;
+  gdouble right_number;
+
+  gtk_tree_model_get (model, iter,
+                      COLUMN_LEFT_NUMBER,  &left_number,
+                      COLUMN_RIGHT_NUMBER, &right_number,
+                      -1);
+
+  gimp_number_pair_entry_set_values (entry, left_number, right_number);
+
+  return TRUE;
+}
+
+static void
+gimp_number_pair_entry_history_add (GtkWidget    *entry,
+                                    GtkTreeModel *model)
+{
+  GValue       value = G_VALUE_INIT;
+  GtkTreeIter  iter;
+  gboolean     iter_valid;
+  gdouble      left_number;
+  gdouble      right_number;
+  const gchar *text;
+
+  text = gtk_entry_get_text (GTK_ENTRY (entry));
+  gimp_number_pair_entry_get_values (GIMP_NUMBER_PAIR_ENTRY (entry),
+                                     &left_number,
+                                     &right_number);
+
+  for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
+       iter_valid;
+       iter_valid = gtk_tree_model_iter_next (model, &iter))
+    {
+      gtk_tree_model_get_value (model, &iter, COLUMN_TEXT, &value);
+
+      if (strcmp (text, g_value_get_string (&value)) == 0)
+        {
+          g_value_unset (&value);
+          break;
+        }
+
+      g_value_unset (&value);
+    }
+
+  if (iter_valid)
+    {
+      gtk_list_store_move_after (GTK_LIST_STORE (model), &iter, NULL);
+    }
+  else
+    {
+      gtk_list_store_append (GTK_LIST_STORE (model), &iter);
+
+      gtk_list_store_set (GTK_LIST_STORE (model), &iter,
+                          COLUMN_LEFT_NUMBER,  left_number,
+                          COLUMN_RIGHT_NUMBER, right_number,
+                          COLUMN_TEXT,        text,
+                          -1);
+
+      /* FIXME: limit the size of the history */
+    }
+}