Adding upstream version 2.10.22.upstream/2.10.22upstream

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

1 files changed, 2234 insertions, 0 deletions

diff --git a/app/widgets/gimpgradienteditor.c b/app/widgets/gimpgradienteditor.c
new file mode 100644
index 0000000..a8851c5
--- /dev/null
+++ b/app/widgets/gimpgradienteditor.c
@@ -0,0 +1,2234 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * Gradient editor module copyight (C) 1996-1997 Federico Mena Quintero
+ * federico@nuclecu.unam.mx
+ *
+ * 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 PURIGHTE.  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/>.
+ */
+
+/* Special thanks to:
+ *
+ * Luis Albarran (luis4@mindspring.com) - Nice UI suggestions
+ *
+ * Miguel de Icaza (miguel@nuclecu.unam.mx) - Pop-up menu suggestion
+ *
+ * Marcelo Malheiros (malheiro@dca.fee.unicamp.br) - many, many
+ * suggestions, nice gradient files
+ *
+ * Adam Moss (adam@uunet.pipex.com) - idea for the hint bar
+ *
+ * Everyone on #gimp - many suggestions
+ */
+
+/* TODO:
+ *
+ * - Add all of Marcelo's neat suggestions:
+ *   - Hue rotate, saturation, brightness, contrast.
+ *
+ * - Better handling of bogus gradient files and inconsistent
+ *   segments.  Do not loop indefinitely in seg_get_segment_at() if
+ *   there is a missing segment between two others.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpcolor/gimpcolor.h"
+#include "libgimpmath/gimpmath.h"
+#include "libgimpbase/gimpbase.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "widgets-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontainer.h"
+#include "core/gimpcontext.h"
+#include "core/gimpdatafactory.h"
+#include "core/gimpgradient.h"
+
+#include "gimpcolordialog.h"
+#include "gimpdialogfactory.h"
+#include "gimpdnd.h"
+#include "gimpdocked.h"
+#include "gimpgradienteditor.h"
+#include "gimphelp-ids.h"
+#include "gimpuimanager.h"
+#include "gimpview.h"
+#include "gimpviewrenderergradient.h"
+#include "gimpwidgets-utils.h"
+
+#include "gimp-intl.h"
+
+
+#define EPSILON 1e-10
+
+#define GRAD_SCROLLBAR_STEP_SIZE 0.05
+#define GRAD_SCROLLBAR_PAGE_SIZE 0.75
+
+#define GRAD_VIEW_SIZE            96
+#define GRAD_CONTROL_HEIGHT       14
+#define GRAD_CURRENT_COLOR_WIDTH  16
+
+#define GRAD_MOVE_TIME 150 /* ms between mouse click and detection of movement in gradient control */
+
+
+#define GRAD_VIEW_EVENT_MASK (GDK_EXPOSURE_MASK            | \
+                              GDK_LEAVE_NOTIFY_MASK        | \
+                              GDK_POINTER_MOTION_MASK      | \
+                              GDK_POINTER_MOTION_HINT_MASK | \
+                              GDK_BUTTON_PRESS_MASK        | \
+                              GDK_BUTTON_RELEASE_MASK)
+
+#define GRAD_CONTROL_EVENT_MASK (GDK_EXPOSURE_MASK            | \
+                                 GDK_LEAVE_NOTIFY_MASK        | \
+                                 GDK_POINTER_MOTION_MASK      | \
+                                 GDK_POINTER_MOTION_HINT_MASK | \
+                                 GDK_BUTTON_PRESS_MASK        | \
+                                 GDK_BUTTON_RELEASE_MASK      | \
+                                 GDK_BUTTON1_MOTION_MASK)
+
+
+/*  local function prototypes  */
+
+static void  gimp_gradient_editor_docked_iface_init (GimpDockedInterface *face);
+
+static void   gimp_gradient_editor_constructed      (GObject            *object);
+static void   gimp_gradient_editor_dispose          (GObject            *object);
+
+static void   gimp_gradient_editor_unmap            (GtkWidget          *widget);
+static void   gimp_gradient_editor_set_data         (GimpDataEditor     *editor,
+                                                     GimpData           *data);
+
+static void   gimp_gradient_editor_set_context      (GimpDocked         *docked,
+                                                     GimpContext        *context);
+
+static void   gimp_gradient_editor_update          (GimpGradientEditor  *editor);
+static void   gimp_gradient_editor_gradient_dirty   (GimpGradientEditor *editor,
+                                                     GimpGradient       *gradient);
+static void   gradient_editor_drop_gradient         (GtkWidget          *widget,
+                                                     gint                x,
+                                                     gint                y,
+                                                     GimpViewable       *viewable,
+                                                     gpointer            data);
+static void   gradient_editor_drop_color            (GtkWidget          *widget,
+                                                     gint                x,
+                                                     gint                y,
+                                                     const GimpRGB      *color,
+                                                     gpointer            data);
+static void   gradient_editor_control_drop_color    (GtkWidget          *widget,
+                                                     gint                x,
+                                                     gint                y,
+                                                     const GimpRGB      *color,
+                                                     gpointer            data);
+static void   gradient_editor_scrollbar_update      (GtkAdjustment      *adj,
+                                                     GimpGradientEditor *editor);
+
+static void   gradient_editor_set_hint              (GimpGradientEditor *editor,
+                                                     const gchar        *str1,
+                                                     const gchar        *str2,
+                                                     const gchar        *str3,
+                                                     const gchar        *str4);
+
+static GimpGradientSegment *
+              gradient_editor_save_selection        (GimpGradientEditor *editor);
+static void   gradient_editor_replace_selection     (GimpGradientEditor *editor,
+                                                     GimpGradientSegment *replace_seg);
+
+static void   gradient_editor_left_color_update     (GimpColorDialog    *dialog,
+                                                     const GimpRGB      *color,
+                                                     GimpColorDialogState state,
+                                                     GimpGradientEditor *editor);
+static void   gradient_editor_right_color_update    (GimpColorDialog    *dialog,
+                                                     const GimpRGB      *color,
+                                                     GimpColorDialogState state,
+                                                     GimpGradientEditor *editor);
+
+
+/* Gradient view functions */
+
+static gboolean  view_events                      (GtkWidget          *widget,
+                                                   GdkEvent           *event,
+                                                   GimpGradientEditor *editor);
+static void      view_set_hint                    (GimpGradientEditor *editor,
+                                                   gint                x);
+
+static void      view_pick_color                  (GimpGradientEditor *editor,
+                                                   GimpColorPickTarget pick_target,
+                                                   GimpColorPickState  pick_state,
+                                                   gint                x);
+
+/* Gradient control functions */
+
+static gboolean  control_events                   (GtkWidget          *widget,
+                                                   GdkEvent           *event,
+                                                   GimpGradientEditor *editor);
+static gboolean  control_expose                   (GtkWidget          *widget,
+                                                   GdkEventExpose     *event,
+                                                   GimpGradientEditor *editor);
+static void      control_do_hint                  (GimpGradientEditor *editor,
+                                                   gint                x,
+                                                   gint                y);
+static void      control_button_press             (GimpGradientEditor *editor,
+                                                   gint                x,
+                                                   gint                y,
+                                                   guint               button,
+                                                   guint               state);
+static gboolean  control_point_in_handle          (GimpGradientEditor *editor,
+                                                   GimpGradient       *gradient,
+                                                   gint                x,
+                                                   gint                y,
+                                                   GimpGradientSegment *seg,
+                                                   GradientEditorDragMode handle);
+static void      control_select_single_segment    (GimpGradientEditor  *editor,
+                                                   GimpGradientSegment *seg);
+static void      control_extend_selection         (GimpGradientEditor  *editor,
+                                                   GimpGradientSegment *seg,
+                                                   gdouble              pos);
+static void      control_motion                   (GimpGradientEditor  *editor,
+                                                   GimpGradient        *gradient,
+                                                   gint                 x);
+
+static void      control_compress_left            (GimpGradient        *gradient,
+                                                   GimpGradientSegment *range_l,
+                                                   GimpGradientSegment *range_r,
+                                                   GimpGradientSegment *drag_seg,
+                                                   gdouble              pos);
+
+static double    control_move                     (GimpGradientEditor  *editor,
+                                                   GimpGradientSegment *range_l,
+                                                   GimpGradientSegment *range_r,
+                                                   gdouble              delta);
+
+/* Control update/redraw functions */
+
+static void      control_update                   (GimpGradientEditor *editor,
+                                                   GimpGradient       *gradient,
+                                                   gboolean            recalculate);
+static void      control_draw                     (GimpGradientEditor *editor,
+                                                   GimpGradient       *gradient,
+                                                   cairo_t            *cr,
+                                                   gint                width,
+                                                   gint                height,
+                                                   gdouble             left,
+                                                   gdouble             right);
+static void      control_draw_normal_handle       (GimpGradientEditor *editor,
+                                                   cairo_t            *cr,
+                                                   gdouble             pos,
+                                                   gint                height,
+                                                   gboolean            selected);
+static void      control_draw_middle_handle       (GimpGradientEditor *editor,
+                                                   cairo_t            *cr,
+                                                   gdouble             pos,
+                                                   gint                height,
+                                                   gboolean            selected);
+static void      control_draw_handle              (cairo_t            *cr,
+                                                   GdkColor           *border,
+                                                   GdkColor           *fill,
+                                                   gint                xpos,
+                                                   gint                height);
+
+static gint      control_calc_p_pos               (GimpGradientEditor *editor,
+                                                   gdouble             pos);
+static gdouble   control_calc_g_pos               (GimpGradientEditor *editor,
+                                                   gint                pos);
+
+/* Segment functions */
+
+static void      seg_get_closest_handle           (GimpGradient         *grad,
+                                                   gdouble               pos,
+                                                   GimpGradientSegment **seg,
+                                                   GradientEditorDragMode *handle);
+static gboolean  seg_in_selection                 (GimpGradient         *grad,
+                                                   GimpGradientSegment  *seg,
+                                                   GimpGradientSegment  *left,
+                                                   GimpGradientSegment  *right);
+
+static GtkWidget * gradient_hint_label_add        (GtkBox *box);
+
+
+G_DEFINE_TYPE_WITH_CODE (GimpGradientEditor, gimp_gradient_editor,
+                         GIMP_TYPE_DATA_EDITOR,
+                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED,
+                                                gimp_gradient_editor_docked_iface_init))
+
+#define parent_class gimp_gradient_editor_parent_class
+
+static GimpDockedInterface *parent_docked_iface = NULL;
+
+
+static void
+gimp_gradient_editor_class_init (GimpGradientEditorClass *klass)
+{
+  GObjectClass        *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass      *widget_class = GTK_WIDGET_CLASS (klass);
+  GimpDataEditorClass *editor_class = GIMP_DATA_EDITOR_CLASS (klass);
+
+  object_class->constructed = gimp_gradient_editor_constructed;
+  object_class->dispose     = gimp_gradient_editor_dispose;
+
+  widget_class->unmap       = gimp_gradient_editor_unmap;
+
+  editor_class->set_data    = gimp_gradient_editor_set_data;
+  editor_class->title       = _("Gradient Editor");
+}
+
+static void
+gimp_gradient_editor_docked_iface_init (GimpDockedInterface *iface)
+{
+  parent_docked_iface = g_type_interface_peek_parent (iface);
+
+  if (! parent_docked_iface)
+    parent_docked_iface = g_type_default_interface_peek (GIMP_TYPE_DOCKED);
+
+  iface->set_context = gimp_gradient_editor_set_context;
+}
+
+static void
+gimp_gradient_editor_init (GimpGradientEditor *editor)
+{
+  GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
+  GtkWidget      *frame;
+  GtkWidget      *vbox;
+  GtkWidget      *hbox;
+  GtkWidget      *hint_vbox;
+  GimpRGB         transp;
+
+  gimp_rgba_set (&transp, 0.0, 0.0, 0.0, 0.0);
+
+  /* Frame for gradient view and gradient control */
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+  gtk_box_pack_start (GTK_BOX (editor), frame, TRUE, TRUE, 0);
+  gtk_widget_show (frame);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_container_add (GTK_CONTAINER (frame), vbox);
+  gtk_widget_show (vbox);
+
+  data_editor->view = gimp_view_new_full_by_types (NULL,
+                                                   GIMP_TYPE_VIEW,
+                                                   GIMP_TYPE_GRADIENT,
+                                                   GRAD_VIEW_SIZE,
+                                                   GRAD_VIEW_SIZE, 0,
+                                                   FALSE, FALSE, FALSE);
+  gtk_widget_set_size_request (data_editor->view, -1, GRAD_VIEW_SIZE);
+  gtk_widget_set_events (data_editor->view, GRAD_VIEW_EVENT_MASK);
+  gimp_view_set_expand (GIMP_VIEW (data_editor->view), TRUE);
+  gtk_box_pack_start (GTK_BOX (vbox), data_editor->view, TRUE, TRUE, 0);
+  gtk_widget_show (data_editor->view);
+
+  g_signal_connect (data_editor->view, "event",
+                    G_CALLBACK (view_events),
+                    editor);
+
+  gimp_dnd_viewable_dest_add (GTK_WIDGET (data_editor->view),
+                              GIMP_TYPE_GRADIENT,
+                              gradient_editor_drop_gradient,
+                              editor);
+
+  gimp_dnd_color_dest_add (GTK_WIDGET (data_editor->view),
+                              gradient_editor_drop_color,
+                              editor);
+
+  /* Gradient control */
+  editor->control = gtk_drawing_area_new ();
+  gtk_widget_set_size_request (editor->control, -1, GRAD_CONTROL_HEIGHT);
+  gtk_widget_set_events (editor->control, GRAD_CONTROL_EVENT_MASK);
+  gtk_box_pack_start (GTK_BOX (vbox), editor->control, FALSE, FALSE, 0);
+  gtk_widget_show (editor->control);
+
+  g_signal_connect (editor->control, "event",
+                    G_CALLBACK (control_events),
+                    editor);
+
+  g_signal_connect (editor->control, "expose-event",
+                    G_CALLBACK (control_expose),
+                    editor);
+
+  gimp_dnd_color_dest_add (GTK_WIDGET (editor->control),
+                              gradient_editor_control_drop_color,
+                              editor);
+
+  /*  Scrollbar  */
+  editor->zoom_factor = 1;
+
+  editor->scroll_data = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1.0,
+                                                            GRAD_SCROLLBAR_STEP_SIZE,
+                                                            GRAD_SCROLLBAR_PAGE_SIZE,
+                                                            1.0));
+
+  g_signal_connect (editor->scroll_data, "value-changed",
+                    G_CALLBACK (gradient_editor_scrollbar_update),
+                    editor);
+  g_signal_connect (editor->scroll_data, "changed",
+                    G_CALLBACK (gradient_editor_scrollbar_update),
+                    editor);
+
+  editor->scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL,
+                                         editor->scroll_data);
+  gtk_box_pack_start (GTK_BOX (editor), editor->scrollbar, FALSE, FALSE, 0);
+  gtk_widget_show (editor->scrollbar);
+
+  /* Box for current color and the hint labels */
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+  gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+
+  /* Frame showing current active color */
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  editor->current_color = gimp_color_area_new (&transp,
+                                               GIMP_COLOR_AREA_SMALL_CHECKS,
+                                               GDK_BUTTON1_MASK |
+                                               GDK_BUTTON2_MASK);
+  gtk_container_add (GTK_CONTAINER (frame), editor->current_color);
+  gtk_widget_set_size_request (editor->current_color,
+                               GRAD_CURRENT_COLOR_WIDTH, -1);
+  gtk_widget_show (editor->current_color);
+
+  /* Hint box */
+  hint_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_box_pack_start (GTK_BOX (hbox), hint_vbox, TRUE, TRUE, 0);
+  gtk_widget_show (hint_vbox);
+
+  editor->hint_label1 = gradient_hint_label_add (GTK_BOX (hint_vbox));
+  editor->hint_label2 = gradient_hint_label_add (GTK_BOX (hint_vbox));
+  editor->hint_label3 = gradient_hint_label_add (GTK_BOX (hint_vbox));
+  editor->hint_label4 = gradient_hint_label_add (GTK_BOX (hint_vbox));
+
+  /* Black, 50% Gray, White, Clear */
+  gimp_rgba_set (&editor->saved_colors[0], 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[1], 0.5, 0.5, 0.5, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[2], 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[3], 0.0, 0.0, 0.0, GIMP_OPACITY_TRANSPARENT);
+
+  /* Red, Yellow, Green, Cyan, Blue, Magenta */
+  gimp_rgba_set (&editor->saved_colors[4], 1.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[5], 1.0, 1.0, 0.0, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[6], 0.0, 1.0, 0.0, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[7], 0.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[8], 0.0, 0.0, 1.0, GIMP_OPACITY_OPAQUE);
+  gimp_rgba_set (&editor->saved_colors[9], 1.0, 0.0, 1.0, GIMP_OPACITY_OPAQUE);
+}
+
+static void
+gimp_gradient_editor_constructed (GObject *object)
+{
+  GimpGradientEditor *editor = GIMP_GRADIENT_EDITOR (object);
+
+  G_OBJECT_CLASS (parent_class)->constructed (object);
+
+  gimp_editor_add_action_button (GIMP_EDITOR (editor), "gradient-editor",
+                                 "gradient-editor-zoom-out", NULL);
+
+  gimp_editor_add_action_button (GIMP_EDITOR (editor), "gradient-editor",
+                                 "gradient-editor-zoom-in", NULL);
+
+  gimp_editor_add_action_button (GIMP_EDITOR (editor), "gradient-editor",
+                                 "gradient-editor-zoom-all", NULL);
+}
+
+static void
+gimp_gradient_editor_dispose (GObject *object)
+{
+  GimpGradientEditor *editor = GIMP_GRADIENT_EDITOR (object);
+
+  if (editor->color_dialog)
+    gtk_dialog_response (GTK_DIALOG (editor->color_dialog),
+                         GTK_RESPONSE_CANCEL);
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_gradient_editor_unmap (GtkWidget *widget)
+{
+  GimpGradientEditor *editor = GIMP_GRADIENT_EDITOR (widget);
+
+  if (editor->color_dialog)
+    gtk_dialog_response (GTK_DIALOG (editor->color_dialog),
+                         GTK_RESPONSE_CANCEL);
+
+  GTK_WIDGET_CLASS (parent_class)->unmap (widget);
+}
+
+static void
+gimp_gradient_editor_set_data (GimpDataEditor *editor,
+                               GimpData       *data)
+{
+  GimpGradientEditor *gradient_editor = GIMP_GRADIENT_EDITOR (editor);
+  GimpData           *old_data;
+
+  if (gradient_editor->color_dialog)
+    gtk_dialog_response (GTK_DIALOG (gradient_editor->color_dialog),
+                         GTK_RESPONSE_CANCEL);
+
+  old_data = gimp_data_editor_get_data (editor);
+
+  if (old_data)
+    g_signal_handlers_disconnect_by_func (old_data,
+                                          gimp_gradient_editor_gradient_dirty,
+                                          gradient_editor);
+
+  GIMP_DATA_EDITOR_CLASS (parent_class)->set_data (editor, data);
+
+  if (data)
+    g_signal_connect_swapped (data, "dirty",
+                              G_CALLBACK (gimp_gradient_editor_gradient_dirty),
+                              gradient_editor);
+
+  gimp_view_set_viewable (GIMP_VIEW (editor->view),
+                          GIMP_VIEWABLE (data));
+
+  control_update (gradient_editor, GIMP_GRADIENT (data), TRUE);
+}
+
+static void
+gimp_gradient_editor_set_context (GimpDocked  *docked,
+                                  GimpContext *context)
+{
+  GimpDataEditor *data_editor = GIMP_DATA_EDITOR (docked);
+
+  parent_docked_iface->set_context (docked, context);
+
+  gimp_view_renderer_set_context (GIMP_VIEW (data_editor->view)->renderer,
+                                  context);
+}
+
+
+/*  public functions  */
+
+GtkWidget *
+gimp_gradient_editor_new (GimpContext     *context,
+                          GimpMenuFactory *menu_factory)
+{
+  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
+
+  return g_object_new (GIMP_TYPE_GRADIENT_EDITOR,
+                       "menu-factory",    menu_factory,
+                       "menu-identifier", "<GradientEditor>",
+                       "ui-path",         "/gradient-editor-popup",
+                       "data-factory",    context->gimp->gradient_factory,
+                       "context",         context,
+                       "data",            gimp_context_get_gradient (context),
+                       NULL);
+}
+
+void
+gimp_gradient_editor_get_selection (GimpGradientEditor   *editor,
+                                    GimpGradient        **gradient,
+                                    GimpGradientSegment **left,
+                                    GimpGradientSegment **right)
+{
+  g_return_if_fail (GIMP_IS_GRADIENT_EDITOR (editor));
+
+  if (gradient)
+    *gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  if (left)
+    *left = editor->control_sel_l;
+
+  if (right)
+    *right = editor->control_sel_r;
+}
+
+void
+gimp_gradient_editor_set_selection (GimpGradientEditor  *editor,
+                                    GimpGradientSegment *left,
+                                    GimpGradientSegment *right)
+{
+  g_return_if_fail (GIMP_IS_GRADIENT_EDITOR (editor));
+  g_return_if_fail (left != NULL);
+  g_return_if_fail (right != NULL);
+
+  editor->control_sel_l = left;
+  editor->control_sel_r = right;
+}
+
+void
+gimp_gradient_editor_edit_left_color (GimpGradientEditor *editor)
+{
+  GimpGradient *gradient;
+
+  g_return_if_fail (GIMP_IS_GRADIENT_EDITOR (editor));
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  if (! gradient              ||
+      ! editor->control_sel_l ||
+      editor->control_sel_l->left_color_type != GIMP_GRADIENT_COLOR_FIXED)
+    return;
+
+  editor->saved_dirty    = gimp_data_is_dirty (GIMP_DATA (gradient));
+  editor->saved_segments = gradient_editor_save_selection (editor);
+
+  editor->color_dialog =
+    gimp_color_dialog_new (GIMP_VIEWABLE (gradient),
+                           GIMP_DATA_EDITOR (editor)->context,
+                           _("Left Endpoint Color"),
+                           GIMP_ICON_GRADIENT,
+                           _("Gradient Segment's Left Endpoint Color"),
+                           GTK_WIDGET (editor),
+                           gimp_dialog_factory_get_singleton (),
+                           "gimp-gradient-editor-color-dialog",
+                           &editor->control_sel_l->left_color,
+                           TRUE, TRUE);
+
+  g_signal_connect (editor->color_dialog, "destroy",
+                    G_CALLBACK (gtk_widget_destroyed),
+                    &editor->color_dialog);
+
+  g_signal_connect (editor->color_dialog, "update",
+                    G_CALLBACK (gradient_editor_left_color_update),
+                    editor);
+
+  gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
+  gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
+                          gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
+
+  gtk_window_present (GTK_WINDOW (editor->color_dialog));
+}
+
+void
+gimp_gradient_editor_edit_right_color (GimpGradientEditor *editor)
+{
+  GimpGradient *gradient;
+
+  g_return_if_fail (GIMP_IS_GRADIENT_EDITOR (editor));
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  if (! gradient              ||
+      ! editor->control_sel_r ||
+      editor->control_sel_r->right_color_type != GIMP_GRADIENT_COLOR_FIXED)
+    return;
+
+  editor->saved_dirty    = gimp_data_is_dirty (GIMP_DATA (gradient));
+  editor->saved_segments = gradient_editor_save_selection (editor);
+
+  editor->color_dialog =
+    gimp_color_dialog_new (GIMP_VIEWABLE (gradient),
+                           GIMP_DATA_EDITOR (editor)->context,
+                           _("Right Endpoint Color"),
+                           GIMP_ICON_GRADIENT,
+                           _("Gradient Segment's Right Endpoint Color"),
+                           GTK_WIDGET (editor),
+                           gimp_dialog_factory_get_singleton (),
+                           "gimp-gradient-editor-color-dialog",
+                           &editor->control_sel_l->right_color,
+                           TRUE, TRUE);
+
+  g_signal_connect (editor->color_dialog, "destroy",
+                    G_CALLBACK (gtk_widget_destroyed),
+                    &editor->color_dialog);
+
+  g_signal_connect (editor->color_dialog, "update",
+                    G_CALLBACK (gradient_editor_right_color_update),
+                    editor);
+
+  gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
+  gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
+                          gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
+
+  gtk_window_present (GTK_WINDOW (editor->color_dialog));
+}
+
+void
+gimp_gradient_editor_zoom (GimpGradientEditor *editor,
+                           GimpZoomType        zoom_type)
+{
+  GtkAdjustment *adjustment;
+  gdouble        old_value;
+  gdouble        old_page_size;
+  gdouble        value     = 0.0;
+  gdouble        page_size = 1.0;
+
+  g_return_if_fail (GIMP_IS_GRADIENT_EDITOR (editor));
+
+  adjustment = editor->scroll_data;
+
+  old_value     = gtk_adjustment_get_value (adjustment);
+  old_page_size = gtk_adjustment_get_page_size (adjustment);
+
+  switch (zoom_type)
+    {
+    case GIMP_ZOOM_IN_MAX:
+    case GIMP_ZOOM_IN_MORE:
+    case GIMP_ZOOM_IN:
+      editor->zoom_factor++;
+
+      page_size = 1.0 / editor->zoom_factor;
+      value     = old_value + (old_page_size - page_size) / 2.0;
+      break;
+
+    case GIMP_ZOOM_OUT_MORE:
+    case GIMP_ZOOM_OUT:
+      if (editor->zoom_factor <= 1)
+        return;
+
+      editor->zoom_factor--;
+
+      page_size = 1.0 / editor->zoom_factor;
+      value     = old_value - (page_size - old_page_size) / 2.0;
+
+      if (value < 0.0)
+        value = 0.0;
+      else if ((value + page_size) > 1.0)
+        value = 1.0 - page_size;
+      break;
+
+    case GIMP_ZOOM_OUT_MAX:
+    case GIMP_ZOOM_TO: /* abused as ZOOM_ALL */
+      editor->zoom_factor = 1;
+
+      value     = 0.0;
+      page_size = 1.0;
+      break;
+    }
+
+  gtk_adjustment_configure (adjustment,
+                            value,
+                            gtk_adjustment_get_lower (adjustment),
+                            gtk_adjustment_get_upper (adjustment),
+                            page_size * GRAD_SCROLLBAR_STEP_SIZE,
+                            page_size * GRAD_SCROLLBAR_PAGE_SIZE,
+                            page_size);
+}
+
+
+/*  private functions  */
+
+static void
+gimp_gradient_editor_update (GimpGradientEditor *editor)
+{
+  GimpGradient *gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  control_update (editor, gradient, FALSE);
+}
+
+static void
+gimp_gradient_editor_gradient_dirty (GimpGradientEditor *editor,
+                                     GimpGradient       *gradient)
+{
+  GimpGradientSegment *segment;
+  gboolean             left_seen  = FALSE;
+  gboolean             right_seen = FALSE;
+
+  for (segment = gradient->segments; segment; segment = segment->next)
+    {
+      if (segment == editor->control_sel_l)
+        left_seen = TRUE;
+
+      if (segment == editor->control_sel_r)
+        right_seen = TRUE;
+
+      if (right_seen && ! left_seen)
+        {
+          GimpGradientSegment *tmp;
+
+          tmp = editor->control_sel_l;
+          editor->control_sel_l = editor->control_sel_r;
+          editor->control_sel_r = tmp;
+
+          right_seen = FALSE;
+          left_seen  = TRUE;
+        }
+    }
+
+  control_update (editor, gradient, ! (left_seen && right_seen));
+}
+
+static void
+gradient_editor_drop_gradient (GtkWidget    *widget,
+                               gint          x,
+                               gint          y,
+                               GimpViewable *viewable,
+                               gpointer      data)
+{
+  gimp_data_editor_set_data (GIMP_DATA_EDITOR (data), GIMP_DATA (viewable));
+}
+
+static void
+gradient_editor_drop_color (GtkWidget     *widget,
+                            gint           x,
+                            gint           y,
+                            const GimpRGB *color,
+                            gpointer       data)
+{
+  GimpGradientEditor  *editor = GIMP_GRADIENT_EDITOR (data);
+  GimpGradient        *gradient;
+  gdouble              xpos;
+  GimpGradientSegment *seg, *lseg, *rseg;
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  xpos = control_calc_g_pos (editor, x);
+  seg = gimp_gradient_get_segment_at (gradient, xpos);
+
+  gimp_data_freeze (GIMP_DATA (gradient));
+
+  gimp_gradient_segment_split_midpoint (gradient,
+                                        GIMP_DATA_EDITOR (editor)->context,
+                                        seg,
+                                        editor->blend_color_space,
+                                        &lseg, &rseg);
+
+  if (lseg)
+    {
+      lseg->right = xpos;
+      lseg->middle = (lseg->left + lseg->right) / 2.0;
+      lseg->right_color = *color;
+    }
+
+  if (rseg)
+    {
+      rseg->left = xpos;
+      rseg->middle = (rseg->left + rseg->right) / 2.0;
+      rseg->left_color  = *color;
+    }
+
+  gimp_data_thaw (GIMP_DATA (gradient));
+}
+
+static void
+gradient_editor_control_drop_color (GtkWidget     *widget,
+                                    gint           x,
+                                    gint           y,
+                                    const GimpRGB *color,
+                                    gpointer       data)
+{
+  GimpGradientEditor    *editor = GIMP_GRADIENT_EDITOR (data);
+  GimpGradient          *gradient;
+  gdouble                xpos;
+  GimpGradientSegment   *seg, *lseg, *rseg;
+  GradientEditorDragMode handle;
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  xpos = control_calc_g_pos (editor, x);
+  seg_get_closest_handle (gradient, xpos, &seg, &handle);
+
+  if (seg)
+    {
+      if (handle == GRAD_DRAG_LEFT)
+        {
+          lseg = seg->prev;
+          rseg = seg;
+        }
+      else
+        return;
+    }
+  else
+    {
+      lseg = gimp_gradient_get_segment_at (gradient, xpos);
+      rseg = NULL;
+    }
+
+  gimp_data_freeze (GIMP_DATA (gradient));
+
+  if (lseg)
+    lseg->right_color = *color;
+
+  if (rseg)
+    rseg->left_color  = *color;
+
+  gimp_data_thaw (GIMP_DATA (gradient));
+}
+
+static void
+gradient_editor_scrollbar_update (GtkAdjustment      *adjustment,
+                                  GimpGradientEditor *editor)
+{
+  GimpDataEditor           *data_editor = GIMP_DATA_EDITOR (editor);
+  GimpViewRendererGradient *renderer;
+  gchar                    *str1;
+  gchar                    *str2;
+
+  str1 = g_strdup_printf (_("Zoom factor: %d:1"),
+                          editor->zoom_factor);
+
+  str2 = g_strdup_printf (_("Displaying [%0.4f, %0.4f]"),
+                          gtk_adjustment_get_value (adjustment),
+                          gtk_adjustment_get_value (adjustment) +
+                          gtk_adjustment_get_page_size (adjustment));
+
+  gradient_editor_set_hint (editor, str1, str2, NULL, NULL);
+
+  g_free (str1);
+  g_free (str2);
+
+  renderer = GIMP_VIEW_RENDERER_GRADIENT (GIMP_VIEW (data_editor->view)->renderer);
+
+  gimp_view_renderer_gradient_set_offsets (renderer,
+                                           gtk_adjustment_get_value (adjustment),
+                                           gtk_adjustment_get_value (adjustment) +
+                                           gtk_adjustment_get_page_size (adjustment));
+
+  gimp_view_renderer_update (GIMP_VIEW_RENDERER (renderer));
+  gimp_gradient_editor_update (editor);
+}
+
+static void
+gradient_editor_set_hint (GimpGradientEditor *editor,
+                          const gchar        *str1,
+                          const gchar        *str2,
+                          const gchar        *str3,
+                          const gchar        *str4)
+{
+  gtk_label_set_text (GTK_LABEL (editor->hint_label1), str1);
+  gtk_label_set_text (GTK_LABEL (editor->hint_label2), str2);
+  gtk_label_set_text (GTK_LABEL (editor->hint_label3), str3);
+  gtk_label_set_text (GTK_LABEL (editor->hint_label4), str4);
+}
+
+static GimpGradientSegment *
+gradient_editor_save_selection (GimpGradientEditor *editor)
+{
+  GimpGradientSegment *seg, *prev, *tmp;
+  GimpGradientSegment *oseg, *oaseg;
+
+  prev = NULL;
+  oseg = editor->control_sel_l;
+  tmp  = NULL;
+
+  do
+    {
+      seg = gimp_gradient_segment_new ();
+
+      *seg = *oseg; /* Copy everything */
+
+      if (prev == NULL)
+        tmp = seg; /* Remember first segment */
+      else
+        prev->next = seg;
+
+      seg->prev = prev;
+      seg->next = NULL;
+
+      prev  = seg;
+      oaseg = oseg;
+      oseg  = oseg->next;
+    }
+  while (oaseg != editor->control_sel_r);
+
+  return tmp;
+}
+
+static void
+gradient_editor_replace_selection (GimpGradientEditor  *editor,
+                                   GimpGradientSegment *replace_seg)
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *lseg, *rseg;
+  GimpGradientSegment *replace_last;
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  /* Remember left and right segments */
+
+  lseg = editor->control_sel_l->prev;
+  rseg = editor->control_sel_r->next;
+
+  replace_last = gimp_gradient_segment_get_last (replace_seg);
+
+  /* Free old selection */
+
+  editor->control_sel_r->next = NULL;
+
+  gimp_gradient_segments_free (editor->control_sel_l);
+
+  /* Link in new segments */
+
+  if (lseg)
+    lseg->next = replace_seg;
+  else
+    gradient->segments = replace_seg;
+
+  replace_seg->prev = lseg;
+
+  if (rseg)
+    rseg->prev = replace_last;
+
+  replace_last->next = rseg;
+
+  editor->control_sel_l = replace_seg;
+  editor->control_sel_r = replace_last;
+}
+
+static void
+gradient_editor_left_color_update (GimpColorDialog      *dialog,
+                                   const GimpRGB        *color,
+                                   GimpColorDialogState  state,
+                                   GimpGradientEditor   *editor)
+{
+  GimpGradient *gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  switch (state)
+    {
+    case GIMP_COLOR_DIALOG_UPDATE:
+      gimp_gradient_segment_range_blend (gradient,
+                                         editor->control_sel_l,
+                                         editor->control_sel_r,
+                                         color,
+                                         &editor->control_sel_r->right_color,
+                                         TRUE, TRUE);
+      break;
+
+    case GIMP_COLOR_DIALOG_OK:
+      gimp_gradient_segment_range_blend (gradient,
+                                         editor->control_sel_l,
+                                         editor->control_sel_r,
+                                         color,
+                                         &editor->control_sel_r->right_color,
+                                         TRUE, TRUE);
+      gimp_gradient_segments_free (editor->saved_segments);
+      gtk_widget_destroy (editor->color_dialog);
+      editor->color_dialog = NULL;
+      gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
+      gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
+                              gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
+      break;
+
+    case GIMP_COLOR_DIALOG_CANCEL:
+      gradient_editor_replace_selection (editor, editor->saved_segments);
+      if (! editor->saved_dirty)
+        gimp_data_clean (GIMP_DATA (gradient));
+      gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gradient));
+      gtk_widget_destroy (editor->color_dialog);
+      editor->color_dialog = NULL;
+      gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
+      gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
+                              gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
+      break;
+    }
+}
+
+static void
+gradient_editor_right_color_update (GimpColorDialog      *dialog,
+                                    const GimpRGB        *color,
+                                    GimpColorDialogState  state,
+                                    GimpGradientEditor   *editor)
+{
+  GimpGradient *gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  switch (state)
+    {
+    case GIMP_COLOR_DIALOG_UPDATE:
+      gimp_gradient_segment_range_blend (gradient,
+                                         editor->control_sel_l,
+                                         editor->control_sel_r,
+                                         &editor->control_sel_l->left_color,
+                                         color,
+                                         TRUE, TRUE);
+      break;
+
+    case GIMP_COLOR_DIALOG_OK:
+      gimp_gradient_segment_range_blend (gradient,
+                                         editor->control_sel_l,
+                                         editor->control_sel_r,
+                                         &editor->control_sel_l->left_color,
+                                         color,
+                                         TRUE, TRUE);
+      gimp_gradient_segments_free (editor->saved_segments);
+      gtk_widget_destroy (editor->color_dialog);
+      editor->color_dialog = NULL;
+      gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
+      gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
+                              gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
+      break;
+
+    case GIMP_COLOR_DIALOG_CANCEL:
+      gradient_editor_replace_selection (editor, editor->saved_segments);
+      if (! editor->saved_dirty)
+        gimp_data_clean (GIMP_DATA (gradient));
+      gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gradient));
+      gtk_widget_destroy (editor->color_dialog);
+      editor->color_dialog = NULL;
+      gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
+      gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
+                              gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
+      break;
+    }
+}
+
+
+/***** Gradient view functions *****/
+
+static gboolean
+view_events (GtkWidget          *widget,
+             GdkEvent           *event,
+             GimpGradientEditor *editor)
+{
+  GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
+
+  if (! data_editor->data)
+    return TRUE;
+
+  switch (event->type)
+    {
+    case GDK_LEAVE_NOTIFY:
+      gradient_editor_set_hint (editor, NULL, NULL, NULL, NULL);
+      break;
+
+    case GDK_MOTION_NOTIFY:
+      {
+        GdkEventMotion *mevent = (GdkEventMotion *) event;
+
+        if (mevent->x != editor->view_last_x)
+          {
+            editor->view_last_x = mevent->x;
+
+            if (editor->view_button_down)
+              {
+                view_pick_color (editor,
+                                 (mevent->state & gimp_get_toggle_behavior_mask ()) ?
+                                 GIMP_COLOR_PICK_TARGET_BACKGROUND :
+                                 GIMP_COLOR_PICK_TARGET_FOREGROUND,
+                                 GIMP_COLOR_PICK_STATE_UPDATE,
+                                 mevent->x);
+              }
+            else
+              {
+                view_set_hint (editor, mevent->x);
+              }
+          }
+
+        gdk_event_request_motions (mevent);
+      }
+      break;
+
+    case GDK_BUTTON_PRESS:
+      {
+        GdkEventButton *bevent = (GdkEventButton *) event;
+
+        if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
+          {
+            gimp_editor_popup_menu (GIMP_EDITOR (editor), NULL, NULL);
+          }
+        else if (bevent->button == 1)
+          {
+            editor->view_last_x      = bevent->x;
+            editor->view_button_down = TRUE;
+
+            view_pick_color (editor,
+                             (bevent->state & gimp_get_toggle_behavior_mask ()) ?
+                             GIMP_COLOR_PICK_TARGET_BACKGROUND :
+                             GIMP_COLOR_PICK_TARGET_FOREGROUND,
+                             GIMP_COLOR_PICK_STATE_START,
+                             bevent->x);
+          }
+      }
+      break;
+
+    case GDK_SCROLL:
+      {
+        GdkEventScroll *sevent = (GdkEventScroll *) event;
+
+        if (sevent->state & gimp_get_toggle_behavior_mask ())
+          {
+            switch (sevent->direction)
+              {
+              case GDK_SCROLL_UP:
+                gimp_gradient_editor_zoom (editor, GIMP_ZOOM_IN);
+                break;
+
+              case GDK_SCROLL_DOWN:
+                gimp_gradient_editor_zoom (editor, GIMP_ZOOM_OUT);
+                break;
+
+              default:
+                break;
+              }
+          }
+        else
+          {
+            GtkAdjustment *adj   = editor->scroll_data;
+            gfloat         value = gtk_adjustment_get_value (adj);
+
+            switch (sevent->direction)
+              {
+              case GDK_SCROLL_UP:
+                value -= gtk_adjustment_get_page_increment (adj) / 2;
+                break;
+
+              case GDK_SCROLL_DOWN:
+                value += gtk_adjustment_get_page_increment (adj) / 2;
+                break;
+
+              default:
+                break;
+              }
+
+            value = CLAMP (value,
+                           gtk_adjustment_get_lower (adj),
+                           gtk_adjustment_get_upper (adj) -
+                           gtk_adjustment_get_page_size (adj));
+
+            gtk_adjustment_set_value (adj, value);
+          }
+      }
+      break;
+
+    case GDK_BUTTON_RELEASE:
+      if (editor->view_button_down)
+        {
+          GdkEventButton *bevent = (GdkEventButton *) event;
+
+          editor->view_last_x      = bevent->x;
+          editor->view_button_down = FALSE;
+
+          view_pick_color (editor,
+                           (bevent->state & gimp_get_toggle_behavior_mask ()) ?
+                           GIMP_COLOR_PICK_TARGET_BACKGROUND :
+                           GIMP_COLOR_PICK_TARGET_FOREGROUND,
+                           GIMP_COLOR_PICK_STATE_END,
+                           bevent->x);
+          break;
+        }
+      break;
+
+    default:
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static void
+view_set_hint (GimpGradientEditor *editor,
+               gint                x)
+{
+  GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
+  GimpRGB         rgb;
+  GimpHSV         hsv;
+  gdouble         xpos;
+  gchar          *str1;
+  gchar          *str2;
+  gchar          *str3;
+  gchar          *str4;
+
+  xpos = control_calc_g_pos (editor, x);
+
+  gimp_gradient_get_color_at (GIMP_GRADIENT (data_editor->data),
+                              data_editor->context, NULL,
+                              xpos, FALSE, FALSE, &rgb);
+
+  gimp_color_area_set_color (GIMP_COLOR_AREA (editor->current_color), &rgb);
+
+  gimp_rgb_to_hsv (&rgb, &hsv);
+
+  str1 = g_strdup_printf (_("Position: %0.4f"), xpos);
+  str2 = g_strdup_printf (_("RGB (%0.3f, %0.3f, %0.3f)"),
+                          rgb.r, rgb.g, rgb.b);
+  str3 = g_strdup_printf (_("HSV (%0.1f, %0.1f, %0.1f)"),
+                          hsv.h * 360.0, hsv.s * 100.0, hsv.v * 100.0);
+  str4 = g_strdup_printf (_("Luminance: %0.1f    Opacity: %0.1f"),
+                          GIMP_RGB_LUMINANCE (rgb.r, rgb.g, rgb.b) * 100.0,
+                          rgb.a * 100.0);
+
+  gradient_editor_set_hint (editor, str1, str2, str3, str4);
+
+  g_free (str1);
+  g_free (str2);
+  g_free (str3);
+  g_free (str4);
+}
+
+static void
+view_pick_color (GimpGradientEditor  *editor,
+                 GimpColorPickTarget  pick_target,
+                 GimpColorPickState   pick_state,
+                 gint                 x)
+{
+  GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
+  GimpRGB         color;
+  gdouble         xpos;
+  gchar          *str2;
+  gchar          *str3;
+
+  xpos = control_calc_g_pos (editor, x);
+
+  gimp_gradient_get_color_at (GIMP_GRADIENT (data_editor->data),
+                              data_editor->context, NULL,
+                              xpos, FALSE, FALSE, &color);
+
+  gimp_color_area_set_color (GIMP_COLOR_AREA (editor->current_color), &color);
+
+  str2 = g_strdup_printf (_("RGB (%d, %d, %d)"),
+                          (gint) (color.r * 255.0),
+                          (gint) (color.g * 255.0),
+                          (gint) (color.b * 255.0));
+
+  str3 = g_strdup_printf ("(%0.3f, %0.3f, %0.3f)", color.r, color.g, color.b);
+
+  if (pick_target == GIMP_COLOR_PICK_TARGET_FOREGROUND)
+    {
+      gimp_context_set_foreground (data_editor->context, &color);
+
+      gradient_editor_set_hint (editor, _("Foreground color set to:"),
+                                str2, str3, NULL);
+    }
+  else
+    {
+      gimp_context_set_background (data_editor->context, &color);
+
+      gradient_editor_set_hint (editor, _("Background color set to:"),
+                                str2, str3, NULL);
+    }
+
+  g_free (str2);
+  g_free (str3);
+}
+
+/***** Gradient control functions *****/
+
+static gboolean
+control_events (GtkWidget          *widget,
+                GdkEvent           *event,
+                GimpGradientEditor *editor)
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  if (! GIMP_DATA_EDITOR (editor)->data)
+    return TRUE;
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  switch (event->type)
+    {
+    case GDK_LEAVE_NOTIFY:
+      gradient_editor_set_hint (editor, NULL, NULL, NULL, NULL);
+      break;
+
+    case GDK_BUTTON_PRESS:
+      if (editor->control_drag_mode == GRAD_DRAG_NONE)
+        {
+          GdkEventButton *bevent = (GdkEventButton *) event;
+
+          editor->control_last_x     = bevent->x;
+          editor->control_click_time = bevent->time;
+
+          control_button_press (editor,
+                                bevent->x, bevent->y,
+                                bevent->button, bevent->state);
+
+          if (editor->control_drag_mode != GRAD_DRAG_NONE)
+            {
+              gtk_grab_add (widget);
+
+              if (GIMP_DATA_EDITOR (editor)->data_editable)
+                {
+                  g_signal_handlers_block_by_func (gradient,
+                                                   gimp_gradient_editor_gradient_dirty,
+                                                   editor);
+                }
+            }
+        }
+      break;
+
+    case GDK_SCROLL:
+      {
+        GdkEventScroll *sevent = (GdkEventScroll *) event;
+
+        if (sevent->state & gimp_get_toggle_behavior_mask ())
+          {
+            if (sevent->direction == GDK_SCROLL_UP)
+              gimp_gradient_editor_zoom (editor, GIMP_ZOOM_IN);
+            else
+              gimp_gradient_editor_zoom (editor, GIMP_ZOOM_OUT);
+          }
+        else
+          {
+            GtkAdjustment *adj = editor->scroll_data;
+
+            gfloat new_value;
+
+            new_value = (gtk_adjustment_get_value (adj) +
+                         ((sevent->direction == GDK_SCROLL_UP) ?
+                          - gtk_adjustment_get_page_increment (adj) / 2 :
+                          gtk_adjustment_get_page_increment (adj) / 2));
+
+            new_value = CLAMP (new_value,
+                               gtk_adjustment_get_lower (adj),
+                               gtk_adjustment_get_upper (adj) -
+                               gtk_adjustment_get_page_size (adj));
+
+            gtk_adjustment_set_value (adj, new_value);
+          }
+      }
+      break;
+
+    case GDK_BUTTON_RELEASE:
+      {
+        GdkEventButton *bevent = (GdkEventButton *) event;
+
+        gradient_editor_set_hint (editor, NULL, NULL, NULL, NULL);
+
+        if (editor->control_drag_mode != GRAD_DRAG_NONE)
+          {
+            if (GIMP_DATA_EDITOR (editor)->data_editable)
+              {
+                g_signal_handlers_unblock_by_func (gradient,
+                                                   gimp_gradient_editor_gradient_dirty,
+                                                   editor);
+              }
+
+            gtk_grab_remove (widget);
+
+            if ((bevent->time - editor->control_click_time) >= GRAD_MOVE_TIME)
+              {
+                /* stuff was done in motion */
+              }
+            else if ((editor->control_drag_mode == GRAD_DRAG_MIDDLE) ||
+                     (editor->control_drag_mode == GRAD_DRAG_ALL))
+              {
+                seg = editor->control_drag_segment;
+
+                if ((editor->control_drag_mode == GRAD_DRAG_ALL) &&
+                    editor->control_compress)
+                  {
+                    control_extend_selection (editor, seg,
+                                              control_calc_g_pos (editor,
+                                                                  bevent->x));
+                  }
+                else
+                  {
+                    control_select_single_segment (editor, seg);
+                  }
+
+                gimp_gradient_editor_update (editor);
+              }
+
+            editor->control_drag_mode = GRAD_DRAG_NONE;
+            editor->control_compress  = FALSE;
+
+            control_do_hint (editor, bevent->x, bevent->y);
+          }
+      }
+      break;
+
+    case GDK_MOTION_NOTIFY:
+      {
+        GdkEventMotion *mevent = (GdkEventMotion *) event;
+
+        if (mevent->x != editor->control_last_x)
+          {
+            editor->control_last_x = mevent->x;
+
+            if (GIMP_DATA_EDITOR (editor)->data_editable &&
+                editor->control_drag_mode != GRAD_DRAG_NONE)
+              {
+
+                if ((mevent->time - editor->control_click_time) >= GRAD_MOVE_TIME)
+                  control_motion (editor, gradient, mevent->x);
+              }
+            else
+              {
+                gimp_gradient_editor_update (editor);
+
+                control_do_hint (editor, mevent->x, mevent->y);
+              }
+          }
+
+        gdk_event_request_motions (mevent);
+      }
+      break;
+
+    default:
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+control_expose (GtkWidget          *widget,
+                GdkEventExpose     *event,
+                GimpGradientEditor *editor)
+{
+  GtkAdjustment *adj = editor->scroll_data;
+  cairo_t       *cr  = gdk_cairo_create (gtk_widget_get_window (widget));
+  GtkAllocation  allocation;
+
+  gtk_widget_get_allocation (widget, &allocation);
+
+  control_draw (editor,
+                GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data),
+                cr,
+                allocation.width,
+                allocation.height,
+                gtk_adjustment_get_value (adj),
+                gtk_adjustment_get_value (adj) +
+                gtk_adjustment_get_page_size (adj));
+
+  cairo_destroy (cr);
+
+  return TRUE;
+}
+
+static void
+control_do_hint (GimpGradientEditor *editor,
+                 gint                x,
+                 gint                y)
+{
+  GimpGradient           *gradient;
+  GimpGradientSegment    *seg;
+  GradientEditorDragMode  handle;
+  gboolean                in_handle;
+  gdouble                 pos;
+  gchar                  *str;
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  pos = control_calc_g_pos (editor, x);
+
+  if ((pos < 0.0) || (pos > 1.0))
+    return;
+
+  seg_get_closest_handle (gradient, pos, &seg, &handle);
+
+  in_handle = control_point_in_handle (editor, gradient,
+                                       x, y, seg, handle);
+
+  if (in_handle)
+    {
+      switch (handle)
+        {
+        case GRAD_DRAG_LEFT:
+          if (seg != NULL)
+            {
+              if (seg->prev != NULL)
+                {
+                  str = g_strdup_printf (_("%s-Drag: move & compress"),
+                                         gimp_get_mod_string (GDK_SHIFT_MASK));
+
+                  gradient_editor_set_hint (editor,
+                                            NULL,
+                                            _("Drag: move"),
+                                            str,
+                                            NULL);
+                  g_free (str);
+                }
+              else
+                {
+                  str = g_strdup_printf (_("%s-Click: extend selection"),
+                                         gimp_get_mod_string (GDK_SHIFT_MASK));
+
+                  gradient_editor_set_hint (editor,
+                                            NULL,
+                                            _("Click: select"),
+                                            str,
+                                            NULL);
+                  g_free (str);
+                }
+            }
+          else
+            {
+              str = g_strdup_printf (_("%s-Click: extend selection"),
+                                     gimp_get_mod_string (GDK_SHIFT_MASK));
+
+              gradient_editor_set_hint (editor,
+                                        NULL,
+                                        _("Click: select"),
+                                        str,
+                                        NULL);
+              g_free (str);
+            }
+          break;
+
+        case GRAD_DRAG_MIDDLE:
+          str = g_strdup_printf (_("%s-Click: extend selection"),
+                                 gimp_get_mod_string (GDK_SHIFT_MASK));
+
+          gradient_editor_set_hint (editor,
+                                    NULL,
+                                    _("Click: select    Drag: move"),
+                                    str,
+                                    NULL);
+          g_free (str);
+          break;
+
+        default:
+          g_warning ("%s: in_handle is true, but received handle type %d.",
+                     G_STRFUNC, in_handle);
+          break;
+        }
+    }
+  else
+    {
+      gchar *str2;
+
+      str  = g_strdup_printf (_("%s-Click: extend selection"),
+                              gimp_get_mod_string (GDK_SHIFT_MASK));
+      str2 = g_strdup_printf (_("%s-Drag: move & compress"),
+                              gimp_get_mod_string (GDK_SHIFT_MASK));
+
+      gradient_editor_set_hint (editor,
+                                _("Click: select    Drag: move"),
+                                str,
+                                str2,
+                                NULL);
+      g_free (str);
+      g_free (str2);
+    }
+}
+
+static void
+control_button_press (GimpGradientEditor *editor,
+                      gint                x,
+                      gint                y,
+                      guint               button,
+                      guint               state)
+{
+  GimpGradient           *gradient;
+  GimpGradientSegment    *seg;
+  GradientEditorDragMode  handle;
+  gdouble                 xpos;
+  gboolean                in_handle;
+
+  gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  if (button == 3)
+    {
+      gimp_editor_popup_menu (GIMP_EDITOR (editor), NULL, NULL);
+      return;
+    }
+
+  /* Find the closest handle */
+
+  xpos = control_calc_g_pos (editor, x);
+
+  seg_get_closest_handle (gradient, xpos, &seg, &handle);
+
+  in_handle = control_point_in_handle (editor, gradient, x, y, seg, handle);
+
+  /* Now see what we have */
+
+  if (in_handle)
+    {
+      switch (handle)
+        {
+        case GRAD_DRAG_LEFT:
+          if (seg != NULL)
+            {
+              /* Left handle of some segment */
+              if (state & GDK_SHIFT_MASK)
+                {
+                  if (seg->prev != NULL)
+                    {
+                      editor->control_drag_mode    = GRAD_DRAG_LEFT;
+                      editor->control_drag_segment = seg;
+                      editor->control_compress     = TRUE;
+                    }
+                  else
+                    {
+                      control_extend_selection (editor, seg, xpos);
+                      gimp_gradient_editor_update (editor);
+                    }
+                }
+              else if (seg->prev != NULL)
+                {
+                  editor->control_drag_mode    = GRAD_DRAG_LEFT;
+                  editor->control_drag_segment = seg;
+                }
+              else
+                {
+                  control_select_single_segment (editor, seg);
+                  gimp_gradient_editor_update (editor);
+                }
+            }
+          else  /* seg == NULL */
+            {
+              /* Right handle of last segment */
+              seg = gimp_gradient_segment_get_last (gradient->segments);
+
+              if (state & GDK_SHIFT_MASK)
+                {
+                  control_extend_selection (editor, seg, xpos);
+                  gimp_gradient_editor_update (editor);
+                }
+              else
+                {
+                  control_select_single_segment (editor, seg);
+                  gimp_gradient_editor_update (editor);
+                }
+            }
+
+          break;
+
+        case GRAD_DRAG_MIDDLE:
+          if (state & GDK_SHIFT_MASK)
+            {
+              control_extend_selection (editor, seg, xpos);
+              gimp_gradient_editor_update (editor);
+            }
+          else
+            {
+              editor->control_drag_mode    = GRAD_DRAG_MIDDLE;
+              editor->control_drag_segment = seg;
+            }
+
+          break;
+
+        default:
+          g_warning ("%s: in_handle is true, but received handle type %d.",
+                     G_STRFUNC, in_handle);
+        }
+    }
+  else  /* !in_handle */
+    {
+      seg = gimp_gradient_get_segment_at (gradient, xpos);
+
+      editor->control_drag_mode    = GRAD_DRAG_ALL;
+      editor->control_drag_segment = seg;
+      editor->control_last_gx      = xpos;
+      editor->control_orig_pos     = xpos;
+
+      if (state & GDK_SHIFT_MASK)
+        editor->control_compress = TRUE;
+    }
+}
+
+static gboolean
+control_point_in_handle (GimpGradientEditor     *editor,
+                         GimpGradient           *gradient,
+                         gint                    x,
+                         gint                    y,
+                         GimpGradientSegment    *seg,
+                         GradientEditorDragMode  handle)
+{
+  gint handle_pos;
+
+  switch (handle)
+    {
+    case GRAD_DRAG_LEFT:
+      if (seg)
+        {
+          handle_pos = control_calc_p_pos (editor, seg->left);
+        }
+      else
+        {
+          seg = gimp_gradient_segment_get_last (gradient->segments);
+
+          handle_pos = control_calc_p_pos (editor, seg->right);
+        }
+
+      break;
+
+    case GRAD_DRAG_MIDDLE:
+      handle_pos = control_calc_p_pos (editor, seg->middle);
+      break;
+
+    default:
+      g_warning ("%s: Cannot handle drag mode %d.", G_STRFUNC, handle);
+      return FALSE;
+    }
+
+  y /= 2;
+
+  if ((x >= (handle_pos - y)) && (x <= (handle_pos + y)))
+    return TRUE;
+  else
+    return FALSE;
+}
+
+/*****/
+
+static void
+control_select_single_segment (GimpGradientEditor  *editor,
+                               GimpGradientSegment *seg)
+{
+  editor->control_sel_l = seg;
+  editor->control_sel_r = seg;
+}
+
+static void
+control_extend_selection (GimpGradientEditor  *editor,
+                          GimpGradientSegment *seg,
+                          gdouble              pos)
+{
+  if (fabs (pos - editor->control_sel_l->left) <
+      fabs (pos - editor->control_sel_r->right))
+    editor->control_sel_l = seg;
+  else
+    editor->control_sel_r = seg;
+}
+
+/*****/
+
+static void
+control_motion (GimpGradientEditor *editor,
+                GimpGradient       *gradient,
+                gint                x)
+{
+  GimpGradientSegment *seg = editor->control_drag_segment;
+  gdouble              pos;
+  gdouble              delta;
+  gchar               *str = NULL;
+
+  switch (editor->control_drag_mode)
+    {
+    case GRAD_DRAG_LEFT:
+      pos = control_calc_g_pos (editor, x);
+
+      if (! editor->control_compress)
+        gimp_gradient_segment_set_left_pos (gradient, seg, pos);
+      else
+        control_compress_left (gradient,
+                               editor->control_sel_l,
+                               editor->control_sel_r,
+                               seg, pos);
+
+      str = g_strdup_printf (_("Handle position: %0.4f"), seg->left);
+      break;
+
+    case GRAD_DRAG_MIDDLE:
+      pos = control_calc_g_pos (editor, x);
+
+      gimp_gradient_segment_set_middle_pos (gradient, seg, pos);
+
+      str = g_strdup_printf (_("Handle position: %0.4f"), seg->middle);
+      break;
+
+    case GRAD_DRAG_ALL:
+      pos    = control_calc_g_pos (editor, x);
+      delta  = pos - editor->control_last_gx;
+
+      if ((seg->left >= editor->control_sel_l->left) &&
+          (seg->right <= editor->control_sel_r->right))
+        delta = control_move (editor,
+                              editor->control_sel_l,
+                              editor->control_sel_r, delta);
+      else
+        delta = control_move (editor, seg, seg, delta);
+
+      editor->control_last_gx += delta;
+
+      str = g_strdup_printf (_("Distance: %0.4f"),
+                             editor->control_last_gx -
+                             editor->control_orig_pos);
+      break;
+
+    default:
+      g_warning ("%s: Attempting to move bogus handle %d.",
+                 G_STRFUNC, editor->control_drag_mode);
+      break;
+    }
+
+  gradient_editor_set_hint (editor, str, NULL, NULL, NULL);
+  g_free (str);
+
+  gimp_gradient_editor_update (editor);
+}
+
+static void
+control_compress_left (GimpGradient        *gradient,
+                       GimpGradientSegment *range_l,
+                       GimpGradientSegment *range_r,
+                       GimpGradientSegment *drag_seg,
+                       gdouble              pos)
+{
+  GimpGradientSegment *seg;
+  gdouble              lbound, rbound;
+  gint                 k;
+
+  /* Check what we have to compress */
+
+  if (!((drag_seg->left >= range_l->left) &&
+        ((drag_seg->right <= range_r->right) || (drag_seg == range_r->next))))
+    {
+      /* We are compressing a segment outside the selection */
+
+      range_l = range_r = drag_seg;
+    }
+
+  /* Calculate left bound for dragged hadle */
+
+  if (drag_seg == range_l)
+    lbound = range_l->prev->left + 2.0 * EPSILON;
+  else
+    {
+      /* Count number of segments to the left of the dragged handle */
+
+      seg = drag_seg;
+      k   = 0;
+
+      while (seg != range_l)
+        {
+          k++;
+          seg = seg->prev;
+        }
+
+      /* 2*k handles have to fit */
+
+      lbound = range_l->left + 2.0 * k * EPSILON;
+    }
+
+  /* Calculate right bound for dragged handle */
+
+  if (drag_seg == range_r->next)
+    rbound = range_r->next->right - 2.0 * EPSILON;
+  else
+    {
+      /* Count number of segments to the right of the dragged handle */
+
+      seg = drag_seg;
+      k   = 1;
+
+      while (seg != range_r)
+        {
+          k++;
+          seg = seg->next;
+        }
+
+      /* 2*k handles have to fit */
+
+      rbound = range_r->right - 2.0 * k * EPSILON;
+    }
+
+  /* Calculate position */
+
+  pos = CLAMP (pos, lbound, rbound);
+
+  /* Compress segments to the left of the handle */
+
+  if (drag_seg == range_l)
+    gimp_gradient_segment_range_compress (gradient,
+                                          range_l->prev, range_l->prev,
+                                          range_l->prev->left, pos);
+  else
+    gimp_gradient_segment_range_compress (gradient,
+                                          range_l, drag_seg->prev,
+                                          range_l->left, pos);
+
+  /* Compress segments to the right of the handle */
+
+  if (drag_seg != range_r->next)
+    gimp_gradient_segment_range_compress (gradient,
+                                          drag_seg, range_r,
+                                          pos, range_r->right);
+  else
+    gimp_gradient_segment_range_compress (gradient,
+                                          drag_seg, drag_seg,
+                                          pos, drag_seg->right);
+}
+
+/*****/
+
+static gdouble
+control_move (GimpGradientEditor  *editor,
+              GimpGradientSegment *range_l,
+              GimpGradientSegment *range_r,
+              gdouble              delta)
+{
+  GimpGradient *gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
+
+  return gimp_gradient_segment_range_move (gradient,
+                                           range_l,
+                                           range_r,
+                                           delta,
+                                           editor->control_compress);
+}
+
+/*****/
+
+static void
+control_update (GimpGradientEditor *editor,
+                GimpGradient       *gradient,
+                gboolean            reset_selection)
+{
+  if (! editor->control_sel_l || ! editor->control_sel_r)
+    reset_selection = TRUE;
+
+  if (reset_selection)
+    {
+      if (gradient)
+        control_select_single_segment (editor, gradient->segments);
+      else
+        control_select_single_segment (editor, NULL);
+    }
+
+  gtk_widget_queue_draw (editor->control);
+}
+
+static void
+control_draw (GimpGradientEditor *editor,
+              GimpGradient       *gradient,
+              cairo_t            *cr,
+              gint                width,
+              gint                height,
+              gdouble             left,
+              gdouble             right)
+{
+  GtkStyle               *control_style;
+  GimpGradientSegment    *seg;
+  GradientEditorDragMode  handle;
+  gint                    sel_l;
+  gint                    sel_r;
+  gdouble                 g_pos;
+  gboolean                selected;
+
+  if (! gradient)
+    return;
+
+  /* Draw selection */
+
+  control_style = gtk_widget_get_style (editor->control);
+
+  sel_l = control_calc_p_pos (editor, editor->control_sel_l->left);
+  sel_r = control_calc_p_pos (editor, editor->control_sel_r->right);
+
+  gdk_cairo_set_source_color (cr,
+                              &control_style->base[GTK_STATE_NORMAL]);
+  cairo_rectangle (cr, 0, 0, width, height);
+  cairo_fill (cr);
+
+  gdk_cairo_set_source_color (cr,
+                              &control_style->base[GTK_STATE_SELECTED]);
+  cairo_rectangle (cr, sel_l, 0, sel_r - sel_l + 1, height);
+  cairo_fill (cr);
+
+  /* Draw handles */
+
+  selected = FALSE;
+
+  for (seg = gradient->segments; seg; seg = seg->next)
+    {
+      if (seg == editor->control_sel_l)
+        selected = TRUE;
+
+      control_draw_normal_handle (editor, cr, seg->left,   height, selected);
+      control_draw_middle_handle (editor, cr, seg->middle, height, selected);
+
+      /* Draw right handle only if this is the last segment */
+      if (seg->next == NULL)
+        control_draw_normal_handle (editor, cr, seg->right, height, selected);
+
+      if (seg == editor->control_sel_r)
+        selected = FALSE;
+    }
+
+  /* Draw the handle which is closest to the mouse position */
+
+  g_pos = control_calc_g_pos (editor, editor->control_last_x);
+
+  seg_get_closest_handle (gradient, CLAMP (g_pos, 0.0, 1.0), &seg, &handle);
+
+  selected = (seg &&
+              seg_in_selection (gradient, seg,
+                                editor->control_sel_l, editor->control_sel_r));
+
+  switch (handle)
+    {
+    case GRAD_DRAG_LEFT:
+      if (seg)
+        {
+          control_draw_normal_handle (editor, cr, seg->left, height, selected);
+        }
+      else
+        {
+          seg = gimp_gradient_segment_get_last (gradient->segments);
+
+          selected = (seg == editor->control_sel_r);
+
+          control_draw_normal_handle (editor, cr, seg->right, height, selected);
+        }
+
+      break;
+
+    case GRAD_DRAG_MIDDLE:
+      control_draw_middle_handle (editor, cr, seg->middle, height, selected);
+      break;
+
+    default:
+      break;
+    }
+}
+
+static void
+control_draw_normal_handle (GimpGradientEditor *editor,
+                            cairo_t            *cr,
+                            gdouble             pos,
+                            gint                height,
+                            gboolean            selected)
+{
+  GtkStyle     *style = gtk_widget_get_style (editor->control);
+  GtkStateType  state = selected ? GTK_STATE_SELECTED : GTK_STATE_NORMAL;
+
+  control_draw_handle (cr,
+                       &style->text_aa[state],
+                       &style->black,
+                       control_calc_p_pos (editor, pos), height);
+}
+
+static void
+control_draw_middle_handle (GimpGradientEditor *editor,
+                            cairo_t            *cr,
+                            gdouble             pos,
+                            gint                height,
+                            gboolean            selected)
+{
+  GtkStyle     *style = gtk_widget_get_style (editor->control);
+  GtkStateType  state = selected ? GTK_STATE_SELECTED : GTK_STATE_NORMAL;
+
+  control_draw_handle (cr,
+                       &style->text_aa[state],
+                       &style->white,
+                       control_calc_p_pos (editor, pos), height);
+}
+
+static void
+control_draw_handle (cairo_t  *cr,
+                     GdkColor *border,
+                     GdkColor *fill,
+                     gint      xpos,
+                     gint      height)
+{
+  cairo_move_to (cr, xpos, 0);
+  cairo_line_to (cr, xpos - height / 2.0, height);
+  cairo_line_to (cr, xpos + height / 2.0, height);
+  cairo_line_to (cr, xpos, 0);
+
+  gdk_cairo_set_source_color (cr, fill);
+  cairo_fill_preserve (cr);
+
+  gdk_cairo_set_source_color (cr, border);
+  cairo_set_line_width (cr, 1);
+  cairo_stroke (cr);
+}
+
+/*****/
+
+static gint
+control_calc_p_pos (GimpGradientEditor *editor,
+                    gdouble             pos)
+{
+  GtkAdjustment *adjustment = editor->scroll_data;
+  GtkAllocation  allocation;
+  gint           pwidth;
+
+  gtk_widget_get_allocation (editor->control, &allocation);
+
+  pwidth = allocation.width;
+
+  /* Calculate the position (in widget's coordinates) of the
+   * requested point from the gradient.  Rounding is done to
+   * minimize mismatches between the rendered gradient view
+   * and the gradient control's handles.
+   */
+
+  return RINT ((pwidth - 1) * (pos - gtk_adjustment_get_value (adjustment)) /
+               gtk_adjustment_get_page_size (adjustment));
+}
+
+static gdouble
+control_calc_g_pos (GimpGradientEditor *editor,
+                    gint                pos)
+{
+  GtkAdjustment *adjustment = editor->scroll_data;
+  GtkAllocation  allocation;
+  gint           pwidth;
+
+  gtk_widget_get_allocation (editor->control, &allocation);
+
+  pwidth = allocation.width;
+
+  /* Calculate the gradient position that corresponds to widget's coordinates */
+
+  return (gtk_adjustment_get_page_size (adjustment) * pos / (pwidth - 1) +
+          gtk_adjustment_get_value (adjustment));
+}
+
+/***** Segment functions *****/
+
+static void
+seg_get_closest_handle (GimpGradient            *grad,
+                        gdouble                  pos,
+                        GimpGradientSegment    **seg,
+                        GradientEditorDragMode  *handle)
+{
+  gdouble l_delta, m_delta, r_delta;
+
+  *seg = gimp_gradient_get_segment_at (grad, pos);
+
+  m_delta = fabs (pos - (*seg)->middle);
+
+  if (pos < (*seg)->middle)
+    {
+      l_delta = fabs (pos - (*seg)->left);
+
+      if (l_delta < m_delta)
+        *handle = GRAD_DRAG_LEFT;
+      else
+        *handle = GRAD_DRAG_MIDDLE;
+    }
+  else
+    {
+      r_delta = fabs (pos - (*seg)->right);
+
+      if (m_delta < r_delta)
+        {
+          *handle = GRAD_DRAG_MIDDLE;
+        }
+      else
+        {
+          *seg = (*seg)->next;
+          *handle = GRAD_DRAG_LEFT;
+        }
+    }
+}
+
+static gboolean
+seg_in_selection (GimpGradient         *grad,
+                  GimpGradientSegment  *seg,
+                  GimpGradientSegment  *left,
+                  GimpGradientSegment  *right)
+{
+  GimpGradientSegment *s;
+
+  for (s = left; s; s = s->next)
+    {
+      if (s == seg)
+        return TRUE;
+
+      if (s == right)
+        break;
+    }
+
+  return FALSE;
+}
+
+static GtkWidget *
+gradient_hint_label_add (GtkBox *box)
+{
+  GtkWidget *label = g_object_new (GTK_TYPE_LABEL,
+                                   "xalign",           0.0,
+                                   "yalign",           0.5,
+                                   "single-line-mode", TRUE,
+                                   NULL);
+  gtk_box_pack_start (box, label, FALSE, FALSE, 0);
+  gtk_widget_show (label);
+
+  return label;
+}