procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 17:33:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions
gimp/libgimpwidgets/gimpspinscale.c
Jehan c93742f178 libgimpwidgets: improving (kinda) GimpSpinScale in RTL layout. 
The label was simply completely invisible because of broken progress
computation. Now it is visible at least when the progress fully cover
the label, but a part of the label is not drawn when the progression is
smaller than the label. I still have not figured out how to fix this,
though I am starting to wonder if we should not just drop this 2-color
fancy drawing of the label. Clearly the fact we can't get the exact
progression gadget dimension is biting us.

Another issue I noticed when playing with RTL layout is that when
editing the value, it gets printed on the right side (together with the
label) which gets messy. This is also something to figure out, hoping we
get an API for this on the GTK side.

Also I am setting "auto dir" to FALSE on the Pango layout, making sure
it follows the widget direction, whatsoever. In particular, even if the
contents is not RTL characters, we should keep a RTL layout to avoid
completely broken layout.
2022-02-17 23:13:42 +01:00

1476 lines
44 KiB
C
Raw Blame History

/* 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 "libgimpbase/gimpbase.h"
#include "libgimpmath/gimpmath.h"
#include "gimpwidgetstypes.h"
#include "gimpspinscale.h"
#include "libgimp/libgimp-intl.h"
#define RELATIVE_CHANGE_SPEED 0.1
enum
{
PROP_0,
PROP_LABEL
};
typedef enum
{
TARGET_NONE,
TARGET_NUMBER,
TARGET_GRAB,
TARGET_GRABBING,
TARGET_RELATIVE
} SpinScaleTarget;
typedef struct _GimpSpinScalePrivate GimpSpinScalePrivate;
struct _GimpSpinScalePrivate
{
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;
gint start_pointer_x;
gint start_pointer_y;
SpinScaleTarget target;
gboolean hover;
gboolean pointer_warp;
gint pointer_warp_x;
gint pointer_warp_start_x;
};
#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_get_preferred_width (GtkWidget *widget,
gint *minimum_width,
gint *natural_width);
static void gimp_spin_scale_get_preferred_height (GtkWidget *widget,
gint *minimum_width,
gint *natural_width);
static void gimp_spin_scale_style_updated (GtkWidget *widget);
static gboolean gimp_spin_scale_draw (GtkWidget *widget,
cairo_t *cr);
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->get_preferred_width = gimp_spin_scale_get_preferred_width;
widget_class->get_preferred_height = gimp_spin_scale_get_preferred_height;
widget_class->style_updated = gimp_spin_scale_style_updated;
widget_class->draw = gimp_spin_scale_draw;
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));
}
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_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);
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_get_preferred_width (GtkWidget *widget,
gint *minimum_width,
gint *natural_width)
{
GimpSpinScalePrivate *private = GET_PRIVATE (widget);
PangoContext *context = gtk_widget_get_pango_context (widget);
PangoFontMetrics *metrics;
GTK_WIDGET_CLASS (parent_class)->get_preferred_width (widget,
minimum_width,
natural_width);
metrics = pango_context_get_metrics (context,
pango_context_get_font_description (context),
pango_context_get_language (context));
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 */
*minimum_width += char_pixels * 3;
*natural_width += char_pixels * 3;
}
pango_font_metrics_unref (metrics);
}
static void
gimp_spin_scale_get_preferred_height (GtkWidget *widget,
gint *minimum_height,
gint *natural_height)
{
GTK_WIDGET_CLASS (parent_class)->get_preferred_height (widget,
minimum_height,
natural_height);
}
static void
gimp_spin_scale_style_updated (GtkWidget *widget)
{
GimpSpinScalePrivate *private = GET_PRIVATE (widget);
GTK_WIDGET_CLASS (parent_class)->style_updated (widget);
g_clear_object (&private->layout);
}
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_draw (GtkWidget *widget,
cairo_t *cr)
{
GimpSpinScalePrivate *private = GET_PRIVATE (widget);
cairo_save (cr);
GTK_WIDGET_CLASS (parent_class)->draw (widget, cr);
cairo_restore (cr);
if (private->label)
{
GtkStyleContext *style = gtk_widget_get_style_context (widget);
GtkAllocation allocation;
GdkRectangle text_area;
GtkStateFlags state;
gint minimum_width;
gint natural_width;
PangoRectangle ink;
gint layout_offset_x;
gint layout_offset_y;
GdkRGBA text_color;
GdkRGBA bar_text_color;
gdouble progress_fraction;
gdouble progress_x;
gdouble progress_y;
gdouble progress_width;
gdouble progress_height;
gtk_widget_get_allocation (widget, &allocation);
gtk_entry_get_text_area (GTK_ENTRY (widget), &text_area);
state = gtk_widget_get_state_flags (widget);
GTK_WIDGET_CLASS (parent_class)->get_preferred_width (widget,
&minimum_width,
&natural_width);
if (! private->layout)
{
private->layout = gtk_widget_create_pango_layout (widget,
private->label_text);
pango_layout_set_ellipsize (private->layout, PANGO_ELLIPSIZE_END);
/* Needing to force right-to-left layout when the widget is
* set so, even when the text is not RTL text. Without this,
* such case is broken because on the left side, we'd have
* both the value and the label texts.
*/
pango_layout_set_auto_dir (private->layout, FALSE);
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 - minimum_width));
pango_layout_get_pixel_extents (private->layout, &ink, NULL);
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 = text_area.x + text_area.width - ink.width - 2;
else
layout_offset_x = text_area.x + 2;
layout_offset_x -= ink.x;
gtk_style_context_get_color (style, state, &text_color);
gtk_style_context_save (style);
gtk_style_context_add_class (style, GTK_STYLE_CLASS_PROGRESSBAR);
gtk_style_context_get_color (style, state, &bar_text_color);
gtk_style_context_restore (style);
progress_fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (widget));
progress_y = 0.0;
progress_width = (gdouble) text_area.width * progress_fraction;
progress_height = text_area.height;
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
progress_x = text_area.width + text_area.x - progress_width;
else
progress_x = text_area.x;
cairo_save (cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_rectangle (cr, 0, 0, text_area.width, text_area.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, text_area.y + layout_offset_y);
gdk_cairo_set_source_rgba (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, text_area.y + layout_offset_y);
gdk_cairo_set_source_rgba (cr, &bar_text_color);
pango_cairo_show_layout (cr, private->layout);
}
return FALSE;
}
/* Returns TRUE if a translation should be done */
static gboolean
gtk_widget_get_translation_to_window (GtkWidget *widget,
GdkWindow *window,
int *x,
int *y)
{
GdkWindow *w, *widget_window;
if (!gtk_widget_get_has_window (widget))
{
GtkAllocation allocation;
gtk_widget_get_allocation (widget, &allocation);
*x = -allocation.x;
*y = -allocation.y;
}
else
{
*x = 0;
*y = 0;
}
widget_window = gtk_widget_get_window (widget);
for (w = window;
w && w != widget_window;
w = gdk_window_get_parent (w))
{
int wx, wy;
gdk_window_get_position (w, &wx, &wy);
*x += wx;
*y += wy;
}
if (w == NULL)
{
*x = 0;
*y = 0;
return FALSE;
}
return TRUE;
}
static void
gimp_spin_scale_event_to_widget_coords (GtkWidget *widget,
GdkWindow *window,
gdouble event_x,
gdouble event_y,
gdouble *widget_x,
gdouble *widget_y)
{
GdkRectangle text_area;
gint tx, ty;
gtk_entry_get_text_area (GTK_ENTRY (widget), &text_area);
if (gtk_widget_get_translation_to_window (widget, window, &tx, &ty))
{
event_x += tx;
event_y += ty;
}
*widget_x = event_x - text_area.x;
*widget_y = event_y - text_area.y;
}
static SpinScaleTarget
gimp_spin_scale_get_target (GtkWidget *widget,
gdouble x,
gdouble y,
GdkEvent *event)
{
GdkRectangle text_area;
gtk_entry_get_text_area (GTK_ENTRY (widget), &text_area);
if (x >= 0 && x < text_area.width &&
y >= 0 && y < text_area.height)
{
PangoRectangle logical;
gint layout_x;
gint layout_y;
if (! event)
return TARGET_GRAB;
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);
layout_x -= text_area.x;
layout_y -= text_area.y;
if (event->type != GDK_MOTION_NOTIFY)
{
GdkEventButton *event_button = (GdkEventButton *) event;
switch (event_button->button)
{
case 1:
if (event_button->state & GDK_SHIFT_MASK)
return TARGET_RELATIVE;
else
/* Button 1 target depends on the cursor position. */
break;
case 3:
return TARGET_RELATIVE;
default:
return TARGET_NUMBER;
}
}
else
{
GdkEventMotion *event_motion = (GdkEventMotion *) event;
if (event_motion->state & GDK_SHIFT_MASK)
return TARGET_RELATIVE;
}
/* For motion events or main button clicks, the target depends on
* the position.
*/
if (x >= layout_x && x < layout_x + logical.width &&
y >= layout_y && y < layout_y + logical.height)
{
return TARGET_NUMBER;
}
else if (event->type == GDK_MOTION_NOTIFY)
{
return TARGET_GRAB;
}
else
{
return TARGET_GRABBING;
}
}
return TARGET_NONE;
}
static void
gimp_spin_scale_update_cursor (GtkWidget *widget,
GdkWindow *window)
{
GimpSpinScalePrivate *private = GET_PRIVATE (widget);
GdkDisplay *display = gtk_widget_get_display (widget);
GdkCursor *cursor = NULL;
switch (private->target)
{
case TARGET_NUMBER:
cursor = gdk_cursor_new_from_name (display, "text");
break;
case TARGET_GRAB:
cursor = gdk_cursor_new_from_name (display, "grab");
break;
case TARGET_GRABBING:
cursor = gdk_cursor_new_from_name (display, "grabbing");
break;
case TARGET_RELATIVE:
cursor = gdk_cursor_new_from_name (display, "col-resize");
break;
default:
break;
}
gdk_window_set_cursor (window, cursor);
g_clear_object (&cursor);
}
static void
gimp_spin_scale_update_target (GtkWidget *widget,
GdkWindow *window,
gdouble x,
gdouble y,
GdkEvent *event)
{
GimpSpinScalePrivate *private = GET_PRIVATE (widget);
SpinScaleTarget target;
target = gimp_spin_scale_get_target (widget, x, y, (GdkEvent *) event);
if (target != private->target)
{
private->target = target;
gimp_spin_scale_update_cursor (widget, window);
}
}
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;
gimp_spin_scale_update_cursor (widget, window);
}
}
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 void
gimp_spin_scale_change_value (GtkWidget *widget,
gdouble x,
guint state)
{
GimpSpinScalePrivate *private = GET_PRIVATE (widget);
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button);
GdkRectangle text_area;
gdouble lower;
gdouble upper;
gdouble value;
gint digits;
gint power = 1;
gtk_entry_get_text_area (GTK_ENTRY (widget), &text_area);
gimp_spin_scale_get_limits (GIMP_SPIN_SCALE (widget), &lower, &upper);
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
x = text_area.width - x;
if (private->relative_change)
{
gdouble step;
step = (upper - lower) / text_area.width * RELATIVE_CHANGE_SPEED;
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
step *= x - (text_area.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) text_area.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);
gtk_adjustment_set_value (adjustment, value);
}
static gboolean
gimp_spin_scale_button_press (GtkWidget *widget,
GdkEventButton *event)
{
GimpSpinScalePrivate *private = GET_PRIVATE (widget);
gdouble x, y;
private->changing_value = FALSE;
private->relative_change = FALSE;
private->pointer_warp = FALSE;
gimp_spin_scale_event_to_widget_coords (widget, event->window,
event->x, event->y,
&x, &y);
gimp_spin_scale_update_target (widget, event->window, x, y, (GdkEvent *) event);
switch (private->target)
{
case TARGET_GRAB:
case TARGET_GRABBING:
private->changing_value = TRUE;
gtk_widget_grab_focus (widget);
gimp_spin_scale_change_value (widget, x, event->state);
gimp_spin_scale_update_cursor (widget, event->window);
return TRUE;
case TARGET_RELATIVE:
private->changing_value = TRUE;
gtk_widget_grab_focus (widget);
private->relative_change = TRUE;
private->start_x = x;
private->start_value = gtk_adjustment_get_value (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)));
private->start_pointer_x = floor (event->x_root);
private->start_pointer_y = floor (event->y_root);
gimp_spin_scale_update_cursor (widget, event->window);
return TRUE;
case TARGET_NUMBER:
gtk_widget_grab_focus (widget);
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);
gdouble x, y;
gimp_spin_scale_event_to_widget_coords (widget, event->window,
event->x, event->y,
&x, &y);
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, x, event->state);
if (private->relative_change)
{
gdk_device_warp (gdk_event_get_device ((GdkEvent *) event),
gdk_event_get_screen ((GdkEvent *) event),
private->start_pointer_x,
private->start_pointer_y);
}
if (private->hover)
{
gimp_spin_scale_update_target (widget, event->window,
0.0, 0.0, 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);
gdouble x, y;
gimp_spin_scale_event_to_widget_coords (widget, event->window,
event->x, event->y,
&x, &y);
gdk_event_request_motions (event);
private->hover = TRUE;
if (private->changing_value)
{
GdkScreen *screen;
GdkDisplay *display;
gint pointer_x;
gint pointer_y;
GdkMonitor *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_display_get_monitor_at_point (display, pointer_x, pointer_y);
gdk_monitor_get_geometry (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_device_warp() 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_device_warp() 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_device_warp(). when
* that happens, we "guess" whether the pointer got warped or
* not by comparing its x coordinate to the one passed to
* gdk_device_warp(): 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;
}
gimp_spin_scale_change_value (widget, x, event->state);
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_device_warp (gdk_event_get_device ((GdkEvent *) event),
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,
x, y, (GdkEvent *) event);
}
return FALSE;
}
static gboolean
gimp_spin_scale_leave_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
GimpSpinScalePrivate *private = GET_PRIVATE (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;
}
Reference in a new issue View git blame Copy permalink