summaryrefslogtreecommitdiffstats
path: root/app/widgets/gimpspinscale.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
commit3c57dd931145d43f2b0aef96c4d178135956bf91 (patch)
tree3de698981e9f0cc2c4f9569b19a5f3595e741f6b /app/widgets/gimpspinscale.c
parentInitial commit. (diff)
downloadgimp-3c57dd931145d43f2b0aef96c4d178135956bf91.tar.xz
gimp-3c57dd931145d43f2b0aef96c4d178135956bf91.zip
Adding upstream version 2.10.36.upstream/2.10.36
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--app/widgets/gimpspinscale.c1546
1 files changed, 1546 insertions, 0 deletions
diff --git a/app/widgets/gimpspinscale.c b/app/widgets/gimpspinscale.c
new file mode 100644
index 0000000..343dc88
--- /dev/null
+++ b/app/widgets/gimpspinscale.c
@@ -0,0 +1,1546 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpspinscale.c
+ * Copyright (C) 2010 Michael Natterer <mitch@gimp.org>
+ * 2012 Øyvind Kolås <pippin@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "libgimpwidgets/gimpwidgets.h"
+#include "libgimpmath/gimpmath.h"
+
+#include "widgets-types.h"
+
+#include "gimpspinscale.h"
+
+#include "gimp-intl.h"
+
+
+#define RELATIVE_CHANGE_SPEED 0.1
+
+
+enum
+{
+ PROP_0,
+ PROP_LABEL
+};
+
+typedef enum
+{
+ TARGET_NONE,
+ TARGET_NUMBER,
+ TARGET_UPPER,
+ TARGET_LOWER
+} SpinScaleTarget;
+
+
+typedef struct _GimpSpinScalePrivate GimpSpinScalePrivate;
+
+struct _GimpSpinScalePrivate
+{
+ gboolean compact;
+
+ gchar *label;
+ gchar *label_text;
+ gchar *label_pattern;
+
+ GtkWindow *mnemonic_window;
+ guint mnemonic_keyval;
+ gboolean mnemonics_visible;
+
+ gboolean constrain_drag;
+
+ gboolean scale_limits_set;
+ gdouble scale_lower;
+ gdouble scale_upper;
+ gdouble gamma;
+
+ PangoLayout *layout;
+ gboolean changing_value;
+ gboolean relative_change;
+ gdouble start_x;
+ gdouble start_value;
+ GdkScreen *start_screen;
+ gint start_pointer_x;
+ gint start_pointer_y;
+ SpinScaleTarget target;
+ gboolean hover;
+ gboolean pointer_warp;
+ gint pointer_warp_x;
+ gint pointer_warp_start_x;
+
+ gint change_value_idle_id;
+ gdouble change_value_idle_value;
+};
+
+#define GET_PRIVATE(obj) ((GimpSpinScalePrivate *) gimp_spin_scale_get_instance_private ((GimpSpinScale *) (obj)))
+
+
+static void gimp_spin_scale_dispose (GObject *object);
+static void gimp_spin_scale_finalize (GObject *object);
+static void gimp_spin_scale_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gimp_spin_scale_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+static void gimp_spin_scale_map (GtkWidget *widget);
+static void gimp_spin_scale_size_request (GtkWidget *widget,
+ GtkRequisition *requisition);
+static void gimp_spin_scale_style_set (GtkWidget *widget,
+ GtkStyle *prev_style);
+static gboolean gimp_spin_scale_expose (GtkWidget *widget,
+ GdkEventExpose *event);
+static gboolean gimp_spin_scale_button_press (GtkWidget *widget,
+ GdkEventButton *event);
+static gboolean gimp_spin_scale_button_release (GtkWidget *widget,
+ GdkEventButton *event);
+static gboolean gimp_spin_scale_motion_notify (GtkWidget *widget,
+ GdkEventMotion *event);
+static gboolean gimp_spin_scale_leave_notify (GtkWidget *widget,
+ GdkEventCrossing *event);
+static void gimp_spin_scale_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *old_toplevel);
+static void gimp_spin_scale_screen_changed (GtkWidget *widget,
+ GdkScreen *old_screen);
+
+static void gimp_spin_scale_value_changed (GtkSpinButton *spin_button);
+
+static void gimp_spin_scale_settings_notify (GtkSettings *settings,
+ const GParamSpec *pspec,
+ GimpSpinScale *scale);
+static void gimp_spin_scale_mnemonics_notify (GtkWindow *window,
+ const GParamSpec *pspec,
+ GimpSpinScale *scale);
+static void gimp_spin_scale_setup_mnemonic (GimpSpinScale *scale,
+ guint previous_keyval);
+
+static gdouble odd_pow (gdouble x,
+ gdouble y);
+
+
+G_DEFINE_TYPE_WITH_PRIVATE (GimpSpinScale, gimp_spin_scale,
+ GIMP_TYPE_SPIN_BUTTON)
+
+#define parent_class gimp_spin_scale_parent_class
+
+
+static void
+gimp_spin_scale_class_init (GimpSpinScaleClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+ GtkSpinButtonClass *spin_button_class = GTK_SPIN_BUTTON_CLASS (klass);
+
+ object_class->dispose = gimp_spin_scale_dispose;
+ object_class->finalize = gimp_spin_scale_finalize;
+ object_class->set_property = gimp_spin_scale_set_property;
+ object_class->get_property = gimp_spin_scale_get_property;
+
+ widget_class->map = gimp_spin_scale_map;
+ widget_class->size_request = gimp_spin_scale_size_request;
+ widget_class->style_set = gimp_spin_scale_style_set;
+ widget_class->expose_event = gimp_spin_scale_expose;
+ widget_class->button_press_event = gimp_spin_scale_button_press;
+ widget_class->button_release_event = gimp_spin_scale_button_release;
+ widget_class->motion_notify_event = gimp_spin_scale_motion_notify;
+ widget_class->leave_notify_event = gimp_spin_scale_leave_notify;
+ widget_class->hierarchy_changed = gimp_spin_scale_hierarchy_changed;
+ widget_class->screen_changed = gimp_spin_scale_screen_changed;
+
+ spin_button_class->value_changed = gimp_spin_scale_value_changed;
+
+ g_object_class_install_property (object_class, PROP_LABEL,
+ g_param_spec_string ("label", NULL, NULL,
+ NULL,
+ GIMP_PARAM_READWRITE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boolean ("compact",
+ NULL, NULL,
+ FALSE,
+ GIMP_PARAM_READABLE));
+}
+
+static void
+gimp_spin_scale_init (GimpSpinScale *scale)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (scale);
+
+ gtk_widget_add_events (GTK_WIDGET (scale),
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK |
+ GDK_BUTTON1_MOTION_MASK |
+ GDK_LEAVE_NOTIFY_MASK);
+
+ gtk_entry_set_alignment (GTK_ENTRY (scale), 1.0);
+ gtk_entry_set_has_frame (GTK_ENTRY (scale), FALSE);
+ gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (scale), TRUE);
+
+ private->mnemonic_keyval = GDK_KEY_VoidSymbol;
+ private->gamma = 1.0;
+}
+
+static void
+gimp_spin_scale_dispose (GObject *object)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (object);
+ guint keyval;
+
+ keyval = private->mnemonic_keyval;
+ private->mnemonic_keyval = GDK_KEY_VoidSymbol;
+
+ gimp_spin_scale_setup_mnemonic (GIMP_SPIN_SCALE (object), keyval);
+
+ g_clear_object (&private->layout);
+
+ if (private->change_value_idle_id)
+ {
+ GtkAdjustment *adjustment;
+
+ adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (object));
+
+ g_source_remove (private->change_value_idle_id);
+
+ private->change_value_idle_id = 0;
+
+ gtk_adjustment_set_value (adjustment, private->change_value_idle_value);
+ }
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_spin_scale_finalize (GObject *object)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (object);
+
+ g_clear_pointer (&private->label, g_free);
+ g_clear_pointer (&private->label_text, g_free);
+ g_clear_pointer (&private->label_pattern, g_free);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_spin_scale_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GimpSpinScale *scale = GIMP_SPIN_SCALE (object);
+
+ switch (property_id)
+ {
+ case PROP_LABEL:
+ gimp_spin_scale_set_label (scale, g_value_get_string (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+gimp_spin_scale_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GimpSpinScale *scale = GIMP_SPIN_SCALE (object);
+
+ switch (property_id)
+ {
+ case PROP_LABEL:
+ g_value_set_string (value, gimp_spin_scale_get_label (scale));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+gimp_spin_scale_map (GtkWidget *widget)
+{
+ GdkWindow *window;
+
+ GTK_WIDGET_CLASS (parent_class)->map (widget);
+
+ window = gtk_entry_get_text_window (GTK_ENTRY (widget));
+
+ if (window)
+ {
+ /* as per 2020, motion hints seem to be broken, at least on X: calling
+ * gdk_event_request_motions() doesn't seem to generate further motion
+ * events, causing motion events to be discarded, especially if the spin-
+ * scale is tied to some costly operation, such as projection
+ * invalidation, which blocks the main thread.
+ *
+ * to fix this, we simply avoid motion hints for the widget, and use an
+ * idle for setting the spin-scale value in response to motion events, as
+ * a form of ad-hoc motion compression.
+ *
+ * note that this isn't necessary with gtk3, which does its own motion
+ * compression.
+ */
+ gdk_window_set_events (window,
+ gdk_window_get_events (window) &
+ ~GDK_POINTER_MOTION_HINT_MASK);
+ }
+}
+
+static void
+gimp_spin_scale_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+ GtkStyle *style = gtk_widget_get_style (widget);
+ PangoContext *context = gtk_widget_get_pango_context (widget);
+ PangoFontMetrics *metrics;
+
+ GTK_WIDGET_CLASS (parent_class)->size_request (widget, requisition);
+
+ metrics = pango_context_get_metrics (context, style->font_desc,
+ pango_context_get_language (context));
+
+ if (! private->compact)
+ {
+ gint height;
+
+ height = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
+ pango_font_metrics_get_descent (metrics));
+
+ requisition->height += height;
+ }
+
+ if (private->label)
+ {
+ gint char_width;
+ gint digit_width;
+ gint char_pixels;
+
+ char_width = pango_font_metrics_get_approximate_char_width (metrics);
+ digit_width = pango_font_metrics_get_approximate_digit_width (metrics);
+ char_pixels = PANGO_PIXELS (MAX (char_width, digit_width));
+
+ /* ~3 chars for the ellipses */
+ requisition->width += char_pixels * 3;
+ }
+
+ pango_font_metrics_unref (metrics);
+}
+
+static void
+gimp_spin_scale_style_set (GtkWidget *widget,
+ GtkStyle *prev_style)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+
+ GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
+
+ g_clear_object (&private->layout);
+
+ gtk_widget_style_get (widget,
+ "compact", &private->compact,
+ NULL);
+}
+
+static PangoAttrList *
+pattern_to_attrs (const gchar *text,
+ const gchar *pattern)
+{
+ PangoAttrList *attrs = pango_attr_list_new ();
+ const char *p = text;
+ const char *q = pattern;
+ const char *start;
+
+ while (TRUE)
+ {
+ while (*p && q && *q != '_')
+ {
+ p = g_utf8_next_char (p);
+ q++;
+ }
+ start = p;
+ while (*p && *q && *q == '_')
+ {
+ p = g_utf8_next_char (p);
+ q++;
+ }
+
+ if (p > start)
+ {
+ PangoAttribute *attr = pango_attr_underline_new (PANGO_UNDERLINE_LOW);
+
+ attr->start_index = start - text;
+ attr->end_index = p - text;
+
+ pango_attr_list_insert (attrs, attr);
+ }
+ else
+ break;
+ }
+
+ return attrs;
+}
+
+static gboolean
+gimp_spin_scale_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+ GtkStyle *style = gtk_widget_get_style (widget);
+ cairo_t *cr;
+ gboolean rtl;
+ gint w, h;
+
+ GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+
+ cr = gdk_cairo_create (event->window);
+ gdk_cairo_region (cr, event->region);
+ cairo_clip (cr);
+
+ rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+
+ w = gdk_window_get_width (event->window);
+ h = gdk_window_get_height (event->window);
+
+ /* upper/lower halves highlight */
+ if (! private->compact &&
+ event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)) &&
+ gtk_widget_get_sensitive (widget) &&
+ (private->target == TARGET_UPPER || private->target == TARGET_LOWER))
+ {
+ gint window_width;
+ gint window_height;
+ const GdkColor *color;
+ gdouble r, g, b, a;
+
+ window_width = gdk_window_get_width (event->window);
+ window_height = gdk_window_get_height (event->window);
+
+ color = &style->text[gtk_widget_get_state (widget)];
+
+ switch (private->target)
+ {
+ case TARGET_UPPER:
+ cairo_rectangle (cr, 0, 0, window_width, window_height / 2);
+ break;
+
+ case TARGET_LOWER:
+ cairo_rectangle (cr, 0, window_height / 2, window_width, (window_height + 1) / 2);
+ break;
+
+ default:
+ break;
+ }
+
+ r = (gdouble) color->red / 0xffff;
+ g = (gdouble) color->green / 0xffff;
+ b = (gdouble) color->blue / 0xffff;
+ a = 0.12 + 0.04 * MAX (r, MAX (g, b));
+
+ if (private->changing_value)
+ a *= 1.6;
+
+ cairo_set_source_rgba (cr, r, g, b, a);
+
+ cairo_fill (cr);
+ }
+
+ cairo_set_line_width (cr, 1.0);
+
+ if (event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+ {
+ /* let spinbutton-side line of rectangle disappear */
+ if (rtl)
+ cairo_rectangle (cr, -0.5, 0.5, w, h - 1.0);
+ else
+ cairo_rectangle (cr, 0.5, 0.5, w, h - 1.0);
+
+ gdk_cairo_set_source_color (cr,
+ &style->text_aa[gtk_widget_get_state (widget)]);
+ cairo_stroke (cr);
+ }
+ else
+ {
+ /* let text-box-side line of rectangle disappear */
+ if (rtl)
+ cairo_rectangle (cr, 0.5, 0.5, w, h - 1.0);
+ else
+ cairo_rectangle (cr, -0.5, 0.5, w, h - 1.0);
+
+ gdk_cairo_set_source_color (cr,
+ &style->text_aa[gtk_widget_get_state (widget)]);
+ cairo_stroke (cr);
+
+ if (rtl)
+ cairo_rectangle (cr, 1.5, 1.5, w - 2.0, h - 3.0);
+ else
+ cairo_rectangle (cr, 0.5, 1.5, w - 2.0, h - 3.0);
+
+ gdk_cairo_set_source_color (cr,
+ &style->base[gtk_widget_get_state (widget)]);
+ cairo_stroke (cr);
+ }
+
+ if (private->label &&
+ gtk_widget_is_drawable (widget) &&
+ event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+ {
+ GtkRequisition requisition;
+ GtkAllocation allocation;
+ PangoRectangle logical;
+ gint layout_offset_x;
+ gint layout_offset_y;
+ GtkStateType state;
+ GdkColor text_color;
+ GdkColor bar_text_color;
+ gint window_width;
+ gint window_height;
+ gdouble progress_fraction;
+ gint progress_x;
+ gint progress_y;
+ gint progress_width;
+ gint progress_height;
+
+ GTK_WIDGET_CLASS (parent_class)->size_request (widget, &requisition);
+ gtk_widget_get_allocation (widget, &allocation);
+
+ if (! private->layout)
+ {
+ private->layout = gtk_widget_create_pango_layout (widget,
+ private->label_text);
+ pango_layout_set_ellipsize (private->layout, PANGO_ELLIPSIZE_END);
+
+ if (private->mnemonics_visible)
+ {
+ PangoAttrList *attrs;
+
+ attrs = pattern_to_attrs (private->label_text,
+ private->label_pattern);
+ if (attrs)
+ {
+ pango_layout_set_attributes (private->layout, attrs);
+ pango_attr_list_unref (attrs);
+ }
+ }
+ }
+
+ pango_layout_set_width (private->layout,
+ PANGO_SCALE *
+ (allocation.width - requisition.width));
+ pango_layout_get_pixel_extents (private->layout, NULL, &logical);
+
+ gtk_entry_get_layout_offsets (GTK_ENTRY (widget), NULL, &layout_offset_y);
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ layout_offset_x = w - logical.width - 2;
+ else
+ layout_offset_x = 2;
+
+ layout_offset_x -= logical.x;
+
+ state = GTK_STATE_SELECTED;
+ if (! gtk_widget_get_sensitive (widget))
+ state = GTK_STATE_INSENSITIVE;
+ text_color = style->text[gtk_widget_get_state (widget)];
+ bar_text_color = style->fg[state];
+
+ window_width = gdk_window_get_width (event->window);
+ window_height = gdk_window_get_height (event->window);
+
+ progress_fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (widget));
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ {
+ progress_fraction = 1.0 - progress_fraction;
+
+ progress_x = window_width * progress_fraction;
+ progress_y = 0;
+ progress_width = window_width - progress_x;
+ progress_height = window_height;
+ }
+ else
+ {
+ progress_x = 0;
+ progress_y = 0;
+ progress_width = window_width * progress_fraction;
+ progress_height = window_height;
+ }
+
+ cairo_save (cr);
+
+ cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
+ cairo_rectangle (cr, 0, 0, window_width, window_height);
+ cairo_rectangle (cr, progress_x, progress_y,
+ progress_width, progress_height);
+ cairo_clip (cr);
+ cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING);
+
+ cairo_move_to (cr, layout_offset_x, layout_offset_y);
+ gdk_cairo_set_source_color (cr, &text_color);
+ pango_cairo_show_layout (cr, private->layout);
+
+ cairo_restore (cr);
+
+ cairo_rectangle (cr, progress_x, progress_y,
+ progress_width, progress_height);
+ cairo_clip (cr);
+
+ cairo_move_to (cr, layout_offset_x, layout_offset_y);
+ gdk_cairo_set_source_color (cr, &bar_text_color);
+ pango_cairo_show_layout (cr, private->layout);
+ }
+
+ cairo_destroy (cr);
+
+ return FALSE;
+}
+
+static SpinScaleTarget
+gimp_spin_scale_get_target (GtkWidget *widget,
+ gdouble x,
+ gdouble y,
+ GdkEventButton *event)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+ GtkAllocation allocation;
+ PangoRectangle logical;
+ gint layout_x;
+ gint layout_y;
+
+ if (private->compact && ! event)
+ return TARGET_UPPER;
+
+ gtk_widget_get_allocation (widget, &allocation);
+ gtk_entry_get_layout_offsets (GTK_ENTRY (widget), &layout_x, &layout_y);
+ pango_layout_get_pixel_extents (gtk_entry_get_layout (GTK_ENTRY (widget)),
+ NULL, &logical);
+
+ if (x >= layout_x && x < layout_x + logical.width &&
+ y >= layout_y && y < layout_y + logical.height &&
+ (! private->compact ||
+ (gtk_widget_has_focus (widget) &&
+ gdk_event_triggers_context_menu ((GdkEvent *) event))))
+ {
+ return TARGET_NUMBER;
+ }
+
+ if (private->compact)
+ {
+ switch (event->button)
+ {
+ case 1:
+ if (event->state & GDK_SHIFT_MASK)
+ return TARGET_LOWER;
+ else
+ return TARGET_UPPER;
+
+ case 3:
+ return TARGET_LOWER;
+
+ default:
+ return TARGET_NUMBER;
+ }
+ }
+ else
+ {
+ if (y >= allocation.height / 2)
+ return TARGET_LOWER;
+ else
+ return TARGET_UPPER;
+ }
+}
+
+static void
+gimp_spin_scale_update_target (GtkWidget *widget,
+ GdkWindow *window,
+ gdouble x,
+ gdouble y,
+ GdkEventButton *event)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+ SpinScaleTarget target;
+
+ target = gimp_spin_scale_get_target (widget, x, y, event);
+
+ if (target != private->target)
+ {
+ GdkDisplay *display = gtk_widget_get_display (widget);
+ GdkCursor *cursor = NULL;
+
+ private->target = target;
+
+ switch (target)
+ {
+ case TARGET_NUMBER:
+ cursor = gdk_cursor_new_for_display (display, GDK_XTERM);
+ break;
+
+ case TARGET_UPPER:
+ cursor = gdk_cursor_new_for_display (display, GDK_SB_UP_ARROW);
+ break;
+
+ case TARGET_LOWER:
+ cursor = gdk_cursor_new_for_display (display, GDK_SB_H_DOUBLE_ARROW);
+ break;
+
+ default:
+ break;
+ }
+
+ gdk_window_set_cursor (window, cursor);
+
+ gtk_widget_queue_draw (widget);
+
+ if (cursor)
+ gdk_cursor_unref (cursor);
+ }
+}
+
+static void
+gimp_spin_scale_clear_target (GtkWidget *widget,
+ GdkWindow *window)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+
+ if (private->target != TARGET_NONE)
+ {
+ private->target = TARGET_NONE;
+
+ gdk_window_set_cursor (window, NULL);
+
+ gtk_widget_queue_draw (widget);
+ }
+}
+
+static void
+gimp_spin_scale_get_limits (GimpSpinScale *scale,
+ gdouble *lower,
+ gdouble *upper)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (scale);
+
+ if (private->scale_limits_set)
+ {
+ *lower = private->scale_lower;
+ *upper = private->scale_upper;
+ }
+ else
+ {
+ GtkSpinButton *spin_button = GTK_SPIN_BUTTON (scale);
+ GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button);
+
+ *lower = gtk_adjustment_get_lower (adjustment);
+ *upper = gtk_adjustment_get_upper (adjustment);
+ }
+}
+
+static gboolean
+gimp_spin_scale_change_value_idle (GimpSpinScale *scale)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (scale);
+ GtkAdjustment *adjustment;
+
+ private->change_value_idle_id = 0;
+
+ adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (scale));
+
+ gtk_adjustment_set_value (adjustment, private->change_value_idle_value);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+gimp_spin_scale_change_value (GtkWidget *widget,
+ gdouble x,
+ guint state,
+ gboolean now)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+ GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
+ GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button);
+ GdkWindow *text_window = gtk_entry_get_text_window (GTK_ENTRY (widget));
+ gdouble lower;
+ gdouble upper;
+ gint width;
+ gdouble value;
+ gint digits;
+ gint power = 1;
+
+ gimp_spin_scale_get_limits (GIMP_SPIN_SCALE (widget), &lower, &upper);
+
+ width = gdk_window_get_width (text_window);
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ x = width - x;
+
+ if (private->relative_change)
+ {
+ gdouble step;
+
+ step = (upper - lower) / width * RELATIVE_CHANGE_SPEED;
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ step *= x - (width - private->start_x);
+ else
+ step *= x - private->start_x;
+
+ if (state & GDK_CONTROL_MASK)
+ {
+ gdouble page_inc = gtk_adjustment_get_page_increment (adjustment);
+
+ step = RINT (step / page_inc) * page_inc;
+ }
+
+ value = private->start_value + step;
+ }
+ else
+ {
+ gdouble x0, x1;
+ gdouble fraction;
+
+ x0 = odd_pow (lower, 1.0 / private->gamma);
+ x1 = odd_pow (upper, 1.0 / private->gamma);
+
+ fraction = x / (gdouble) width;
+
+ value = fraction * (x1 - x0) + x0;
+ value = odd_pow (value, private->gamma);
+
+ if (state & GDK_CONTROL_MASK)
+ {
+ gdouble page_inc = gtk_adjustment_get_page_increment (adjustment);
+
+ value = RINT (value / page_inc) * page_inc;
+ }
+ }
+
+ digits = gtk_spin_button_get_digits (spin_button);
+ while (digits--)
+ power *= 10;
+
+ /* round the value to the possible precision of the spinbutton, so
+ * a focus-out will not change the value again, causing inadvertend
+ * adjustment signals.
+ */
+ value *= power;
+ value = RINT (value);
+ value /= power;
+
+ if (private->constrain_drag)
+ value = rint (value);
+
+ if (now)
+ {
+ if (private->change_value_idle_id)
+ {
+ g_source_remove (private->change_value_idle_id);
+
+ private->change_value_idle_id = 0;
+ }
+
+ gtk_adjustment_set_value (adjustment, value);
+ }
+ else if (! private->change_value_idle_id)
+ {
+ private->change_value_idle_value = value;
+
+ private->change_value_idle_id = g_idle_add_full (
+ G_PRIORITY_DEFAULT + 1,
+ (GSourceFunc) gimp_spin_scale_change_value_idle,
+ widget, NULL);
+ }
+}
+
+static gboolean
+gimp_spin_scale_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+
+ private->changing_value = FALSE;
+ private->relative_change = FALSE;
+ private->pointer_warp = FALSE;
+
+ if (event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+ {
+ gimp_spin_scale_update_target (widget, event->window,
+ event->x, event->y, event);
+
+ gtk_widget_queue_draw (widget);
+
+ switch (private->target)
+ {
+ case TARGET_UPPER:
+ private->changing_value = TRUE;
+
+ gtk_widget_grab_focus (widget);
+
+ gimp_spin_scale_change_value (widget, event->x, event->state, TRUE);
+
+ return TRUE;
+
+ case TARGET_LOWER:
+ private->changing_value = TRUE;
+
+ gtk_widget_grab_focus (widget);
+
+ private->relative_change = TRUE;
+ private->start_x = event->x;
+ private->start_value = gtk_adjustment_get_value (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)));
+
+ private->start_screen = gdk_event_get_screen ((GdkEvent *) event);
+ private->start_pointer_x = floor (event->x_root);
+ private->start_pointer_y = floor (event->y_root);
+
+ return TRUE;
+
+ default:
+ break;
+ }
+ }
+
+ return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event);
+}
+
+static gboolean
+gimp_spin_scale_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+
+ if (private->changing_value)
+ {
+ private->changing_value = FALSE;
+
+ /* don't change the value if we're in the middle of a pointer warp, since
+ * we didn't adjust start_x yet. see the comment in
+ * gimp_spin_scale_motion_notify().
+ */
+ if (! private->pointer_warp)
+ gimp_spin_scale_change_value (widget, event->x, event->state, TRUE);
+
+ if (private->relative_change)
+ {
+ gdk_display_warp_pointer (gdk_screen_get_display (private->start_screen),
+ private->start_screen,
+ private->start_pointer_x,
+ private->start_pointer_y);
+ }
+
+ if (private->hover)
+ gimp_spin_scale_update_target (widget, event->window,
+ event->x, event->y, NULL);
+ else
+ gimp_spin_scale_clear_target (widget, event->window);
+
+ gtk_widget_queue_draw (widget);
+
+ return TRUE;
+ }
+
+ return GTK_WIDGET_CLASS (parent_class)->button_release_event (widget, event);
+}
+
+static gboolean
+gimp_spin_scale_motion_notify (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+
+ gdk_event_request_motions (event);
+
+ if (event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+ private->hover = TRUE;
+
+ if (private->changing_value)
+ {
+ GdkScreen *screen;
+ GdkDisplay *display;
+ gint pointer_x;
+ gint pointer_y;
+ gint monitor;
+ GdkRectangle monitor_geometry;
+
+ screen = gdk_event_get_screen ((GdkEvent *) event);
+ display = gdk_screen_get_display (screen);
+
+ pointer_x = floor (event->x_root);
+ pointer_y = floor (event->y_root);
+
+ monitor = gdk_screen_get_monitor_at_point (screen, pointer_x, pointer_y);
+ gdk_screen_get_monitor_geometry (screen, monitor, &monitor_geometry);
+
+ /* when applying a relative change, we wrap the pointer around the left
+ * and right edges of the current monitor, so that the adjustment is not
+ * limited by the monitor geometry. when the pointer reaches one of the
+ * monitor edges, we move it one pixel away from the opposite edge, so
+ * that it can be subsequently moved in the other direction, and adjust
+ * start_x accordingly.
+ *
+ * unfortunately, we can't rely on gdk_display_warp_pointer() to actually
+ * move the pointer (for example, it doesn't work on wayland), and
+ * there's no easy way to tell whether the pointer moved or not. in
+ * particular, even when the pointer doesn't move, gdk still simulates a
+ * motion event, and reports the "new" pointer position until a real
+ * motion event occurs.
+ *
+ * in order not to erroneously adjust start_x when
+ * gdk_display_warp_pointer() fails, we remember that we *tried* to warp
+ * the pointer, and defer the actual adjustment of start_x until a future
+ * motion event, where the pointer's x coordinate is different from the
+ * one passed to gdk_display_warp_pointer(). when that happens, we
+ * "guess" whether the pointer got warped or not by comparing its x
+ * coordinate to the one passed to gdk_display_warp_pointer(): if their
+ * difference is less than half the monitor width, then we assume the
+ * pointer got warped (otherwise, the user must have very quickly moved
+ * the mouse across half the screen.) yes, this is an ugly ugly hack :)
+ */
+
+ if (private->pointer_warp)
+ {
+ if (pointer_x == private->pointer_warp_x)
+ return TRUE;
+
+ private->pointer_warp = FALSE;
+
+ if (ABS (pointer_x - private->pointer_warp_x) < monitor_geometry.width / 2)
+ private->start_x = private->pointer_warp_start_x;
+ }
+
+ /* change the value in an idle, as a form of motion compression, since we
+ * don't use motion hints. see the comment in gimp_spin_scale_map().
+ */
+ gimp_spin_scale_change_value (widget, event->x, event->state, FALSE);
+
+ if (private->relative_change)
+ {
+ GtkAdjustment *adjustment;
+ gdouble value;
+ gdouble lower;
+ gdouble upper;
+
+ adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
+
+ value = gtk_adjustment_get_value (adjustment);
+ lower = gtk_adjustment_get_lower (adjustment);
+ upper = gtk_adjustment_get_upper (adjustment);
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ {
+ gdouble temp;
+
+ value = -value;
+
+ temp = lower;
+ lower = -upper;
+ upper = -temp;
+ }
+
+ if (pointer_x <= monitor_geometry.x &&
+ value > lower)
+ {
+ private->pointer_warp = TRUE;
+ private->pointer_warp_x = (monitor_geometry.width - 1) + pointer_x - 1;
+ private->pointer_warp_start_x = private->start_x + (monitor_geometry.width - 2);
+ }
+ else if (pointer_x >= monitor_geometry.x + (monitor_geometry.width - 1) &&
+ value < upper)
+ {
+ private->pointer_warp = TRUE;
+ private->pointer_warp_x = pointer_x - (monitor_geometry.width - 1) + 1;
+ private->pointer_warp_start_x = private->start_x - (monitor_geometry.width - 2);
+ }
+
+ if (private->pointer_warp)
+ {
+ gdk_display_warp_pointer (display,
+ screen,
+ private->pointer_warp_x,
+ pointer_y);
+ }
+ }
+
+ return TRUE;
+ }
+
+ GTK_WIDGET_CLASS (parent_class)->motion_notify_event (widget, event);
+
+ if (! (event->state &
+ (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) &&
+ private->hover)
+ {
+ gimp_spin_scale_update_target (widget, event->window,
+ event->x, event->y, NULL);
+ }
+
+ return FALSE;
+}
+
+static gboolean
+gimp_spin_scale_leave_notify (GtkWidget *widget,
+ GdkEventCrossing *event)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+
+ if (event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+ {
+ private->hover = FALSE;
+
+ if (! (event->state &
+ (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)))
+ {
+ gimp_spin_scale_clear_target (widget, event->window);
+ }
+ }
+
+ return GTK_WIDGET_CLASS (parent_class)->leave_notify_event (widget, event);
+}
+
+static void
+gimp_spin_scale_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *old_toplevel)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+
+ gimp_spin_scale_setup_mnemonic (GIMP_SPIN_SCALE (widget),
+ private->mnemonic_keyval);
+}
+
+static void
+gimp_spin_scale_screen_changed (GtkWidget *widget,
+ GdkScreen *old_screen)
+{
+ GimpSpinScale *scale = GIMP_SPIN_SCALE (widget);
+ GimpSpinScalePrivate *private = GET_PRIVATE (scale);
+ GtkSettings *settings;
+
+ g_clear_object (&private->layout);
+
+ if (old_screen)
+ {
+ settings = gtk_settings_get_for_screen (old_screen);
+
+ g_signal_handlers_disconnect_by_func (settings,
+ gimp_spin_scale_settings_notify,
+ scale);
+ }
+
+ if (! gtk_widget_has_screen (widget))
+ return;
+
+ settings = gtk_widget_get_settings (widget);
+
+ g_signal_connect (settings, "notify::gtk-enable-mnemonics",
+ G_CALLBACK (gimp_spin_scale_settings_notify),
+ scale);
+ g_signal_connect (settings, "notify::gtk-enable-accels",
+ G_CALLBACK (gimp_spin_scale_settings_notify),
+ scale);
+
+ gimp_spin_scale_settings_notify (settings, NULL, scale);
+}
+
+static void
+gimp_spin_scale_value_changed (GtkSpinButton *spin_button)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (spin_button);
+ GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button);
+ gdouble lower;
+ gdouble upper;
+ gdouble value;
+ gdouble x0, x1;
+ gdouble x;
+
+ gimp_spin_scale_get_limits (GIMP_SPIN_SCALE (spin_button), &lower, &upper);
+
+ value = CLAMP (gtk_adjustment_get_value (adjustment), lower, upper);
+
+ x0 = odd_pow (lower, 1.0 / private->gamma);
+ x1 = odd_pow (upper, 1.0 / private->gamma);
+ x = odd_pow (value, 1.0 / private->gamma);
+
+ gtk_entry_set_progress_fraction (GTK_ENTRY (spin_button),
+ (x - x0) / (x1 - x0));
+}
+
+static void
+gimp_spin_scale_settings_notify (GtkSettings *settings,
+ const GParamSpec *pspec,
+ GimpSpinScale *scale)
+{
+ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (scale));
+
+ if (GTK_IS_WINDOW (toplevel))
+ gimp_spin_scale_mnemonics_notify (GTK_WINDOW (toplevel), NULL, scale);
+}
+
+static void
+gimp_spin_scale_mnemonics_notify (GtkWindow *window,
+ const GParamSpec *pspec,
+ GimpSpinScale *scale)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (scale);
+ gboolean mnemonics_visible = FALSE;
+ gboolean enable_mnemonics;
+ gboolean auto_mnemonics;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (scale)),
+ "gtk-enable-mnemonics", &enable_mnemonics,
+ "gtk-auto-mnemonics", &auto_mnemonics,
+ NULL);
+
+ if (enable_mnemonics &&
+ (! auto_mnemonics ||
+ gtk_widget_is_sensitive (GTK_WIDGET (scale))))
+ {
+ g_object_get (window,
+ "mnemonics-visible", &mnemonics_visible,
+ NULL);
+ }
+
+ if (private->mnemonics_visible != mnemonics_visible)
+ {
+ private->mnemonics_visible = mnemonics_visible;
+
+ g_clear_object (&private->layout);
+
+ gtk_widget_queue_draw (GTK_WIDGET (scale));
+ }
+}
+
+static void
+gimp_spin_scale_setup_mnemonic (GimpSpinScale *scale,
+ guint previous_keyval)
+{
+ GimpSpinScalePrivate *private = GET_PRIVATE (scale);
+ GtkWidget *widget = GTK_WIDGET (scale);
+ GtkWidget *toplevel;
+
+ if (private->mnemonic_window)
+ {
+ g_signal_handlers_disconnect_by_func (private->mnemonic_window,
+ gimp_spin_scale_mnemonics_notify,
+ scale);
+
+ gtk_window_remove_mnemonic (private->mnemonic_window,
+ previous_keyval,
+ widget);
+ private->mnemonic_window = NULL;
+ }
+
+ toplevel = gtk_widget_get_toplevel (widget);
+
+ if (gtk_widget_is_toplevel (toplevel) &&
+ private->mnemonic_keyval != GDK_KEY_VoidSymbol)
+ {
+ gtk_window_add_mnemonic (GTK_WINDOW (toplevel),
+ private->mnemonic_keyval,
+ widget);
+ private->mnemonic_window = GTK_WINDOW (toplevel);
+
+ g_signal_connect (toplevel, "notify::mnemonics-visible",
+ G_CALLBACK (gimp_spin_scale_mnemonics_notify),
+ scale);
+ }
+}
+
+static gdouble
+odd_pow (gdouble x,
+ gdouble y)
+{
+ if (x >= 0.0)
+ return pow (x, y);
+ else
+ return -pow (-x, y);
+}
+
+
+/* public functions */
+
+GtkWidget *
+gimp_spin_scale_new (GtkAdjustment *adjustment,
+ const gchar *label,
+ gint digits)
+{
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), NULL);
+
+ return g_object_new (GIMP_TYPE_SPIN_SCALE,
+ "adjustment", adjustment,
+ "label", label,
+ "digits", digits,
+ NULL);
+}
+
+static gboolean
+separate_uline_pattern (const gchar *str,
+ guint *accel_key,
+ gchar **new_str,
+ gchar **pattern)
+{
+ gboolean underscore;
+ const gchar *src;
+ gchar *dest;
+ gchar *pattern_dest;
+
+ *accel_key = GDK_KEY_VoidSymbol;
+ *new_str = g_new (gchar, strlen (str) + 1);
+ *pattern = g_new (gchar, g_utf8_strlen (str, -1) + 1);
+
+ underscore = FALSE;
+
+ src = str;
+ dest = *new_str;
+ pattern_dest = *pattern;
+
+ while (*src)
+ {
+ gunichar c;
+ const gchar *next_src;
+
+ c = g_utf8_get_char (src);
+ if (c == (gunichar)-1)
+ {
+ g_warning ("Invalid input string");
+ g_free (*new_str);
+ g_free (*pattern);
+
+ return FALSE;
+ }
+ next_src = g_utf8_next_char (src);
+
+ if (underscore)
+ {
+ if (c == '_')
+ *pattern_dest++ = ' ';
+ else
+ {
+ *pattern_dest++ = '_';
+ if (*accel_key == GDK_KEY_VoidSymbol)
+ *accel_key = gdk_keyval_to_lower (gdk_unicode_to_keyval (c));
+ }
+
+ while (src < next_src)
+ *dest++ = *src++;
+
+ underscore = FALSE;
+ }
+ else
+ {
+ if (c == '_')
+ {
+ underscore = TRUE;
+ src = next_src;
+ }
+ else
+ {
+ while (src < next_src)
+ *dest++ = *src++;
+
+ *pattern_dest++ = ' ';
+ }
+ }
+ }
+
+ *dest = 0;
+ *pattern_dest = 0;
+
+ return TRUE;
+}
+
+void
+gimp_spin_scale_set_label (GimpSpinScale *scale,
+ const gchar *label)
+{
+ GimpSpinScalePrivate *private;
+ guint accel_key = GDK_KEY_VoidSymbol;
+ gchar *text = NULL;
+ gchar *pattern = NULL;
+
+ g_return_if_fail (GIMP_IS_SPIN_SCALE (scale));
+
+ private = GET_PRIVATE (scale);
+
+ if (label == private->label)
+ return;
+
+ if (label && ! separate_uline_pattern (label, &accel_key, &text, &pattern))
+ return;
+
+ g_free (private->label);
+ private->label = g_strdup (label);
+
+ g_free (private->label_text);
+ private->label_text = text; /* don't dup */
+
+ g_free (private->label_pattern);
+ private->label_pattern = pattern; /* don't dup */
+
+ if (private->mnemonic_keyval != accel_key)
+ {
+ guint previous = private->mnemonic_keyval;
+
+ private->mnemonic_keyval = accel_key;
+
+ gimp_spin_scale_setup_mnemonic (scale, previous);
+ }
+
+ g_clear_object (&private->layout);
+
+ gtk_widget_queue_resize (GTK_WIDGET (scale));
+
+ g_object_notify (G_OBJECT (scale), "label");
+}
+
+const gchar *
+gimp_spin_scale_get_label (GimpSpinScale *scale)
+{
+ g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), NULL);
+
+ return GET_PRIVATE (scale)->label;
+}
+
+void
+gimp_spin_scale_set_scale_limits (GimpSpinScale *scale,
+ gdouble lower,
+ gdouble upper)
+{
+ GimpSpinScalePrivate *private;
+ GtkSpinButton *spin_button;
+ GtkAdjustment *adjustment;
+
+ g_return_if_fail (GIMP_IS_SPIN_SCALE (scale));
+
+ private = GET_PRIVATE (scale);
+ spin_button = GTK_SPIN_BUTTON (scale);
+ adjustment = gtk_spin_button_get_adjustment (spin_button);
+
+ g_return_if_fail (lower >= gtk_adjustment_get_lower (adjustment));
+ g_return_if_fail (upper <= gtk_adjustment_get_upper (adjustment));
+
+ private->scale_limits_set = TRUE;
+ private->scale_lower = lower;
+ private->scale_upper = upper;
+ private->gamma = 1.0;
+
+ gimp_spin_scale_value_changed (spin_button);
+}
+
+void
+gimp_spin_scale_unset_scale_limits (GimpSpinScale *scale)
+{
+ GimpSpinScalePrivate *private;
+
+ g_return_if_fail (GIMP_IS_SPIN_SCALE (scale));
+
+ private = GET_PRIVATE (scale);
+
+ private->scale_limits_set = FALSE;
+ private->scale_lower = 0.0;
+ private->scale_upper = 0.0;
+
+ gimp_spin_scale_value_changed (GTK_SPIN_BUTTON (scale));
+}
+
+gboolean
+gimp_spin_scale_get_scale_limits (GimpSpinScale *scale,
+ gdouble *lower,
+ gdouble *upper)
+{
+ GimpSpinScalePrivate *private;
+
+ g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), FALSE);
+
+ private = GET_PRIVATE (scale);
+
+ if (lower)
+ *lower = private->scale_lower;
+
+ if (upper)
+ *upper = private->scale_upper;
+
+ return private->scale_limits_set;
+}
+
+void
+gimp_spin_scale_set_gamma (GimpSpinScale *scale,
+ gdouble gamma)
+{
+ GimpSpinScalePrivate *private;
+
+ g_return_if_fail (GIMP_IS_SPIN_SCALE (scale));
+
+ private = GET_PRIVATE (scale);
+
+ private->gamma = gamma;
+
+ gimp_spin_scale_value_changed (GTK_SPIN_BUTTON (scale));
+}
+
+gdouble
+gimp_spin_scale_get_gamma (GimpSpinScale *scale)
+{
+ g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), 1.0);
+
+ return GET_PRIVATE (scale)->gamma;
+}
+
+/**
+ * gimp_spin_scale_set_constrain_drag:
+ * @scale: the #GimpSpinScale.
+ * @constrain: whether constraining to integer values when dragging with
+ * pointer.
+ *
+ * If @constrain_drag is TRUE, dragging the scale with the pointer will
+ * only result into integer values. It will still possible to set the
+ * scale to fractional values (if the spin scale "digits" is above 0)
+ * for instance with keyboard edit.
+ */
+void
+gimp_spin_scale_set_constrain_drag (GimpSpinScale *scale,
+ gboolean constrain)
+{
+ GimpSpinScalePrivate *private;
+
+ g_return_if_fail (GIMP_IS_SPIN_SCALE (scale));
+
+ private = GET_PRIVATE (scale);
+
+ private->constrain_drag = constrain;
+}
+
+gboolean
+gimp_spin_scale_get_constrain_drag (GimpSpinScale *scale)
+{
+ g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), 1.0);
+
+ return GET_PRIVATE (scale)->constrain_drag;
+}