*/
/*
- * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2004. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#include <config.h>
#include <stdio.h>
+#include <math.h>
+#include "gtkalias.h"
#include "gtkintl.h"
#include "gtkmain.h"
+#include "gtkmarshalers.h"
#include "gtkrange.h"
-#include "gtksignal.h"
#include "gtkintl.h"
+#include "gtkscrollbar.h"
#define SCROLL_INITIAL_DELAY 250 /* must hold button this long before ... */
#define SCROLL_LATER_DELAY 100 /* ... it starts repeating at this rate */
enum {
VALUE_CHANGED,
+ ADJUST_BOUNDS,
MOVE_SLIDER,
+ CHANGE_VALUE,
LAST_SIGNAL
};
GtkAllocation *allocation);
static void gtk_range_realize (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,
GdkEventExpose *event);
static gint gtk_range_button_press (GtkWidget *widget,
GdkEventCrossing *event);
static gint gtk_range_leave_notify (GtkWidget *widget,
GdkEventCrossing *event);
+static void gtk_range_grab_notify (GtkWidget *widget,
+ gboolean was_grabbed);
+static void gtk_range_state_changed (GtkWidget *widget,
+ GtkStateType previous_state);
static gint gtk_range_scroll_event (GtkWidget *widget,
GdkEventScroll *event);
static void gtk_range_style_set (GtkWidget *widget,
gint *slider_width,
gint *stepper_size,
gint *trough_border,
- gint *stepper_spacing);
+ gint *stepper_spacing,
+ gint *arrow_displacement_x,
+ gint *arrow_displacement_y);
static void gtk_range_calc_request (GtkRange *range,
gint slider_width,
gint stepper_size,
static void gtk_range_remove_update_timer (GtkRange *range);
static GdkRectangle* get_area (GtkRange *range,
MouseLocation location);
-static void gtk_range_internal_set_value (GtkRange *range,
+static gboolean gtk_range_real_change_value (GtkRange *range,
+ GtkScrollType scroll,
gdouble value);
static void gtk_range_update_value (GtkRange *range);
static guint signals[LAST_SIGNAL];
-GtkType
+GType
gtk_range_get_type (void)
{
- static GtkType range_type = 0;
+ static GType range_type = 0;
if (!range_type)
{
- static const GtkTypeInfo range_info =
+ static const GTypeInfo range_info =
{
- "GtkRange",
- sizeof (GtkRange),
sizeof (GtkRangeClass),
- (GtkClassInitFunc) gtk_range_class_init,
- (GtkObjectInitFunc) gtk_range_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) NULL,
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_range_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkRange),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gtk_range_init,
+ NULL, /* value_table */
};
- range_type = gtk_type_unique (GTK_TYPE_WIDGET, &range_info);
+ range_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkRange",
+ &range_info, G_TYPE_FLAG_ABSTRACT);
}
return range_type;
widget_class->size_allocate = gtk_range_size_allocate;
widget_class->realize = gtk_range_realize;
widget_class->unrealize = gtk_range_unrealize;
+ widget_class->map = gtk_range_map;
+ widget_class->unmap = gtk_range_unmap;
widget_class->expose_event = gtk_range_expose;
widget_class->button_press_event = gtk_range_button_press;
widget_class->button_release_event = gtk_range_button_release;
widget_class->scroll_event = gtk_range_scroll_event;
widget_class->enter_notify_event = gtk_range_enter_notify;
widget_class->leave_notify_event = gtk_range_leave_notify;
+ widget_class->grab_notify = gtk_range_grab_notify;
+ widget_class->state_changed = gtk_range_state_changed;
widget_class->style_set = gtk_range_style_set;
class->move_slider = gtk_range_move_slider;
+ class->change_value = gtk_range_real_change_value;
class->slider_detail = "slider";
class->stepper_detail = "stepper";
signals[VALUE_CHANGED] =
g_signal_new ("value_changed",
- G_TYPE_FROM_CLASS (object_class),
+ G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkRangeClass, value_changed),
NULL, NULL,
- gtk_marshal_NONE__NONE,
+ _gtk_marshal_NONE__NONE,
G_TYPE_NONE, 0);
+ signals[ADJUST_BOUNDS] =
+ g_signal_new ("adjust_bounds",
+ G_TYPE_FROM_CLASS (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkRangeClass, adjust_bounds),
+ NULL, NULL,
+ _gtk_marshal_VOID__DOUBLE,
+ G_TYPE_NONE, 1,
+ G_TYPE_DOUBLE);
+
signals[MOVE_SLIDER] =
g_signal_new ("move_slider",
- G_TYPE_FROM_CLASS (object_class),
+ G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkRangeClass, move_slider),
NULL, NULL,
- gtk_marshal_VOID__ENUM,
+ _gtk_marshal_VOID__ENUM,
G_TYPE_NONE, 1,
GTK_TYPE_SCROLL_TYPE);
-
+
+ /**
+ * 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.
+ * @returns: %TRUE to prevent other handlers from being invoked for the
+ * 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
+ * type of scroll event that occurred and the resultant new value.
+ * The application can handle the event itself and return %TRUE to
+ * prevent further processing. Or, by returning %FALSE, it can pass
+ * the event to other handlers until the default GTK+ handler is
+ * reached.
+ *
+ * The value parameter is unrounded. An application that overrides
+ * the ::change-value signal is responsible for clamping the value to
+ * the desired number of decimal digits; the default GTK+ handler
+ * clamps the value based on @range->round_digits.
+ *
+ * It is not possible to use delayed update policies in an overridden
+ * ::change-value handler.
+ *
+ * Since: 2.6
+ */
+ signals[CHANGE_VALUE] =
+ g_signal_new ("change_value",
+ G_TYPE_FROM_CLASS (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkRangeClass, change_value),
+ _gtk_boolean_handled_accumulator, NULL,
+ _gtk_marshal_BOOLEAN__ENUM_DOUBLE,
+ 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",
- _("Update policy"),
- _("How the range should be updated on the screen"),
+ P_("Update policy"),
+ P_("How the range should be updated on the screen"),
GTK_TYPE_UPDATE_TYPE,
GTK_UPDATE_CONTINUOUS,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ADJUSTMENT,
g_param_spec_object ("adjustment",
- _("Adjustment"),
- _("The GtkAdjustment that contains the current value of this range object"),
+ P_("Adjustment"),
+ P_("The GtkAdjustment that contains the current value of this range object"),
GTK_TYPE_ADJUSTMENT,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_INVERTED,
g_param_spec_boolean ("inverted",
- _("Inverted"),
- _("Invert direction slider moves to increase range value"),
+ P_("Inverted"),
+ P_("Invert direction slider moves to increase range value"),
FALSE,
G_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("slider_width",
- _("Slider Width"),
- _("Width of scrollbar or scale thumb"),
+ P_("Slider Width"),
+ P_("Width of scrollbar or scale thumb"),
0,
G_MAXINT,
14,
G_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("trough_border",
- _("Trough Border"),
- _("Spacing between thumb/steppers and outer trough bevel"),
+ P_("Trough Border"),
+ P_("Spacing between thumb/steppers and outer trough bevel"),
0,
G_MAXINT,
1,
G_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("stepper_size",
- _("Stepper Size"),
- _("Length of step buttons at ends"),
+ P_("Stepper Size"),
+ P_("Length of step buttons at ends"),
0,
G_MAXINT,
14,
G_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("stepper_spacing",
- _("Stepper Spacing"),
- _("Spacing between step buttons and thumb"),
+ P_("Stepper Spacing"),
+ P_("Spacing between step buttons and thumb"),
0,
G_MAXINT,
0,
G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int ("arrow_displacement_x",
+ P_("Arrow X Displacement"),
+ P_("How far in the x direction to move the arrow when the button is depressed"),
+ G_MININT,
+ G_MAXINT,
+ 0,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int ("arrow_displacement_y",
+ P_("Arrow Y Displacement"),
+ P_("How far in the y direction to move the arrow when the button is depressed"),
+ G_MININT,
+ G_MAXINT,
+ 0,
+ G_PARAM_READABLE));
}
static void
g_value_set_enum (value, range->update_policy);
break;
case PROP_ADJUSTMENT:
- g_value_set_object (value, G_OBJECT (range->adjustment));
+ g_value_set_object (value, range->adjustment);
break;
case PROP_INVERTED:
g_value_set_boolean (value, range->inverted);
static void
gtk_range_init (GtkRange *range)
{
+ GTK_WIDGET_SET_FLAGS (range, GTK_NO_WINDOW);
+
range->adjustment = NULL;
range->update_policy = GTK_UPDATE_CONTINUOUS;
range->inverted = FALSE;
range->need_recalc = TRUE;
range->round_digits = -1;
range->layout = g_new0 (GtkRangeLayout, 1);
+ range->layout->mouse_location = MOUSE_OUTSIDE;
+ range->layout->mouse_x = -1;
+ range->layout->mouse_y = -1;
range->layout->grab_location = MOUSE_OUTSIDE;
range->layout->grab_button = 0;
range->timer = NULL;
{
if (range->adjustment)
{
- gtk_signal_disconnect_by_func (GTK_OBJECT (range->adjustment),
- G_CALLBACK (gtk_range_adjustment_changed),
- range);
- gtk_signal_disconnect_by_func (GTK_OBJECT (range->adjustment),
- G_CALLBACK (gtk_range_adjustment_value_changed),
- range);
- gtk_object_unref (GTK_OBJECT (range->adjustment));
+ g_signal_handlers_disconnect_by_func (range->adjustment,
+ gtk_range_adjustment_changed,
+ range);
+ g_signal_handlers_disconnect_by_func (range->adjustment,
+ gtk_range_adjustment_value_changed,
+ range);
+ g_object_unref (range->adjustment);
}
range->adjustment = adjustment;
- gtk_object_ref (GTK_OBJECT (adjustment));
+ g_object_ref (adjustment);
gtk_object_sink (GTK_OBJECT (adjustment));
- gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
- (GtkSignalFunc) gtk_range_adjustment_changed,
- range);
- gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
- (GtkSignalFunc) gtk_range_adjustment_value_changed,
- range);
+ g_signal_connect (adjustment, "changed",
+ G_CALLBACK (gtk_range_adjustment_changed),
+ range);
+ g_signal_connect (adjustment, "value_changed",
+ G_CALLBACK (gtk_range_adjustment_value_changed),
+ range);
gtk_range_adjustment_changed (adjustment, range);
g_object_notify (G_OBJECT (range), "adjustment");
* @max: maximum range value
*
* Sets the allowable values in the #GtkRange, and clamps the range
- * value to be between min and max.
+ * value to be between @min and @max. (If the range has a non-zero
+ * page size, it is clamped between @min and @max - page-size.)
**/
void
gtk_range_set_range (GtkRange *range,
value = CLAMP (range->adjustment->value,
range->adjustment->lower,
(range->adjustment->upper - range->adjustment->page_size));
-
- gtk_adjustment_changed (range->adjustment);
+
+ gtk_adjustment_set_value (range->adjustment, value);
+ gtk_adjustment_changed (range->adjustment);
}
/**
static void
gtk_range_finalize (GObject *object)
{
- GtkRange *range;
-
- g_return_if_fail (GTK_IS_RANGE (object));
-
- range = GTK_RANGE (object);
+ GtkRange *range = GTK_RANGE (object);
g_free (range->layout);
static void
gtk_range_destroy (GtkObject *object)
{
- GtkRange *range;
-
- g_return_if_fail (GTK_IS_RANGE (object));
-
- range = GTK_RANGE (object);
+ GtkRange *range = GTK_RANGE (object);
gtk_range_remove_step_timer (range);
gtk_range_remove_update_timer (range);
if (range->adjustment)
{
- if (range->adjustment)
- gtk_signal_disconnect_by_data (GTK_OBJECT (range->adjustment),
- (gpointer) range);
- gtk_object_unref (GTK_OBJECT (range->adjustment));
+ g_signal_handlers_disconnect_by_func (range->adjustment,
+ gtk_range_adjustment_changed,
+ range);
+ g_signal_handlers_disconnect_by_func (range->adjustment,
+ gtk_range_adjustment_value_changed,
+ range);
+ g_object_unref (range->adjustment);
range->adjustment = NULL;
}
range = GTK_RANGE (widget);
gtk_range_get_props (range,
- &slider_width, &stepper_size, &trough_border, &stepper_spacing);
+ &slider_width, &stepper_size, &trough_border, &stepper_spacing,
+ NULL, NULL);
gtk_range_calc_request (range,
slider_width, stepper_size, trough_border, stepper_spacing,
range = GTK_RANGE (widget);
+ widget->allocation = *allocation;
+
range->need_recalc = TRUE;
gtk_range_calc_layout (range, range->adjustment->value);
- (* GTK_WIDGET_CLASS (parent_class)->size_allocate) (widget, allocation);
+ if (GTK_WIDGET_REALIZED (range))
+ gdk_window_move_resize (range->event_window,
+ widget->allocation.x,
+ widget->allocation.y,
+ widget->allocation.width,
+ widget->allocation.height);
}
static void
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ widget->window = gtk_widget_get_parent_window (widget);
+ g_object_ref (widget->window);
+
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
+ attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = gtk_widget_get_events (widget);
- attributes.event_mask |= (GDK_EXPOSURE_MASK |
- GDK_BUTTON_PRESS_MASK |
+ attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK);
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ attributes_mask = GDK_WA_X | GDK_WA_Y;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, range);
+ range->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (range->event_window, range);
widget->style = gtk_style_attach (widget->style, widget->window);
- gtk_style_set_background (widget->style, widget->window, widget->state);
}
static void
gtk_range_unrealize (GtkWidget *widget)
{
- GtkRange *range;
-
- g_return_if_fail (GTK_IS_RANGE (widget));
-
- range = GTK_RANGE (widget);
+ GtkRange *range = GTK_RANGE (widget);
gtk_range_remove_step_timer (range);
gtk_range_remove_update_timer (range);
+ gdk_window_set_user_data (range->event_window, NULL);
+ gdk_window_destroy (range->event_window);
+ range->event_window = NULL;
+
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
+static void
+gtk_range_map (GtkWidget *widget)
+{
+ GtkRange *range = GTK_RANGE (widget);
+
+ gdk_window_show (range->event_window);
+
+ GTK_WIDGET_CLASS (parent_class)->map (widget);
+}
+
+static void
+gtk_range_unmap (GtkWidget *widget)
+{
+ GtkRange *range = GTK_RANGE (widget);
+
+ gdk_window_hide (range->event_window);
+
+ GTK_WIDGET_CLASS (parent_class)->unmap (widget);
+}
+
static void
draw_stepper (GtkRange *range,
GdkRectangle *rect,
GtkStateType state_type;
GtkShadowType shadow_type;
GdkRectangle intersection;
+ GtkWidget *widget = GTK_WIDGET (range);
+
+ gint arrow_x;
+ gint arrow_y;
+ gint arrow_width;
+ gint arrow_height;
/* More to get the right clip region than for efficiency */
if (!gdk_rectangle_intersect (area, rect, &intersection))
return;
+
+ intersection.x += widget->allocation.x;
+ intersection.y += widget->allocation.y;
if (!GTK_WIDGET_IS_SENSITIVE (range))
state_type = GTK_STATE_INSENSITIVE;
shadow_type = GTK_SHADOW_IN;
else
shadow_type = GTK_SHADOW_OUT;
+
+ gtk_paint_box (widget->style,
+ widget->window,
+ state_type, shadow_type,
+ &intersection, widget,
+ GTK_RANGE_GET_CLASS (range)->stepper_detail,
+ widget->allocation.x + rect->x,
+ widget->allocation.y + rect->y,
+ rect->width,
+ rect->height);
+
+ arrow_width = rect->width / 2;
+ arrow_height = rect->height / 2;
+ arrow_x = widget->allocation.x + rect->x + (rect->width - arrow_width) / 2;
+ arrow_y = widget->allocation.y + rect->y + (rect->height - arrow_height) / 2;
- gtk_paint_arrow (GTK_WIDGET (range)->style,
- GTK_WIDGET (range)->window,
+ if (clicked)
+ {
+ gint arrow_displacement_x;
+ gint arrow_displacement_y;
+
+ gtk_range_get_props (GTK_RANGE (widget), NULL, NULL, NULL, NULL,
+ &arrow_displacement_x, &arrow_displacement_y);
+
+ arrow_x += arrow_displacement_x;
+ arrow_y += arrow_displacement_y;
+ }
+
+ gtk_paint_arrow (widget->style,
+ widget->window,
state_type, shadow_type,
- &intersection, GTK_WIDGET (range),
+ &intersection, widget,
GTK_RANGE_GET_CLASS (range)->stepper_detail,
arrow_type,
- TRUE, rect->x, rect->y, rect->width, rect->height);
+ TRUE,
+ arrow_x, arrow_y, arrow_width, arrow_height);
}
static gint
GtkRange *range;
gboolean sensitive;
GtkStateType state;
+ GdkRectangle expose_area; /* Relative to widget->allocation */
GdkRectangle area;
-
- g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+ gint focus_line_width = 0;
+ gint focus_padding = 0;
range = GTK_RANGE (widget);
+ 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;
+
gtk_range_calc_layout (range, range->adjustment->value);
sensitive = GTK_WIDGET_IS_SENSITIVE (widget);
-
+
/* Just to be confusing, we draw the trough for the whole
* range rectangle, not the trough rectangle (the trough
* rectangle is just for hit detection)
/* The gdk_rectangle_intersect is more to get the right
* clip region (limited to range_rect) than for efficiency
*/
- if (gdk_rectangle_intersect (&event->area, &range->range_rect,
+ if (gdk_rectangle_intersect (&expose_area, &range->range_rect,
&area))
{
+ area.x += widget->allocation.x;
+ area.y += widget->allocation.y;
+
gtk_paint_box (widget->style,
widget->window,
sensitive ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
GTK_SHADOW_IN,
&area, GTK_WIDGET(range), "trough",
- range->range_rect.x,
- range->range_rect.y,
- range->range_rect.width,
- range->range_rect.height);
+ widget->allocation.x + range->range_rect.x + focus_line_width + focus_padding,
+ widget->allocation.y + range->range_rect.y + focus_line_width + focus_padding,
+ range->range_rect.width - 2 * (focus_line_width + focus_padding),
+ range->range_rect.height - 2 * (focus_line_width + focus_padding));
if (sensitive &&
GTK_WIDGET_HAS_FOCUS (range))
- gtk_paint_focus (widget->style,
- widget->window,
+ gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
&area, widget, "trough",
- range->range_rect.x,
- range->range_rect.y,
+ widget->allocation.x + range->range_rect.x,
+ widget->allocation.y + range->range_rect.y,
range->range_rect.width,
range->range_rect.height);
}
else
state = GTK_STATE_NORMAL;
- if (gdk_rectangle_intersect (&event->area,
+ if (gdk_rectangle_intersect (&expose_area,
&range->layout->slider,
&area))
{
+ area.x += widget->allocation.x;
+ area.y += widget->allocation.y;
+
gtk_paint_slider (widget->style,
widget->window,
state,
GTK_SHADOW_OUT,
- &event->area,
+ &area,
widget,
GTK_RANGE_GET_CLASS (range)->slider_detail,
- range->layout->slider.x,
- range->layout->slider.y,
+ widget->allocation.x + range->layout->slider.x,
+ widget->allocation.y + range->layout->slider.y,
range->layout->slider.width,
range->layout->slider.height,
range->orientation);
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_UP : GTK_ARROW_LEFT,
range->layout->grab_location == MOUSE_STEPPER_A,
range->layout->mouse_location == MOUSE_STEPPER_A,
- &event->area);
+ &expose_area);
if (range->has_stepper_b)
draw_stepper (range, &range->layout->stepper_b,
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_DOWN : GTK_ARROW_RIGHT,
range->layout->grab_location == MOUSE_STEPPER_B,
range->layout->mouse_location == MOUSE_STEPPER_B,
- &event->area);
+ &expose_area);
if (range->has_stepper_c)
draw_stepper (range, &range->layout->stepper_c,
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_UP : GTK_ARROW_LEFT,
range->layout->grab_location == MOUSE_STEPPER_C,
range->layout->mouse_location == MOUSE_STEPPER_C,
- &event->area);
+ &expose_area);
if (range->has_stepper_d)
draw_stepper (range, &range->layout->stepper_d,
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_DOWN : GTK_ARROW_RIGHT,
range->layout->grab_location == MOUSE_STEPPER_D,
range->layout->mouse_location == MOUSE_STEPPER_D,
- &event->area);
+ &expose_area);
return FALSE;
}
{
/* we don't actually gtk_grab, since a button is down */
+ gtk_grab_add (GTK_WIDGET (range));
+
range->layout->grab_location = location;
range->layout->grab_button = button;
static void
range_grab_remove (GtkRange *range)
{
+ gtk_grab_remove (GTK_WIDGET (range));
+
range->layout->grab_location = MOUSE_OUTSIDE;
range->layout->grab_button = 0;
static GtkScrollType
range_get_scroll_for_grab (GtkRange *range)
-{
+{
+ gboolean invert;
+
+ invert = should_invert (range);
switch (range->layout->grab_location)
{
/* Backward stepper */
switch (range->layout->grab_button)
{
case 1:
- return GTK_SCROLL_STEP_BACKWARD;
+ return invert ? GTK_SCROLL_STEP_FORWARD : GTK_SCROLL_STEP_BACKWARD;
break;
case 2:
- return GTK_SCROLL_PAGE_BACKWARD;
+ return invert ? GTK_SCROLL_PAGE_FORWARD : GTK_SCROLL_PAGE_BACKWARD;
break;
case 3:
- return GTK_SCROLL_START;
+ return invert ? GTK_SCROLL_END : GTK_SCROLL_START;
break;
}
break;
switch (range->layout->grab_button)
{
case 1:
- return GTK_SCROLL_STEP_FORWARD;
+ return invert ? GTK_SCROLL_STEP_BACKWARD : GTK_SCROLL_STEP_FORWARD;
break;
case 2:
- return GTK_SCROLL_PAGE_FORWARD;
+ return invert ? GTK_SCROLL_PAGE_BACKWARD : GTK_SCROLL_PAGE_FORWARD;
break;
case 3:
- return GTK_SCROLL_END;
+ return invert ? GTK_SCROLL_START : GTK_SCROLL_END;
break;
- }
+ }
break;
/* In the trough */
case MOUSE_TROUGH:
{
if (range->trough_click_forward)
- {
- return range->layout->grab_button == 3
- ? GTK_SCROLL_PAGE_FORWARD : GTK_SCROLL_STEP_FORWARD;
- }
+ return GTK_SCROLL_PAGE_FORWARD;
else
- {
- return range->layout->grab_button == 3
- ? GTK_SCROLL_PAGE_BACKWARD : GTK_SCROLL_STEP_BACKWARD;
- }
+ return GTK_SCROLL_PAGE_BACKWARD;
}
break;
gtk_range_button_press (GtkWidget *widget,
GdkEventButton *event)
{
- GtkRange *range;
-
- g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- range = GTK_RANGE (widget);
+ GtkRange *range = GTK_RANGE (widget);
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
gtk_widget_queue_draw (widget);
if (range->layout->mouse_location == MOUSE_TROUGH &&
- (event->button == 1 || event->button == 3))
+ event->button == 1)
{
- /* button 1 steps by step increment, as with button 1 on a stepper,
- * button 3 steps by page increment, as with button 2 on a stepper
+ /* button 1 steps by page increment, as with button 2 on a stepper
*/
GtkScrollType scroll;
gdouble click_value;
stepper_area = get_area (range, range->layout->mouse_location);
gtk_widget_queue_draw_area (widget,
- stepper_area->x,
- stepper_area->y,
+ widget->allocation.x + stepper_area->x,
+ widget->allocation.y + stepper_area->y,
stepper_area->width,
stepper_area->height);
gint delta;
gint c;
gdouble new_value;
-
+ gboolean handled;
+
if (range->orientation == GTK_ORIENTATION_VERTICAL)
delta = mouse_y - range->slide_initial_coordinate;
else
new_value = coord_to_value (range, c);
- gtk_range_internal_set_value (range, new_value);
+ g_signal_emit (range, signals[CHANGE_VALUE], 0, GTK_SCROLL_JUMP, new_value,
+ &handled);
+}
+
+static void stop_scrolling (GtkRange *range)
+{
+ range_grab_remove (range);
+ 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 gint
gtk_range_button_release (GtkWidget *widget,
GdkEventButton *event)
{
- GtkRange *range;
-
- g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+ GtkRange *range = GTK_RANGE (widget);
- range = GTK_RANGE (widget);
-
- range->layout->mouse_x = event->x;
- range->layout->mouse_y = event->y;
+ if (event->window == range->event_window)
+ {
+ range->layout->mouse_x = event->x;
+ range->layout->mouse_y = event->y;
+ }
+ else
+ {
+ gdk_window_get_pointer (range->event_window,
+ &range->layout->mouse_x,
+ &range->layout->mouse_y,
+ NULL);
+ }
if (range->layout->grab_button == event->button)
{
- GtkScrollType scroll;
- MouseLocation grab_location;
-
- grab_location = range->layout->grab_location;
+ if (range->layout->grab_location == MOUSE_SLIDER)
+ update_slider_position (range, range->layout->mouse_x, range->layout->mouse_y);
- scroll = range_get_scroll_for_grab (range);
-
- range_grab_remove (range);
- gtk_range_remove_step_timer (range);
-
- /* We only do the move if we're still on top of the button at
- * release
- */
- if (grab_location == range->layout->mouse_location &&
- scroll != GTK_SCROLL_NONE)
- {
- gtk_range_scroll (range, scroll);
- }
-
- if (grab_location == MOUSE_SLIDER)
- update_slider_position (range, event->x, event->y);
-
- /* 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 (widget);
+ stop_scrolling (range);
return TRUE;
}
return FALSE;
}
+/**
+ * _gtk_range_get_wheel_delta:
+ * @range: a #GtkRange
+ * @direction: A #GdkScrollDirection
+ *
+ * Returns a good step value for the mouse wheel.
+ *
+ * Return value: A good step value for the mouse wheel.
+ *
+ * Since: 2.4
+ **/
+gdouble
+_gtk_range_get_wheel_delta (GtkRange *range,
+ GdkScrollDirection direction)
+{
+ GtkAdjustment *adj = range->adjustment;
+ gdouble delta;
+
+ if (GTK_IS_SCROLLBAR (range))
+ delta = pow (adj->page_size, 2.0 / 3.0);
+ else
+ delta = adj->step_increment * 2;
+
+ if (direction == GDK_SCROLL_UP ||
+ direction == GDK_SCROLL_LEFT)
+ delta = - delta;
+
+ if (range->inverted)
+ delta = - delta;
+
+ return delta;
+}
+
static gint
gtk_range_scroll_event (GtkWidget *widget,
GdkEventScroll *event)
{
- GtkRange *range;
-
- g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- range = GTK_RANGE (widget);
+ GtkRange *range = GTK_RANGE (widget);
if (GTK_WIDGET_REALIZED (range))
{
GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
- gdouble new_value = adj->value + ((event->direction == GDK_SCROLL_UP ||
- event->direction == GDK_SCROLL_LEFT) ?
- -adj->page_increment / 2:
- adj->page_increment / 2);
+ gdouble delta;
+ gboolean handled;
- gtk_range_internal_set_value (range, new_value);
+ delta = _gtk_range_get_wheel_delta (range, event->direction);
+ g_signal_emit (range, signals[CHANGE_VALUE], 0,
+ GTK_SCROLL_JUMP, adj->value + delta,
+ &handled);
+
/* Policy DELAYED makes sense with scroll events,
* but DISCONTINUOUS doesn't, so we update immediately
- * for DISCONTINOUS
+ * for DISCONTINUOUS
*/
if (range->update_policy == GTK_UPDATE_DISCONTINUOUS)
gtk_range_update_value (range);
GtkRange *range;
gint x, y;
- g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
range = GTK_RANGE (widget);
- gdk_window_get_pointer (widget->window, &x, &y, NULL);
+ gdk_window_get_pointer (range->event_window, &x, &y, NULL);
range->layout->mouse_x = x;
range->layout->mouse_y = y;
gtk_range_enter_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
- GtkRange *range;
-
- g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- range = GTK_RANGE (widget);
+ GtkRange *range = GTK_RANGE (widget);
range->layout->mouse_x = event->x;
range->layout->mouse_y = event->y;
gtk_range_leave_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
- GtkRange *range;
-
- g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- range = GTK_RANGE (widget);
+ GtkRange *range = GTK_RANGE (widget);
range->layout->mouse_x = -1;
range->layout->mouse_y = -1;
}
static void
-gtk_range_adjustment_changed (GtkAdjustment *adjustment,
- gpointer data)
+gtk_range_grab_notify (GtkWidget *widget,
+ gboolean was_grabbed)
{
- GtkRange *range;
+ if (!was_grabbed)
+ stop_scrolling (GTK_RANGE (widget));
+}
- g_return_if_fail (adjustment != NULL);
- g_return_if_fail (data != NULL);
+static void
+gtk_range_state_changed (GtkWidget *widget,
+ GtkStateType previous_state)
+{
+ if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ stop_scrolling (GTK_RANGE (widget));
+}
- range = GTK_RANGE (data);
+static void
+gtk_range_adjustment_changed (GtkAdjustment *adjustment,
+ gpointer data)
+{
+ GtkRange *range = GTK_RANGE (data);
range->need_recalc = TRUE;
gtk_widget_queue_draw (GTK_WIDGET (range));
gtk_range_adjustment_value_changed (GtkAdjustment *adjustment,
gpointer data)
{
- GtkRange *range;
-
- g_return_if_fail (adjustment != NULL);
- g_return_if_fail (data != NULL);
-
- range = GTK_RANGE (data);
+ GtkRange *range = GTK_RANGE (data);
range->need_recalc = TRUE;
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, TRUE);
+ gdk_window_process_updates (GTK_WIDGET (range)->window, FALSE);
/* Note that we don't round off to range->round_digits here.
* that's because it's really broken to change a value
* will enforce on the adjustment.
*/
- g_signal_emit (G_OBJECT (range), signals[VALUE_CHANGED], 0);
+ g_signal_emit (range, signals[VALUE_CHANGED], 0);
}
static void
gtk_range_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
- GtkRange *range;
-
- g_return_if_fail (GTK_IS_RANGE (widget));
-
- range = GTK_RANGE (widget);
+ GtkRange *range = GTK_RANGE (widget);
range->need_recalc = TRUE;
step_back (GtkRange *range)
{
gdouble newval;
+ gboolean handled;
newval = range->adjustment->value - range->adjustment->step_increment;
- gtk_range_internal_set_value (range, newval);
+ g_signal_emit (range, signals[CHANGE_VALUE], 0,
+ GTK_SCROLL_STEP_BACKWARD, newval, &handled);
}
static void
step_forward (GtkRange *range)
{
gdouble newval;
+ gboolean handled;
newval = range->adjustment->value + range->adjustment->step_increment;
-
- gtk_range_internal_set_value (range, newval);
+ g_signal_emit (range, signals[CHANGE_VALUE], 0,
+ GTK_SCROLL_STEP_FORWARD, newval, &handled);
}
page_back (GtkRange *range)
{
gdouble newval;
+ gboolean handled;
newval = range->adjustment->value - range->adjustment->page_increment;
- gtk_range_internal_set_value (range, newval);
+ g_signal_emit (range, signals[CHANGE_VALUE], 0,
+ GTK_SCROLL_PAGE_BACKWARD, newval, &handled);
}
static void
page_forward (GtkRange *range)
{
gdouble newval;
+ gboolean handled;
newval = range->adjustment->value + range->adjustment->page_increment;
+ g_signal_emit (range, signals[CHANGE_VALUE], 0,
+ GTK_SCROLL_PAGE_FORWARD, newval, &handled);
+}
+
+static void
+scroll_begin (GtkRange *range)
+{
+ gboolean handled;
+ g_signal_emit (range, signals[CHANGE_VALUE], 0,
+ GTK_SCROLL_START, range->adjustment->lower,
+ &handled);
+}
+
+static void
+scroll_end (GtkRange *range)
+{
+ gdouble newval;
+ gboolean handled;
- gtk_range_internal_set_value (range, newval);
+ newval = range->adjustment->upper - range->adjustment->page_size;
+ g_signal_emit (range, signals[CHANGE_VALUE], 0, GTK_SCROLL_END, newval,
+ &handled);
}
static void
break;
case GTK_SCROLL_START:
- gtk_range_internal_set_value (range,
- range->adjustment->lower);
+ scroll_begin (range);
break;
case GTK_SCROLL_END:
- gtk_range_internal_set_value (range,
- range->adjustment->upper - range->adjustment->page_size);
+ scroll_end (range);
break;
case GTK_SCROLL_JUMP:
/* Policy DELAYED makes sense with key events,
* but DISCONTINUOUS doesn't, so we update immediately
- * for DISCONTINOUS
+ * for DISCONTINUOUS
*/
if (range->update_policy == GTK_UPDATE_DISCONTINUOUS)
gtk_range_update_value (range);
gint *slider_width,
gint *stepper_size,
gint *trough_border,
- gint *stepper_spacing)
+ gint *stepper_spacing,
+ gint *arrow_displacement_x,
+ gint *arrow_displacement_y)
{
GtkWidget *widget = GTK_WIDGET (range);
gint tmp_slider_width, tmp_stepper_size, tmp_trough_border, tmp_stepper_spacing;
+ gint tmp_arrow_displacement_x, tmp_arrow_displacement_y;
gtk_widget_style_get (widget,
"slider_width", &tmp_slider_width,
"trough_border", &tmp_trough_border,
"stepper_size", &tmp_stepper_size,
"stepper_spacing", &tmp_stepper_spacing,
+ "arrow_displacement_x", &tmp_arrow_displacement_x,
+ "arrow_displacement_y", &tmp_arrow_displacement_y,
NULL);
+ if (GTK_WIDGET_CAN_FOCUS (range))
+ {
+ gint focus_line_width;
+ gint focus_padding;
+
+ gtk_widget_style_get (GTK_WIDGET (range),
+ "focus-line-width", &focus_line_width,
+ "focus-padding", &focus_padding,
+ NULL);
+
+ tmp_trough_border += focus_line_width + focus_padding;
+ }
+
if (slider_width)
*slider_width = tmp_slider_width;
if (stepper_spacing)
*stepper_spacing = tmp_stepper_spacing;
+
+ if (arrow_displacement_x)
+ *arrow_displacement_x = tmp_arrow_displacement_x;
+
+ if (arrow_displacement_y)
+ *arrow_displacement_y = tmp_arrow_displacement_y;
}
#define POINT_IN_RECT(xcoord, ycoord, rect) \
{
gint slider_length;
gint n_steppers;
-
+
border->left = 0;
border->right = 0;
border->top = 0;
layout = range->layout;
gtk_range_get_props (range,
- &slider_width, &stepper_size, &trough_border, &stepper_spacing);
+ &slider_width, &stepper_size, &trough_border, &stepper_spacing,
+ NULL, NULL);
gtk_range_calc_request (range,
slider_width, stepper_size, trough_border, stepper_spacing,
/* slider height is the fraction (page_size /
* total_adjustment_range) times the trough height in pixels
*/
- height = ((bottom - top) * (range->adjustment->page_size /
- (range->adjustment->upper - range->adjustment->lower)));
+
+ if (range->adjustment->upper - range->adjustment->lower != 0)
+ height = ((bottom - top) * (range->adjustment->page_size /
+ (range->adjustment->upper - range->adjustment->lower)));
+ else
+ height = range->min_slider_size;
if (height < range->min_slider_size ||
range->slider_size_fixed)
y = top;
- y += (bottom - top - height) * ((adjustment_value - range->adjustment->lower) /
- (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size));
+ if (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size != 0)
+ y += (bottom - top - height) * ((adjustment_value - range->adjustment->lower) /
+ (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size));
y = CLAMP (y, top, bottom);
/* slider width is the fraction (page_size /
* total_adjustment_range) times the trough width in pixels
*/
- width = ((right - left) * (range->adjustment->page_size /
+
+ if (range->adjustment->upper - range->adjustment->lower != 0)
+ width = ((right - left) * (range->adjustment->page_size /
(range->adjustment->upper - range->adjustment->lower)));
+ else
+ width = range->min_slider_size;
if (width < range->min_slider_size ||
range->slider_size_fixed)
x = left;
- x += (right - left - width) * ((adjustment_value - range->adjustment->lower) /
- (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size));
+ if (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size != 0)
+ x += (right - left - width) * ((adjustment_value - range->adjustment->lower) /
+ (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size));
x = CLAMP (x, left, right);
return NULL;
}
-static void
-gtk_range_internal_set_value (GtkRange *range,
- gdouble value)
+static gboolean
+gtk_range_real_change_value (GtkRange *range,
+ GtkScrollType scroll,
+ gdouble value)
{
+ /* potentially adjust the bounds _before we clamp */
+ g_signal_emit (range, signals[ADJUST_BOUNDS], 0, value);
+
value = CLAMP (value, range->adjustment->lower,
(range->adjustment->upper - range->adjustment->page_size));
if (range->round_digits >= 0)
{
- char buffer[128];
+ gdouble power;
+ gint i;
- /* This is just so darn lame. */
- g_snprintf (buffer, 128, "%0.*f",
- range->round_digits, value);
- sscanf (buffer, "%lf", &value);
+ i = range->round_digits;
+ power = 1;
+ while (i--)
+ power *= 10;
+
+ value = floor ((value * power) + 0.5) / power;
}
if (range->adjustment->value != value)
break;
}
}
+ return FALSE;
}
static void
initial_timeout,
range);
range->timer->step = step;
+
+ gtk_range_scroll (range, range->timer->step);
}
static void
projects / ~andy / gtk / blobdiff