* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <config.h>
+#include "config.h"
#include <stdio.h>
#include <math.h>
#include <gdk/gdkkeysyms.h>
PROP_ADJUSTMENT,
PROP_INVERTED,
PROP_LOWER_STEPPER_SENSITIVITY,
- PROP_UPPER_STEPPER_SENSITIVITY
+ PROP_UPPER_STEPPER_SENSITIVITY,
+ PROP_SHOW_FILL_LEVEL,
+ PROP_RESTRICT_TO_FILL_LEVEL,
+ PROP_FILL_LEVEL
};
enum {
MOUSE_WIDGET /* inside widget but not in any of the above GUI elements */
} MouseLocation;
+#define GTK_RANGE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RANGE, GtkRangeLayout))
+
struct _GtkRangeLayout
{
/* These are in widget->window coordinates */
guint lower_sensitive : 1;
guint upper_sensitive : 1;
+ /* Fill level */
+ guint show_fill_level : 1;
+ guint restrict_to_fill_level : 1;
+
GtkSensitivityType lower_sensitivity;
GtkSensitivityType upper_sensitivity;
+ guint repaint_id;
+
+ gdouble fill_level;
};
GValue *value,
GParamSpec *pspec);
static void gtk_range_destroy (GtkObject *object);
-static void gtk_range_finalize (GObject *object);
static void gtk_range_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_range_size_allocate (GtkWidget *widget,
static void gtk_range_unrealize (GtkWidget *widget);
static void gtk_range_map (GtkWidget *widget);
static void gtk_range_unmap (GtkWidget *widget);
-static gint gtk_range_expose (GtkWidget *widget,
+static gboolean gtk_range_expose (GtkWidget *widget,
GdkEventExpose *event);
-static gint gtk_range_button_press (GtkWidget *widget,
+static gboolean gtk_range_button_press (GtkWidget *widget,
GdkEventButton *event);
-static gint gtk_range_button_release (GtkWidget *widget,
+static gboolean gtk_range_button_release (GtkWidget *widget,
GdkEventButton *event);
-static gint gtk_range_motion_notify (GtkWidget *widget,
+static gboolean gtk_range_motion_notify (GtkWidget *widget,
GdkEventMotion *event);
-static gint gtk_range_enter_notify (GtkWidget *widget,
+static gboolean gtk_range_enter_notify (GtkWidget *widget,
GdkEventCrossing *event);
-static gint gtk_range_leave_notify (GtkWidget *widget,
+static gboolean gtk_range_leave_notify (GtkWidget *widget,
GdkEventCrossing *event);
static gboolean gtk_range_grab_broken (GtkWidget *widget,
GdkEventGrabBroken *event);
gboolean was_grabbed);
static void gtk_range_state_changed (GtkWidget *widget,
GtkStateType previous_state);
-static gint gtk_range_scroll_event (GtkWidget *widget,
+static gboolean gtk_range_scroll_event (GtkWidget *widget,
GdkEventScroll *event);
static void gtk_range_style_set (GtkWidget *widget,
GtkStyle *previous_style);
GtkScrollType scroll);
/* Internals */
-static void gtk_range_scroll (GtkRange *range,
+static gboolean gtk_range_scroll (GtkRange *range,
GtkScrollType scroll);
static gboolean gtk_range_update_mouse_location (GtkRange *range);
static void gtk_range_calc_layout (GtkRange *range,
gobject_class->set_property = gtk_range_set_property;
gobject_class->get_property = gtk_range_get_property;
- gobject_class->finalize = gtk_range_finalize;
object_class->destroy = gtk_range_destroy;
widget_class->size_request = gtk_range_size_request;
class->slider_detail = "slider";
class->stepper_detail = "stepper";
+ /**
+ * GtkRange::value-changed:
+ * @range: the #GtkRange
+ *
+ * Emitted when the range value changes.
+ */
signals[VALUE_CHANGED] =
g_signal_new (I_("value_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_TYPE_NONE, 1,
G_TYPE_DOUBLE);
+ /**
+ * GtkRange::move-slider:
+ * @range: the #GtkRange
+ * @step: how to move the slider
+ *
+ * Virtual function that moves the slider. Used for keybindings.
+ */
signals[MOVE_SLIDER] =
g_signal_new (I_("move_slider"),
G_TYPE_FROM_CLASS (gobject_class),
/**
* GtkRange::change-value:
- * @range: the range that received the signal.
- * @scroll: the type of scroll action that was performed.
- * @value: the new value resulting from the scroll action.
+ * @range: the range that received the signal
+ * @scroll: the type of scroll action that was performed
+ * @value: the new value resulting from the scroll action
* @returns: %TRUE to prevent other handlers from being invoked for the
- * signal. %FALSE to propagate the signal further.
+ * signal, %FALSE to propagate the signal further
*
* The ::change-value signal is emitted when a scroll action is
* performed on a range. It allows an application to determine the
G_TYPE_BOOLEAN, 2,
GTK_TYPE_SCROLL_TYPE,
G_TYPE_DOUBLE);
-
+
g_object_class_install_property (gobject_class,
PROP_UPDATE_POLICY,
g_param_spec_enum ("update-policy",
GTK_SENSITIVITY_AUTO,
GTK_PARAM_READWRITE));
+ /**
+ * GtkRange:show-fill-level:
+ *
+ * The show-fill-level property controls whether fill level indicator
+ * graphics are displayed on the trough. See
+ * gtk_range_set_show_fill_level().
+ *
+ * Since: 2.12
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_SHOW_FILL_LEVEL,
+ g_param_spec_boolean ("show-fill-level",
+ P_("Show Fill Level"),
+ P_("Whether to display a fill level indicator graphics on trough."),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkRange:restrict-to-fill-level:
+ *
+ * The restrict-to-fill-level property controls whether slider
+ * movement is restricted to an upper boundary set by the
+ * fill level. See gtk_range_set_restrict_to_fill_level().
+ *
+ * Since: 2.12
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_RESTRICT_TO_FILL_LEVEL,
+ g_param_spec_boolean ("restrict-to-fill-level",
+ P_("Restrict to Fill Level"),
+ P_("Whether to restrict the upper boundary to the fill level."),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkRange:fill-level:
+ *
+ * The fill level (e.g. prebuffering of a network stream).
+ * See gtk_range_set_fill_level().
+ *
+ * Since: 2.12
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_FILL_LEVEL,
+ g_param_spec_double ("fill-level",
+ P_("Fill Level"),
+ P_("The fill level."),
+ -G_MAXDOUBLE,
+ G_MAXDOUBLE,
+ G_MAXDOUBLE,
+ GTK_PARAM_READWRITE));
+
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("slider-width",
P_("Slider Width"),
*
* The spacing between the stepper buttons and thumb. Note that
* setting this value to anything > 0 will automatically set the
- * trough-under-steppers style property to TRUE as well. Also,
+ * trough-under-steppers style property to %TRUE as well. Also,
* stepper-spacing won't have any effect if there are no steppers.
*/
gtk_widget_class_install_style_property (widget_class,
/**
* GtkRange:trough-side-details:
*
+ * When %TRUE, the parts of the trough on the two sides of the
+ * slider are drawn with different details.
+ *
* Since: 2.10
*/
gtk_widget_class_install_style_property (widget_class,
*
* Whether to draw the trough across the full length of the range or
* to exclude the steppers and their spacing. Note that setting the
- * stepper-spacing style property to any value > 0 will
+ * #GtkRange:stepper-spacing style property to any value > 0 will
* automatically enable trough-under-steppers too.
*
* Since: 2.10
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("trough-under-steppers",
P_("Trough Under Steppers"),
- P_("Whether to draw trought for full length of range or exclude the steppers and spacing"),
+ P_("Whether to draw trough for full length of range or exclude the steppers and spacing"),
TRUE,
GTK_PARAM_READABLE));
+
+ g_type_class_add_private (class, sizeof (GtkRangeLayout));
}
static void
case PROP_UPPER_STEPPER_SENSITIVITY:
gtk_range_set_upper_stepper_sensitivity (range, g_value_get_enum (value));
break;
+ case PROP_SHOW_FILL_LEVEL:
+ gtk_range_set_show_fill_level (range, g_value_get_boolean (value));
+ break;
+ case PROP_RESTRICT_TO_FILL_LEVEL:
+ gtk_range_set_restrict_to_fill_level (range, g_value_get_boolean (value));
+ break;
+ case PROP_FILL_LEVEL:
+ gtk_range_set_fill_level (range, g_value_get_double (value));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_UPPER_STEPPER_SENSITIVITY:
g_value_set_enum (value, gtk_range_get_upper_stepper_sensitivity (range));
break;
+ case PROP_SHOW_FILL_LEVEL:
+ g_value_set_boolean (value, gtk_range_get_show_fill_level (range));
+ break;
+ case PROP_RESTRICT_TO_FILL_LEVEL:
+ g_value_set_boolean (value, gtk_range_get_restrict_to_fill_level (range));
+ break;
+ case PROP_FILL_LEVEL:
+ g_value_set_double (value, gtk_range_get_fill_level (range));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
range->has_stepper_d = FALSE;
range->need_recalc = TRUE;
range->round_digits = -1;
- range->layout = g_new0 (GtkRangeLayout, 1);
+ range->layout = GTK_RANGE_GET_PRIVATE (range);
range->layout->mouse_location = MOUSE_OUTSIDE;
range->layout->mouse_x = -1;
range->layout->mouse_y = -1;
range->layout->upper_sensitivity = GTK_SENSITIVITY_AUTO;
range->layout->lower_sensitive = TRUE;
range->layout->upper_sensitive = TRUE;
+ range->layout->show_fill_level = FALSE;
+ range->layout->restrict_to_fill_level = TRUE;
+ range->layout->fill_level = G_MAXDOUBLE;
range->timer = NULL;
}
* continuous. #GTK_UPDATE_DISCONTINUOUS means that the value will only
* be updated when the user releases the button and ends the slider
* drag operation.
- *
**/
void
gtk_range_set_update_policy (GtkRange *range,
* is normally 0 for #GtkScale and nonzero for #GtkScrollbar, and
* indicates the size of the visible area of the widget being scrolled.
* The page size affects the size of the scrollbar slider.
- *
**/
void
gtk_range_set_adjustment (GtkRange *range,
* slider moves from top to bottom or left to right. Inverted
* ranges have higher values at the top or on the right rather than
* on the bottom or left.
- *
**/
void
gtk_range_set_inverted (GtkRange *range,
* The step size is used when the user clicks the #GtkScrollbar
* arrows or moves #GtkScale via arrow keys. The page size
* is used for example when moving via Page Up or Page Down keys.
- *
**/
void
gtk_range_set_increments (GtkRange *range,
range->adjustment->lower = min;
range->adjustment->upper = max;
- value = CLAMP (range->adjustment->value,
- range->adjustment->lower,
+ value = range->adjustment->value;
+
+ if (range->layout->restrict_to_fill_level)
+ value = MIN (value, MAX (range->adjustment->lower,
+ range->layout->fill_level));
+
+ value = CLAMP (value, range->adjustment->lower,
(range->adjustment->upper - range->adjustment->page_size));
gtk_adjustment_set_value (range->adjustment, value);
*
* Sets the current value of the range; if the value is outside the
* minimum or maximum range values, it will be clamped to fit inside
- * them. The range emits the "value_changed" signal if the value
- * changes.
- *
+ * them. The range emits the #GtkRange::value-changed signal if the
+ * value changes.
**/
void
gtk_range_set_value (GtkRange *range,
gdouble value)
{
g_return_if_fail (GTK_IS_RANGE (range));
-
+
+ if (range->layout->restrict_to_fill_level)
+ value = MIN (value, MAX (range->adjustment->lower,
+ range->layout->fill_level));
+
value = CLAMP (value, range->adjustment->lower,
(range->adjustment->upper - range->adjustment->page_size));
return range->adjustment->value;
}
+/**
+ * gtk_range_set_show_fill_level:
+ * @range: A #GtkRange
+ * @show_fill_level: Whether a fill level indicator graphics is shown.
+ *
+ * Sets whether a graphical fill level is show on the trough. See
+ * gtk_range_set_fill_level() for a general description of the fill
+ * level concept.
+ *
+ * Since: 2.12
+ **/
+void
+gtk_range_set_show_fill_level (GtkRange *range,
+ gboolean show_fill_level)
+{
+ g_return_if_fail (GTK_IS_RANGE (range));
+
+ show_fill_level = show_fill_level ? TRUE : FALSE;
+
+ if (show_fill_level != range->layout->show_fill_level)
+ {
+ range->layout->show_fill_level = show_fill_level;
+ g_object_notify (G_OBJECT (range), "show-fill-level");
+ gtk_widget_queue_draw (GTK_WIDGET (range));
+ }
+}
+
+/**
+ * gtk_range_get_show_fill_level:
+ * @range: A #GtkRange
+ *
+ * Gets whether the range displays the fill level graphically.
+ *
+ * Return value: %TRUE if @range shows the fill level.
+ *
+ * Since: 2.12
+ **/
+gboolean
+gtk_range_get_show_fill_level (GtkRange *range)
+{
+ g_return_val_if_fail (GTK_IS_RANGE (range), FALSE);
+
+ return range->layout->show_fill_level;
+}
+
+/**
+ * gtk_range_set_restrict_to_fill_level:
+ * @range: A #GtkRange
+ * @restrict_to_fill_level: Whether the fill level restricts slider movement.
+ *
+ * Sets whether the slider is restricted to the fill level. See
+ * gtk_range_set_fill_level() for a general description of the fill
+ * level concept.
+ *
+ * Since: 2.12
+ **/
+void
+gtk_range_set_restrict_to_fill_level (GtkRange *range,
+ gboolean restrict_to_fill_level)
+{
+ g_return_if_fail (GTK_IS_RANGE (range));
+
+ restrict_to_fill_level = restrict_to_fill_level ? TRUE : FALSE;
+
+ if (restrict_to_fill_level != range->layout->restrict_to_fill_level)
+ {
+ range->layout->restrict_to_fill_level = restrict_to_fill_level;
+ g_object_notify (G_OBJECT (range), "restrict-to-fill-level");
+
+ gtk_range_set_value (range, gtk_range_get_value (range));
+ }
+}
+
+/**
+ * gtk_range_get_restrict_to_fill_level:
+ * @range: A #GtkRange
+ *
+ * Gets whether the range is restricted to the fill level.
+ *
+ * Return value: %TRUE if @range is restricted to the fill level.
+ *
+ * Since: 2.12
+ **/
+gboolean
+gtk_range_get_restrict_to_fill_level (GtkRange *range)
+{
+ g_return_val_if_fail (GTK_IS_RANGE (range), FALSE);
+
+ return range->layout->restrict_to_fill_level;
+}
+
+/**
+ * gtk_range_set_fill_level:
+ * @range: a #GtkRange
+ * @fill_level: the new position of the fill level indicator
+ *
+ * Set the new position of the fill level indicator.
+ *
+ * The "fill level" is probably best described by its most prominent
+ * use case, which is an indicator for the amount of pre-buffering in
+ * a streaming media player. In that use case, the value of the range
+ * would indicate the current play position, and the fill level would
+ * be the position up to which the file/stream has been downloaded.
+ *
+ * This amount of prebuffering can be displayed on the range's trough
+ * and is themeable separately from the trough. To enable fill level
+ * display, use gtk_range_set_show_fill_level(). The range defaults
+ * to not showing the fill level.
+ *
+ * Additionally, it's possible to restrict the range's slider position
+ * to values which are smaller than the fill level. This is controller
+ * by gtk_range_set_restrict_to_fill_level() and is by default
+ * enabled.
+ *
+ * Since: 2.12
+ **/
+void
+gtk_range_set_fill_level (GtkRange *range,
+ gdouble fill_level)
+{
+ g_return_if_fail (GTK_IS_RANGE (range));
+
+ if (fill_level != range->layout->fill_level)
+ {
+ range->layout->fill_level = fill_level;
+ g_object_notify (G_OBJECT (range), "fill-level");
+
+ if (range->layout->show_fill_level)
+ gtk_widget_queue_draw (GTK_WIDGET (range));
+
+ if (range->layout->restrict_to_fill_level)
+ gtk_range_set_value (range, gtk_range_get_value (range));
+ }
+}
+
+/**
+ * gtk_range_get_fill_level:
+ * @range : A #GtkRange
+ *
+ * Gets the current position of the fill level indicator.
+ *
+ * Return value: The current fill level
+ *
+ * Since: 2.12
+ **/
+gdouble
+gtk_range_get_fill_level (GtkRange *range)
+{
+ g_return_val_if_fail (GTK_IS_RANGE (range), 0.0);
+
+ return range->layout->fill_level;
+}
+
static gboolean
should_invert (GtkRange *range)
{
return range->inverted;
}
-static void
-gtk_range_finalize (GObject *object)
-{
- GtkRange *range = GTK_RANGE (object);
-
- g_free (range->layout);
-
- (* G_OBJECT_CLASS (gtk_range_parent_class)->finalize) (object);
-}
-
static void
gtk_range_destroy (GtkObject *object)
{
gtk_range_remove_step_timer (range);
gtk_range_remove_update_timer (range);
-
+
+ if (range->layout->repaint_id)
+ g_source_remove (range->layout->repaint_id);
+ range->layout->repaint_id = 0;
+
if (range->adjustment)
{
g_signal_handlers_disconnect_by_func (range->adjustment,
arrow_x, arrow_y, arrow_width, arrow_height);
}
-static gint
+static gboolean
gtk_range_expose (GtkWidget *widget,
GdkEventExpose *event)
{
- GtkRange *range;
+ GtkRange *range = GTK_RANGE (widget);
gboolean sensitive;
GtkStateType state;
GtkShadowType shadow_type;
g_object_get (gtk_widget_get_settings (widget),
"gtk-touchscreen-mode", &touchscreen,
NULL);
+ if (GTK_WIDGET_CAN_FOCUS (range))
+ gtk_widget_style_get (GTK_WIDGET (range),
+ "focus-line-width", &focus_line_width,
+ "focus-padding", &focus_padding,
+ NULL);
- range = GTK_RANGE (widget);
+ /* we're now exposing, so there's no need to force early repaints */
+ if (range->layout->repaint_id)
+ g_source_remove (range->layout->repaint_id);
+ range->layout->repaint_id = 0;
- if (GTK_WIDGET_CAN_FOCUS (range))
- {
- gtk_widget_style_get (GTK_WIDGET (range),
- "focus-line-width", &focus_line_width,
- "focus-padding", &focus_padding,
- NULL);
- }
-
expose_area = event->area;
expose_area.x -= widget->allocation.x;
expose_area.y -= widget->allocation.y;
height - trough_change_pos_y);
}
+ if (range->layout->show_fill_level &&
+ range->adjustment->upper - range->adjustment->page_size -
+ range->adjustment->lower != 0)
+ {
+ gdouble fill_level = range->layout->fill_level;
+ gint fill_x = x;
+ gint fill_y = y;
+ gint fill_width = width;
+ gint fill_height = height;
+ gchar *fill_detail;
+
+ fill_level = CLAMP (fill_level, range->adjustment->lower,
+ range->adjustment->upper -
+ range->adjustment->page_size);
+
+ if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
+ {
+ fill_x = widget->allocation.x + range->layout->trough.x;
+ fill_width = (range->layout->slider.width +
+ (fill_level - range->adjustment->lower) /
+ (range->adjustment->upper -
+ range->adjustment->lower -
+ range->adjustment->page_size) *
+ (range->layout->trough.width -
+ range->layout->slider.width));
+
+ if (should_invert (range))
+ fill_x += range->layout->trough.width - fill_width;
+ }
+ else
+ {
+ fill_y = widget->allocation.y + range->layout->trough.y;
+ fill_height = (range->layout->slider.height +
+ (fill_level - range->adjustment->lower) /
+ (range->adjustment->upper -
+ range->adjustment->lower -
+ range->adjustment->page_size) *
+ (range->layout->trough.height -
+ range->layout->slider.height));
+
+ if (should_invert (range))
+ fill_y += range->layout->trough.height - fill_height;
+ }
+
+ if (fill_level < range->adjustment->upper - range->adjustment->page_size)
+ fill_detail = "trough-fill-level-full";
+ else
+ fill_detail = "trough-fill-level";
+
+ gtk_paint_box (widget->style,
+ widget->window,
+ sensitive ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
+ GTK_SHADOW_OUT,
+ &area, GTK_WIDGET (range), fill_detail,
+ fill_x, fill_y,
+ fill_width, fill_height);
+ }
+
if (sensitive &&
GTK_WIDGET_HAS_FOCUS (range))
gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
static void
range_grab_remove (GtkRange *range)
{
+ MouseLocation location;
+
gtk_grab_remove (GTK_WIDGET (range));
-
+
+ location = range->layout->grab_location;
range->layout->grab_location = MOUSE_OUTSIDE;
range->layout->grab_button = 0;
- if (gtk_range_update_mouse_location (range))
+ if (gtk_range_update_mouse_location (range) ||
+ location != MOUSE_OUTSIDE)
gtk_widget_queue_draw (GTK_WIDGET (range));
}
gtk_range_key_press (GtkWidget *widget,
GdkEventKey *event)
{
- GtkRange *range = (GtkRange *)widget;
+ GtkRange *range = GTK_RANGE (widget);
- if (event->keyval == GDK_Escape)
+ if (event->keyval == GDK_Escape &&
+ range->layout->grab_location != MOUSE_OUTSIDE)
{
stop_scrolling (range);
- update_slider_position (range,
+ update_slider_position (range,
range->slide_initial_coordinate,
range->slide_initial_coordinate);
return TRUE;
}
- else
- return GTK_WIDGET_CLASS (gtk_range_parent_class)->key_press_event (widget, event);
+
+ return GTK_WIDGET_CLASS (gtk_range_parent_class)->key_press_event (widget, event);
}
static gint
gtk_range_remove_step_timer (range);
/* Flush any pending discontinuous/delayed updates */
gtk_range_update_value (range);
-
- /* Just be lazy about this, if we scrolled it will all redraw anyway,
- * so no point optimizing the button deactivate case
- */
- gtk_widget_queue_draw (GTK_WIDGET (range));
}
static gboolean
return delta;
}
-static gint
+static gboolean
gtk_range_scroll_event (GtkWidget *widget,
GdkEventScroll *event)
{
return TRUE;
}
-static gint
+static gboolean
gtk_range_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
return range->layout->mouse_location != MOUSE_OUTSIDE;
}
-static gint
+static gboolean
gtk_range_enter_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
return TRUE;
}
-static gint
+static gboolean
gtk_range_leave_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
*/
}
+static gboolean
+force_repaint (gpointer data)
+{
+ GtkRange *range = GTK_RANGE (data);
+ range->layout->repaint_id = 0;
+ if (GTK_WIDGET_DRAWABLE (range))
+ gdk_window_process_updates (GTK_WIDGET (range)->window, FALSE);
+ return FALSE;
+}
+
static void
gtk_range_adjustment_value_changed (GtkAdjustment *adjustment,
gpointer data)
if (layout_changed (range->layout, &layout))
{
gtk_widget_queue_draw (GTK_WIDGET (range));
-
- /* This is so we don't lag the widget being scrolled. */
- if (GTK_WIDGET_REALIZED (range))
- gdk_window_process_updates (GTK_WIDGET (range)->window, FALSE);
+ /* setup a timer to ensure the range isn't lagging too much behind the scroll position */
+ if (!range->layout->repaint_id)
+ range->layout->repaint_id = gdk_threads_add_timeout_full (GDK_PRIORITY_EVENTS, 181, force_repaint, range, NULL);
}
/* Note that we don't round off to range->round_digits here.
&handled);
}
-static void
+static gboolean
gtk_range_scroll (GtkRange *range,
GtkScrollType scroll)
{
+ gdouble old_value = range->adjustment->value;
+
switch (scroll)
{
case GTK_SCROLL_STEP_LEFT:
case GTK_SCROLL_NONE:
break;
}
+
+ return range->adjustment->value != old_value;
}
static void
gtk_range_move_slider (GtkRange *range,
GtkScrollType scroll)
{
- gtk_range_scroll (range, scroll);
+ gboolean cursor_only;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (range)),
+ "gtk-keynav-cursor-only", &cursor_only,
+ NULL);
+
+ if (cursor_only)
+ {
+ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (range));
+
+ if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
+ {
+ if (scroll == GTK_SCROLL_STEP_UP ||
+ scroll == GTK_SCROLL_STEP_DOWN)
+ {
+ if (toplevel)
+ gtk_widget_child_focus (toplevel,
+ scroll == GTK_SCROLL_STEP_UP ?
+ GTK_DIR_UP : GTK_DIR_DOWN);
+ return;
+ }
+ }
+ else
+ {
+ if (scroll == GTK_SCROLL_STEP_LEFT ||
+ scroll == GTK_SCROLL_STEP_RIGHT)
+ {
+ if (toplevel)
+ gtk_widget_child_focus (toplevel,
+ scroll == GTK_SCROLL_STEP_LEFT ?
+ GTK_DIR_LEFT : GTK_DIR_RIGHT);
+ return;
+ }
+ }
+ }
+
+ if (! gtk_range_scroll (range, scroll))
+ gtk_widget_error_bell (GTK_WIDGET (range));
/* Policy DELAYED makes sense with key events,
* but DISCONTINUOUS doesn't, so we update immediately
/* potentially adjust the bounds _before we clamp */
g_signal_emit (range, signals[ADJUST_BOUNDS], 0, value);
+ if (range->layout->restrict_to_fill_level)
+ value = MIN (value, MAX (range->adjustment->lower,
+ range->layout->fill_level));
+
value = CLAMP (value, range->adjustment->lower,
(range->adjustment->upper - range->adjustment->page_size));
{
GtkRange *range;
- GDK_THREADS_ENTER ();
range = GTK_RANGE (data);
gtk_range_scroll (range, range->timer->step);
- GDK_THREADS_LEAVE ();
return TRUE;
}
GtkSettings *settings;
guint timeout;
- GDK_THREADS_ENTER ();
settings = gtk_widget_get_settings (GTK_WIDGET (data));
g_object_get (settings, "gtk-timeout-repeat", &timeout, NULL);
range = GTK_RANGE (data);
- range->timer->timeout_id = g_timeout_add (timeout * SCROLL_DELAY_FACTOR,
+ range->timer->timeout_id = gdk_threads_add_timeout (timeout * SCROLL_DELAY_FACTOR,
second_timeout,
range);
- GDK_THREADS_LEAVE ();
-
/* remove self */
return FALSE;
}
range->timer = g_new (GtkRangeStepTimer, 1);
- range->timer->timeout_id = g_timeout_add (timeout,
+ range->timer->timeout_id = gdk_threads_add_timeout (timeout,
initial_timeout,
range);
range->timer->step = step;
{
GtkRange *range;
- GDK_THREADS_ENTER ();
range = GTK_RANGE (data);
gtk_range_update_value (range);
range->update_timeout_id = 0;
- GDK_THREADS_LEAVE ();
/* self-remove */
return FALSE;
{
gtk_range_remove_update_timer (range);
- range->update_timeout_id = g_timeout_add (UPDATE_DELAY,
+ range->update_timeout_id = gdk_threads_add_timeout (UPDATE_DELAY,
update_timeout,
range);
}
projects / ~andy / gtk / blobdiff