X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkscale.c;h=a69ae8403624cd23b0b2345da1f35f3c3d03045b;hb=b3ba85a01c71067fbe4c99bee318424d767f12cb;hp=9e92d9cbd376b14f241c0d4a63c41d2cbe1dc74b;hpb=1fe7d3cefd1aeabd6d8cab2a68673bb1f7876988;p=~andy%2Fgtk diff --git a/gtk/gtkscale.c b/gtk/gtkscale.c index 9e92d9cbd..a69ae8403 100644 --- a/gtk/gtkscale.c +++ b/gtk/gtkscale.c @@ -30,17 +30,45 @@ #include #include -#include "gdk/gdkkeysyms.h" #include "gtkscale.h" #include "gtkiconfactory.h" #include "gtkicontheme.h" #include "gtkmarshalers.h" #include "gtkbindings.h" +#include "gtkorientable.h" +#include "gtktypebuiltins.h" #include "gtkprivate.h" #include "gtkintl.h" #include "gtkbuildable.h" #include "gtkbuilderprivate.h" -#include "gtkalias.h" + + +/** + * SECTION:gtkscale + * @Short_description: Base class for GtkHScale and GtkVScale + * @Title: GtkScale + * + * A GtkScale is a slider control used to select a numeric value. + * To use it, you'll probably want to investigate the methods on + * its base class, #GtkRange, in addition to the methods for GtkScale itself. + * To set the value of a scale, you would normally use gtk_range_set_value(). + * To detect changes to the value, you would normally use the + * #GtkRange::value-changed signal. + * + * Note that using the same upper and lower bounds for the #GtkScale (through + * the #GtkRange methods) will hide the slider itself. This is useful for + * applications that want to show an undeterminate value on the scale, without + * changing the layout of the application (such as movie or music players). + * + * GtkScale as GtkBuildable + * GtkScale supports a custom <marks> element, which + * can contain multiple <mark> elements. The "value" and "position" + * attributes have the same meaning as gtk_scale_add_mark() parameters of the + * same name. If the element is not empty, its content is taken as the markup + * to show at the mark. It can be translated with the usual "translatable and + * "context" attributes. + * + */ #define MAX_DIGITS (64) /* don't change this, @@ -49,12 +77,21 @@ * unrelated code portions otherwise */ -#define GTK_SCALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_SCALE, GtkScalePrivate)) - -typedef struct _GtkScalePrivate GtkScalePrivate; typedef struct _GtkScaleMark GtkScaleMark; +struct _GtkScalePrivate +{ + PangoLayout *layout; + + GSList *marks; + + gint digits; + + guint draw_value : 1; + guint value_pos : 2; +}; + struct _GtkScaleMark { gdouble value; @@ -62,12 +99,6 @@ struct _GtkScaleMark GtkPositionType position; }; -struct _GtkScalePrivate -{ - PangoLayout *layout; - GSList *marks; -}; - enum { PROP_0, PROP_DIGITS, @@ -90,10 +121,13 @@ static void gtk_scale_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); -static void gtk_scale_size_request (GtkWidget *widget, - GtkRequisition *requisition); -static void gtk_scale_style_set (GtkWidget *widget, - GtkStyle *previous); +static void gtk_scale_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural); +static void gtk_scale_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural); +static void gtk_scale_style_updated (GtkWidget *widget); static void gtk_scale_get_range_border (GtkRange *range, GtkBorder *border); static void gtk_scale_get_mark_label_size (GtkScale *scale, @@ -107,8 +141,8 @@ static void gtk_scale_get_mark_label_size (GtkScale *scale, static void gtk_scale_finalize (GObject *object); static void gtk_scale_screen_changed (GtkWidget *widget, GdkScreen *old_screen); -static gboolean gtk_scale_expose (GtkWidget *widget, - GdkEventExpose *event); +static gboolean gtk_scale_draw (GtkWidget *widget, + cairo_t *cr); static void gtk_scale_real_get_layout_offsets (GtkScale *scale, gint *x, gint *y); @@ -126,9 +160,9 @@ static void gtk_scale_buildable_custom_finished (GtkBuildable *buildable, gpointer user_data); -G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkScale, gtk_scale, GTK_TYPE_RANGE, - G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, - gtk_scale_buildable_interface_init)) +G_DEFINE_TYPE_WITH_CODE (GtkScale, gtk_scale, GTK_TYPE_RANGE, + G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, + gtk_scale_buildable_interface_init)) static gboolean @@ -169,10 +203,11 @@ gtk_scale_class_init (GtkScaleClass *class) gobject_class->get_property = gtk_scale_get_property; gobject_class->finalize = gtk_scale_finalize; - widget_class->style_set = gtk_scale_style_set; + widget_class->style_updated = gtk_scale_style_updated; widget_class->screen_changed = gtk_scale_screen_changed; - widget_class->expose_event = gtk_scale_expose; - widget_class->size_request = gtk_scale_size_request; + widget_class->draw = gtk_scale_draw; + widget_class->get_preferred_width = gtk_scale_get_preferred_width; + widget_class->get_preferred_height = gtk_scale_get_preferred_height; range_class->slider_detail = "Xscale"; range_class->get_range_border = gtk_scale_get_range_border; @@ -263,116 +298,116 @@ gtk_scale_class_init (GtkScaleClass *class) binding_set = gtk_binding_set_by_class (class); - add_slider_binding (binding_set, GDK_Left, 0, + add_slider_binding (binding_set, GDK_KEY_Left, 0, GTK_SCROLL_STEP_LEFT); - add_slider_binding (binding_set, GDK_Left, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT); - add_slider_binding (binding_set, GDK_KP_Left, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Left, 0, GTK_SCROLL_STEP_LEFT); - add_slider_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT); - add_slider_binding (binding_set, GDK_Right, 0, + add_slider_binding (binding_set, GDK_KEY_Right, 0, GTK_SCROLL_STEP_RIGHT); - add_slider_binding (binding_set, GDK_Right, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT); - add_slider_binding (binding_set, GDK_KP_Right, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Right, 0, GTK_SCROLL_STEP_RIGHT); - add_slider_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT); - add_slider_binding (binding_set, GDK_Up, 0, + add_slider_binding (binding_set, GDK_KEY_Up, 0, GTK_SCROLL_STEP_UP); - add_slider_binding (binding_set, GDK_Up, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP); - add_slider_binding (binding_set, GDK_KP_Up, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Up, 0, GTK_SCROLL_STEP_UP); - add_slider_binding (binding_set, GDK_KP_Up, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP); - add_slider_binding (binding_set, GDK_Down, 0, + add_slider_binding (binding_set, GDK_KEY_Down, 0, GTK_SCROLL_STEP_DOWN); - add_slider_binding (binding_set, GDK_Down, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN); - add_slider_binding (binding_set, GDK_KP_Down, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Down, 0, GTK_SCROLL_STEP_DOWN); - add_slider_binding (binding_set, GDK_KP_Down, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN); - add_slider_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_Page_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT); - add_slider_binding (binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Page_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT); - add_slider_binding (binding_set, GDK_Page_Up, 0, + add_slider_binding (binding_set, GDK_KEY_Page_Up, 0, GTK_SCROLL_PAGE_UP); - add_slider_binding (binding_set, GDK_KP_Page_Up, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Page_Up, 0, GTK_SCROLL_PAGE_UP); - add_slider_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT); - add_slider_binding (binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT); - add_slider_binding (binding_set, GDK_Page_Down, 0, + add_slider_binding (binding_set, GDK_KEY_Page_Down, 0, GTK_SCROLL_PAGE_DOWN); - add_slider_binding (binding_set, GDK_KP_Page_Down, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Page_Down, 0, GTK_SCROLL_PAGE_DOWN); /* Logical bindings (vs. visual bindings above) */ - add_slider_binding (binding_set, GDK_plus, 0, + add_slider_binding (binding_set, GDK_KEY_plus, 0, GTK_SCROLL_STEP_FORWARD); - add_slider_binding (binding_set, GDK_minus, 0, + add_slider_binding (binding_set, GDK_KEY_minus, 0, GTK_SCROLL_STEP_BACKWARD); - add_slider_binding (binding_set, GDK_plus, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_plus, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_FORWARD); - add_slider_binding (binding_set, GDK_minus, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_minus, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_BACKWARD); - add_slider_binding (binding_set, GDK_KP_Add, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Add, 0, GTK_SCROLL_STEP_FORWARD); - add_slider_binding (binding_set, GDK_KP_Subtract, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Subtract, 0, GTK_SCROLL_STEP_BACKWARD); - add_slider_binding (binding_set, GDK_KP_Add, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Add, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_FORWARD); - add_slider_binding (binding_set, GDK_KP_Subtract, GDK_CONTROL_MASK, + add_slider_binding (binding_set, GDK_KEY_KP_Subtract, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_BACKWARD); - add_slider_binding (binding_set, GDK_Home, 0, + add_slider_binding (binding_set, GDK_KEY_Home, 0, GTK_SCROLL_START); - add_slider_binding (binding_set, GDK_KP_Home, 0, + add_slider_binding (binding_set, GDK_KEY_KP_Home, 0, GTK_SCROLL_START); - add_slider_binding (binding_set, GDK_End, 0, + add_slider_binding (binding_set, GDK_KEY_End, 0, GTK_SCROLL_END); - add_slider_binding (binding_set, GDK_KP_End, 0, + add_slider_binding (binding_set, GDK_KEY_KP_End, 0, GTK_SCROLL_END); g_type_class_add_private (gobject_class, sizeof (GtkScalePrivate)); @@ -382,31 +417,41 @@ static void gtk_scale_orientation_notify (GtkRange *range, const GParamSpec *pspec) { - range->flippable = (range->orientation == GTK_ORIENTATION_HORIZONTAL); + GtkOrientation orientation; + + orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (range)); + gtk_range_set_flippable (range, + orientation == GTK_ORIENTATION_HORIZONTAL); } static void gtk_scale_init (GtkScale *scale) { + GtkScalePrivate *priv; GtkRange *range = GTK_RANGE (scale); + GtkStyleContext *context; + + scale->priv = G_TYPE_INSTANCE_GET_PRIVATE (scale, + GTK_TYPE_SCALE, + GtkScalePrivate); + priv = scale->priv; gtk_widget_set_can_focus (GTK_WIDGET (scale), TRUE); - range->slider_size_fixed = TRUE; - range->has_stepper_a = FALSE; - range->has_stepper_b = FALSE; - range->has_stepper_c = FALSE; - range->has_stepper_d = FALSE; + gtk_range_set_slider_size_fixed (range, TRUE); - scale->draw_value = TRUE; - scale->value_pos = GTK_POS_TOP; - scale->digits = 1; - range->round_digits = scale->digits; + priv->draw_value = TRUE; + priv->value_pos = GTK_POS_TOP; + priv->digits = 1; + gtk_range_set_round_digits (range, priv->digits); gtk_scale_orientation_notify (range, NULL); g_signal_connect (scale, "notify::orientation", G_CALLBACK (gtk_scale_orientation_notify), NULL); + + context = gtk_widget_get_style_context (GTK_WIDGET (scale)); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE); } static void @@ -442,20 +487,19 @@ gtk_scale_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GtkScale *scale; - - scale = GTK_SCALE (object); + GtkScale *scale = GTK_SCALE (object); + GtkScalePrivate *priv = scale->priv; switch (prop_id) { case PROP_DIGITS: - g_value_set_int (value, scale->digits); + g_value_set_int (value, priv->digits); break; case PROP_DRAW_VALUE: - g_value_set_boolean (value, scale->draw_value); + g_value_set_boolean (value, priv->draw_value); break; case PROP_VALUE_POS: - g_value_set_enum (value, scale->value_pos); + g_value_set_enum (value, priv->value_pos); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -463,18 +507,17 @@ gtk_scale_get_property (GObject *object, } } -#if 0 /** * gtk_scale_new: * @orientation: the scale's orientation. - * @adjustment: the #GtkAdjustment which sets the range of the scale, or - * %NULL to create a new adjustment. + * @adjustment: (allow-none): the #GtkAdjustment which sets the range + * of the scale, or %NULL to create a new adjustment. * * Creates a new #GtkScale. * * Return value: a new #GtkScale * - * Since: 2.16 + * Since: 3.0 **/ GtkWidget * gtk_scale_new (GtkOrientation orientation, @@ -508,15 +551,15 @@ gtk_scale_new (GtkOrientation orientation, * * Return value: a new #GtkScale * - * Since: 2.16 - **/ + * Since: 3.0 + */ GtkWidget * gtk_scale_new_with_range (GtkOrientation orientation, gdouble min, gdouble max, gdouble step) { - GtkObject *adj; + GtkAdjustment *adj; gint digits; g_return_val_if_fail (min < max, NULL); @@ -541,14 +584,13 @@ gtk_scale_new_with_range (GtkOrientation orientation, "digits", digits, NULL); } -#endif /** * gtk_scale_set_digits: * @scale: a #GtkScale - * @digits: the number of decimal places to display, + * @digits: the number of decimal places to display, * e.g. use 1 to display 1.0, 2 to display 1.00, etc - * + * * Sets the number of decimal places that are displayed in the value. * Also causes the value of the adjustment to be rounded off to this * number of digits, so the retrieved value matches the value the user saw. @@ -557,20 +599,22 @@ void gtk_scale_set_digits (GtkScale *scale, gint digits) { + GtkScalePrivate *priv; GtkRange *range; - + g_return_if_fail (GTK_IS_SCALE (scale)); + priv = scale->priv; range = GTK_RANGE (scale); digits = CLAMP (digits, -1, MAX_DIGITS); - if (scale->digits != digits) + if (priv->digits != digits) { - scale->digits = digits; - if (scale->draw_value) - range->round_digits = digits; - + priv->digits = digits; + if (priv->draw_value) + gtk_range_set_round_digits (range, digits); + _gtk_scale_clear_layout (scale); gtk_widget_queue_resize (GTK_WIDGET (scale)); @@ -591,7 +635,7 @@ gtk_scale_get_digits (GtkScale *scale) { g_return_val_if_fail (GTK_IS_SCALE (scale), -1); - return scale->digits; + return scale->priv->digits; } /** @@ -606,17 +650,21 @@ void gtk_scale_set_draw_value (GtkScale *scale, gboolean draw_value) { + GtkScalePrivate *priv; + g_return_if_fail (GTK_IS_SCALE (scale)); + priv = scale->priv; + draw_value = draw_value != FALSE; - if (scale->draw_value != draw_value) + if (priv->draw_value != draw_value) { - scale->draw_value = draw_value; + priv->draw_value = draw_value; if (draw_value) - GTK_RANGE (scale)->round_digits = scale->digits; + gtk_range_set_round_digits (GTK_RANGE (scale), priv->digits); else - GTK_RANGE (scale)->round_digits = -1; + gtk_range_set_round_digits (GTK_RANGE (scale), -1); _gtk_scale_clear_layout (scale); @@ -640,7 +688,7 @@ gtk_scale_get_draw_value (GtkScale *scale) { g_return_val_if_fail (GTK_IS_SCALE (scale), FALSE); - return scale->draw_value; + return scale->priv->draw_value; } /** @@ -654,13 +702,16 @@ void gtk_scale_set_value_pos (GtkScale *scale, GtkPositionType pos) { + GtkScalePrivate *priv; GtkWidget *widget; g_return_if_fail (GTK_IS_SCALE (scale)); - if (scale->value_pos != pos) + priv = scale->priv; + + if (priv->value_pos != pos) { - scale->value_pos = pos; + priv->value_pos = pos; widget = GTK_WIDGET (scale); _gtk_scale_clear_layout (scale); @@ -684,7 +735,7 @@ gtk_scale_get_value_pos (GtkScale *scale) { g_return_val_if_fail (GTK_IS_SCALE (scale), 0); - return scale->value_pos; + return scale->priv->value_pos; } static void @@ -698,7 +749,7 @@ gtk_scale_get_range_border (GtkRange *range, widget = GTK_WIDGET (range); scale = GTK_SCALE (range); - priv = GTK_SCALE_GET_PRIVATE (scale); + priv = scale->priv; _gtk_scale_get_value_size (scale, &w, &h); @@ -707,12 +758,12 @@ gtk_scale_get_range_border (GtkRange *range, border->top = 0; border->bottom = 0; - if (scale->draw_value) + if (priv->draw_value) { gint value_spacing; gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL); - switch (scale->value_pos) + switch (priv->value_pos) { case GTK_POS_LEFT: border->left += w + value_spacing; @@ -741,7 +792,7 @@ gtk_scale_get_range_border (GtkRange *range, NULL); - if (GTK_RANGE (scale)->orientation == GTK_ORIENTATION_HORIZONTAL) + if (gtk_orientable_get_orientation (GTK_ORIENTABLE (scale)) == GTK_ORIENTATION_HORIZONTAL) { gtk_scale_get_mark_label_size (scale, GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2); if (n1 > 0) @@ -766,12 +817,12 @@ _gtk_scale_get_value_size (GtkScale *scale, gint *width, gint *height) { + GtkScalePrivate *priv = scale->priv; GtkRange *range; - g_return_if_fail (GTK_IS_SCALE (scale)); - - if (scale->draw_value) + if (priv->draw_value) { + GtkAdjustment *adjustment; PangoLayout *layout; PangoRectangle logical_rect; gchar *txt; @@ -779,8 +830,9 @@ _gtk_scale_get_value_size (GtkScale *scale, range = GTK_RANGE (scale); layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL); + adjustment = gtk_range_get_adjustment (range); - txt = _gtk_scale_format_value (scale, range->adjustment->lower); + txt = _gtk_scale_format_value (scale, gtk_adjustment_get_lower (adjustment)); pango_layout_set_text (layout, txt, -1); g_free (txt); @@ -791,7 +843,7 @@ _gtk_scale_get_value_size (GtkScale *scale, if (height) *height = logical_rect.height; - txt = _gtk_scale_format_value (scale, range->adjustment->upper); + txt = _gtk_scale_format_value (scale, gtk_adjustment_get_upper (adjustment)); pango_layout_set_text (layout, txt, -1); g_free (txt); @@ -824,7 +876,7 @@ gtk_scale_get_mark_label_size (GtkScale *scale, gint *width2, gint *height2) { - GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale); + GtkScalePrivate *priv = scale->priv; PangoLayout *layout; PangoRectangle logical_rect; GSList *m; @@ -840,7 +892,7 @@ gtk_scale_get_mark_label_size (GtkScale *scale, { GtkScaleMark *mark = m->data; - if (mark->markup) + if (mark->markup && *mark->markup) { pango_layout_set_markup (layout, mark->markup, -1); pango_layout_get_pixel_extents (layout, NULL, &logical_rect); @@ -872,8 +924,7 @@ gtk_scale_get_mark_label_size (GtkScale *scale, } static void -gtk_scale_style_set (GtkWidget *widget, - GtkStyle *previous) +gtk_scale_style_updated (GtkWidget *widget) { gint slider_length; GtkRange *range; @@ -883,12 +934,12 @@ gtk_scale_style_set (GtkWidget *widget, gtk_widget_style_get (widget, "slider-length", &slider_length, NULL); - - range->min_slider_size = slider_length; - + + gtk_range_set_min_slider_size (range, slider_length); + _gtk_scale_clear_layout (GTK_SCALE (widget)); - GTK_WIDGET_CLASS (gtk_scale_parent_class)->style_set (widget, previous); + GTK_WIDGET_CLASS (gtk_scale_parent_class)->style_updated (widget); } static void @@ -899,32 +950,54 @@ gtk_scale_screen_changed (GtkWidget *widget, } static void -gtk_scale_size_request (GtkWidget *widget, - GtkRequisition *requisition) +gtk_scale_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural) { - GtkRange *range = GTK_RANGE (widget); - gint n1, w1, h1, n2, w2, h2; - gint slider_length; - - GTK_WIDGET_CLASS (gtk_scale_parent_class)->size_request (widget, requisition); + GTK_WIDGET_CLASS (gtk_scale_parent_class)->get_preferred_width (widget, minimum, natural); - gtk_widget_style_get (widget, "slider-length", &slider_length, NULL); + if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL) + { + gint n1, w1, h1, n2, w2, h2; + gint slider_length; + gint w; + gtk_widget_style_get (widget, "slider-length", &slider_length, NULL); - if (range->orientation == GTK_ORIENTATION_HORIZONTAL) - { gtk_scale_get_mark_label_size (GTK_SCALE (widget), GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2); w1 = (n1 - 1) * w1 + MAX (w1, slider_length); w2 = (n2 - 1) * w2 + MAX (w2, slider_length); - requisition->width = MAX (requisition->width, MAX (w1, w2)); + w = MAX (w1, w2); + + *minimum = MAX (*minimum, w); + *natural = MAX (*natural, w); } - else +} + +static void +gtk_scale_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + GTK_WIDGET_CLASS (gtk_scale_parent_class)->get_preferred_height (widget, minimum, natural); + + + if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_VERTICAL) { + gint n1, w1, h1, n2, w2, h2; + gint slider_length; + gint h; + + gtk_widget_style_get (widget, "slider-length", &slider_length, NULL); + gtk_scale_get_mark_label_size (GTK_SCALE (widget), GTK_POS_LEFT, &n1, &w1, &h1, &n2, &w2, &h2); h1 = (n1 - 1) * h1 + MAX (h1, slider_length); h2 = (n2 - 1) * h1 + MAX (h2, slider_length); - requisition->height = MAX (requisition->height, MAX (h1, h2)); + h = MAX (h1, h2); + + *minimum = MAX (*minimum, h); + *natural = MAX (*natural, h); } } @@ -935,6 +1008,7 @@ find_next_pos (GtkWidget *widget, GtkPositionType pos, gint match) { + GtkAllocation allocation; GSList *m; gint i; @@ -946,17 +1020,22 @@ find_next_pos (GtkWidget *widget, return marks[i]; } - return widget->allocation.width; + gtk_widget_get_allocation (widget, &allocation); + if (pos == GTK_POS_TOP || pos == GTK_POS_BOTTOM) + return allocation.width; + else + return allocation.height; } static gboolean -gtk_scale_expose (GtkWidget *widget, - GdkEventExpose *event) +gtk_scale_draw (GtkWidget *widget, + cairo_t *cr) { GtkScale *scale = GTK_SCALE (widget); - GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale); + GtkScalePrivate *priv = scale->priv; GtkRange *range = GTK_RANGE (scale); - GtkStateType state_type; + GtkStateFlags state = 0; + GtkStyleContext *context; gint n_marks; gint *marks; gint focus_padding; @@ -964,6 +1043,7 @@ gtk_scale_expose (GtkWidget *widget, gint value_spacing; gint min_sep = 4; + context = gtk_widget_get_style_context (widget); gtk_widget_style_get (widget, "focus-padding", &focus_padding, "slider-width", &slider_width, @@ -973,14 +1053,15 @@ gtk_scale_expose (GtkWidget *widget, /* We need to chain up _first_ so the various geometry members of * GtkRange struct are updated. */ - GTK_WIDGET_CLASS (gtk_scale_parent_class)->expose_event (widget, event); + GTK_WIDGET_CLASS (gtk_scale_parent_class)->draw (widget, cr); - state_type = GTK_STATE_NORMAL; if (!gtk_widget_is_sensitive (widget)) - state_type = GTK_STATE_INSENSITIVE; + state |= GTK_STATE_FLAG_INSENSITIVE; if (priv->marks) { + GtkOrientation orientation; + GdkRectangle range_rect; gint i; gint x1, x2, x3, y1, y2, y3; PangoLayout *layout; @@ -989,37 +1070,41 @@ gtk_scale_expose (GtkWidget *widget, gint min_pos_before, min_pos_after; gint min_pos, max_pos; + orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (range)); n_marks = _gtk_range_get_stop_positions (range, &marks); layout = gtk_widget_create_pango_layout (widget, NULL); + gtk_range_get_range_rect (range, &range_rect); + + min_pos_before = min_pos_after = 0; - if (range->orientation == GTK_ORIENTATION_HORIZONTAL) - min_pos_before = min_pos_after = widget->allocation.x; - else - min_pos_before = min_pos_after = widget->allocation.y; for (m = priv->marks, i = 0; m; m = m->next, i++) { GtkScaleMark *mark = m->data; - - if (range->orientation == GTK_ORIENTATION_HORIZONTAL) + + if (orientation == GTK_ORIENTATION_HORIZONTAL) { - x1 = widget->allocation.x + marks[i]; + x1 = marks[i]; if (mark->position == GTK_POS_TOP) { - y1 = widget->allocation.y + range->range_rect.y; + y1 = range_rect.y; y2 = y1 - slider_width / 2; min_pos = min_pos_before; - max_pos = widget->allocation.x + find_next_pos (widget, m, marks + i, GTK_POS_TOP, 1) - min_sep; + max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP, 1) - min_sep; } else { - y1 = widget->allocation.y + range->range_rect.y + range->range_rect.height; + y1 = range_rect.y + range_rect.height; y2 = y1 + slider_width / 2; min_pos = min_pos_after; - max_pos = widget->allocation.x + find_next_pos (widget, m, marks + i, GTK_POS_TOP, 0) - min_sep; + max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP, 0) - min_sep; } - gtk_paint_vline (widget->style, widget->window, state_type, - NULL, widget, "scale-mark", y1, y2, x1); + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK); + gtk_style_context_set_state (context, state); + + gtk_render_line (context, cr, + x1, y1, x1, y2); if (mark->markup) { @@ -1031,8 +1116,8 @@ gtk_scale_expose (GtkWidget *widget, x3 = min_pos; if (x3 + logical_rect.width > max_pos) x3 = max_pos - logical_rect.width; - if (x3 < widget->allocation.x) - x3 = widget->allocation.x; + if (x3 < 0) + x3 = 0; if (mark->position == GTK_POS_TOP) { y3 = y2 - value_spacing - logical_rect.height; @@ -1044,44 +1129,49 @@ gtk_scale_expose (GtkWidget *widget, min_pos_after = x3 + logical_rect.width + min_sep; } - gtk_paint_layout (widget->style, widget->window, state_type, - FALSE, NULL, widget, "scale-mark", - x3, y3, layout); + gtk_render_layout (context, cr, + x3, y3, layout); } + + gtk_style_context_restore (context); } else { if (mark->position == GTK_POS_LEFT) { - x1 = widget->allocation.x + range->range_rect.x; - x2 = widget->allocation.x + range->range_rect.x - slider_width / 2; + x1 = range_rect.x; + x2 = range_rect.x - slider_width / 2; min_pos = min_pos_before; - max_pos = widget->allocation.y + find_next_pos (widget, m, marks + i, GTK_POS_LEFT, 1) - min_sep; + max_pos = find_next_pos (widget, m, marks + i, GTK_POS_LEFT, 1) - min_sep; } else { - x1 = widget->allocation.x + range->range_rect.x + range->range_rect.width; - x2 = widget->allocation.x + range->range_rect.x + range->range_rect.width + slider_width / 2; + x1 = range_rect.x + range_rect.width; + x2 = range_rect.x + range_rect.width + slider_width / 2; min_pos = min_pos_after; - max_pos = widget->allocation.y + find_next_pos (widget, m, marks + i, GTK_POS_LEFT, 0) - min_sep; + max_pos = find_next_pos (widget, m, marks + i, GTK_POS_LEFT, 0) - min_sep; } - y1 = widget->allocation.y + marks[i]; + y1 = marks[i]; - gtk_paint_hline (widget->style, widget->window, state_type, - NULL, widget, "range-mark", x1, x2, y1); + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK); + gtk_style_context_set_state (context, state); + + gtk_render_line (context, cr, + x1, y1, x2, y1); if (mark->markup) { pango_layout_set_markup (layout, mark->markup, -1); pango_layout_get_pixel_extents (layout, NULL, &logical_rect); - + y3 = y1 - logical_rect.height / 2; if (y3 < min_pos) y3 = min_pos; if (y3 + logical_rect.height > max_pos) y3 = max_pos - logical_rect.height; - if (y3 < widget->allocation.y) - y3 = widget->allocation.y; + if (y3 < 0) + y3 = 0; if (mark->position == GTK_POS_LEFT) { x3 = x2 - value_spacing - logical_rect.width; @@ -1093,10 +1183,11 @@ gtk_scale_expose (GtkWidget *widget, min_pos_after = y3 + logical_rect.height + min_sep; } - gtk_paint_layout (widget->style, widget->window, state_type, - FALSE, NULL, widget, "scale-mark", - x3, y3, layout); + gtk_render_layout (context, cr, + x3, y3, layout); } + + gtk_style_context_restore (context); } } @@ -1104,25 +1195,23 @@ gtk_scale_expose (GtkWidget *widget, g_free (marks); } - if (scale->draw_value) + if (priv->draw_value) { + GtkOrientation orientation; + GtkAllocation allocation; + PangoLayout *layout; gint x, y; + orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (range)); layout = gtk_scale_get_layout (scale); gtk_scale_get_layout_offsets (scale, &x, &y); + gtk_widget_get_allocation (widget, &allocation); - gtk_paint_layout (widget->style, - widget->window, - state_type, - FALSE, - NULL, - widget, - range->orientation == GTK_ORIENTATION_HORIZONTAL ? - "hscale" : "vscale", - x, y, - layout); - + gtk_render_layout (context, cr, + x - allocation.x, + y - allocation.y, + layout); } return FALSE; @@ -1133,10 +1222,14 @@ gtk_scale_real_get_layout_offsets (GtkScale *scale, gint *x, gint *y) { + GtkScalePrivate *priv = scale->priv; + GtkAllocation allocation; GtkWidget *widget = GTK_WIDGET (scale); GtkRange *range = GTK_RANGE (widget); + GdkRectangle range_rect; PangoLayout *layout = gtk_scale_get_layout (scale); PangoRectangle logical_rect; + gint slider_start, slider_end; gint value_spacing; if (!layout) @@ -1151,32 +1244,36 @@ gtk_scale_real_get_layout_offsets (GtkScale *scale, pango_layout_get_pixel_extents (layout, NULL, &logical_rect); - if (range->orientation == GTK_ORIENTATION_HORIZONTAL) + gtk_widget_get_allocation (widget, &allocation); + gtk_range_get_range_rect (range, &range_rect); + gtk_range_get_slider_range (range, + &slider_start, + &slider_end); + + if (gtk_orientable_get_orientation (GTK_ORIENTABLE (range)) == GTK_ORIENTATION_HORIZONTAL) { - switch (scale->value_pos) + switch (priv->value_pos) { case GTK_POS_LEFT: - *x = range->range_rect.x - value_spacing - logical_rect.width; - *y = range->range_rect.y + (range->range_rect.height - logical_rect.height) / 2; + *x = range_rect.x - value_spacing - logical_rect.width; + *y = range_rect.y + (range_rect.height - logical_rect.height) / 2; break; case GTK_POS_RIGHT: - *x = range->range_rect.x + range->range_rect.width + value_spacing; - *y = range->range_rect.y + (range->range_rect.height - logical_rect.height) / 2; + *x = range_rect.x + range_rect.width + value_spacing; + *y = range_rect.y + (range_rect.height - logical_rect.height) / 2; break; case GTK_POS_TOP: - *x = range->slider_start + - (range->slider_end - range->slider_start - logical_rect.width) / 2; - *x = CLAMP (*x, 0, widget->allocation.width - logical_rect.width); - *y = range->range_rect.y - logical_rect.height - value_spacing; + *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2; + *x = CLAMP (*x, 0, allocation.width - logical_rect.width); + *y = range_rect.y - logical_rect.height - value_spacing; break; case GTK_POS_BOTTOM: - *x = range->slider_start + - (range->slider_end - range->slider_start - logical_rect.width) / 2; - *x = CLAMP (*x, 0, widget->allocation.width - logical_rect.width); - *y = range->range_rect.y + range->range_rect.height + value_spacing; + *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2; + *x = CLAMP (*x, 0, allocation.width - logical_rect.width); + *y = range_rect.y + range_rect.height + value_spacing; break; default: @@ -1186,28 +1283,28 @@ gtk_scale_real_get_layout_offsets (GtkScale *scale, } else { - switch (scale->value_pos) + switch (priv->value_pos) { case GTK_POS_LEFT: - *x = range->range_rect.x - logical_rect.width - value_spacing; - *y = range->slider_start + (range->slider_end - range->slider_start - logical_rect.height) / 2; - *y = CLAMP (*y, 0, widget->allocation.height - logical_rect.height); + *x = range_rect.x - logical_rect.width - value_spacing; + *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2; + *y = CLAMP (*y, 0, allocation.height - logical_rect.height); break; case GTK_POS_RIGHT: - *x = range->range_rect.x + range->range_rect.width + value_spacing; - *y = range->slider_start + (range->slider_end - range->slider_start - logical_rect.height) / 2; - *y = CLAMP (*y, 0, widget->allocation.height - logical_rect.height); + *x = range_rect.x + range_rect.width + value_spacing; + *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2; + *y = CLAMP (*y, 0, allocation.height - logical_rect.height); break; case GTK_POS_TOP: - *x = range->range_rect.x + (range->range_rect.width - logical_rect.width) / 2; - *y = range->range_rect.y - logical_rect.height - value_spacing; + *x = range_rect.x + (range_rect.width - logical_rect.width) / 2; + *y = range_rect.y - logical_rect.height - value_spacing; break; case GTK_POS_BOTTOM: - *x = range->range_rect.x + (range->range_rect.width - logical_rect.width) / 2; - *y = range->range_rect.y + range->range_rect.height + value_spacing; + *x = range_rect.x + (range_rect.width - logical_rect.width) / 2; + *y = range_rect.y + range_rect.height + value_spacing; break; default: @@ -1215,8 +1312,8 @@ gtk_scale_real_get_layout_offsets (GtkScale *scale, } } - *x += widget->allocation.x; - *y += widget->allocation.y; + *x += allocation.x; + *y += allocation.y; } /** @@ -1233,6 +1330,7 @@ gchar* _gtk_scale_format_value (GtkScale *scale, gdouble value) { + GtkScalePrivate *priv = scale->priv; gchar *fmt = NULL; g_signal_emit (scale, @@ -1245,7 +1343,7 @@ _gtk_scale_format_value (GtkScale *scale, return fmt; else /* insert a LRM, to prevent -20 to come out as 20- in RTL locales */ - return g_strdup_printf ("\342\200\216%0.*f", scale->digits, value); + return g_strdup_printf ("\342\200\216%0.*f", priv->digits, value); } static void @@ -1263,33 +1361,35 @@ gtk_scale_finalize (GObject *object) * gtk_scale_get_layout: * @scale: A #GtkScale * - * Gets the #PangoLayout used to display the scale. - * The returned object is owned by the scale so does - * not need to be freed by the caller. + * Gets the #PangoLayout used to display the scale. The returned + * object is owned by the scale so does not need to be freed by + * the caller. + * + * Return value: (transfer none): the #PangoLayout for this scale, + * or %NULL if the #GtkScale:draw-value property is %FALSE. * - * Return value: the #PangoLayout for this scale, or %NULL - * if the #GtkScale:draw-value property is %FALSE. - * * Since: 2.4 */ PangoLayout * gtk_scale_get_layout (GtkScale *scale) { - GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale); + GtkScalePrivate *priv; gchar *txt; g_return_val_if_fail (GTK_IS_SCALE (scale), NULL); + priv = scale->priv; + if (!priv->layout) { - if (scale->draw_value) + if (priv->draw_value) priv->layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL); } - if (scale->draw_value) + if (priv->draw_value) { txt = _gtk_scale_format_value (scale, - GTK_RANGE (scale)->adjustment->value); + gtk_adjustment_get_value (gtk_range_get_adjustment (GTK_RANGE (scale)))); pango_layout_set_text (priv->layout, txt, -1); g_free (txt); } @@ -1300,8 +1400,8 @@ gtk_scale_get_layout (GtkScale *scale) /** * gtk_scale_get_layout_offsets: * @scale: a #GtkScale - * @x: (allow-none): location to store X offset of layout, or %NULL - * @y: (allow-none): location to store Y offset of layout, or %NULL + * @x: (out) (allow-none): location to store X offset of layout, or %NULL + * @y: (out) (allow-none): location to store Y offset of layout, or %NULL * * Obtains the coordinates where the scale will draw the * #PangoLayout representing the text in the scale. Remember @@ -1336,7 +1436,7 @@ gtk_scale_get_layout_offsets (GtkScale *scale, void _gtk_scale_clear_layout (GtkScale *scale) { - GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale); + GtkScalePrivate *priv = scale->priv; g_return_if_fail (GTK_IS_SCALE (scale)); @@ -1365,10 +1465,12 @@ gtk_scale_mark_free (GtkScaleMark *mark) void gtk_scale_clear_marks (GtkScale *scale) { - GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale); + GtkScalePrivate *priv; g_return_if_fail (GTK_IS_SCALE (scale)); + priv = scale->priv; + g_slist_foreach (priv->marks, (GFunc)gtk_scale_mark_free, NULL); g_slist_free (priv->marks); priv->marks = NULL; @@ -1418,12 +1520,16 @@ gtk_scale_add_mark (GtkScale *scale, GtkPositionType position, const gchar *markup) { - GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale); + GtkScalePrivate *priv; GtkScaleMark *mark; GSList *m; gdouble *values; gint n, i; + g_return_if_fail (GTK_IS_SCALE (scale)); + + priv = scale->priv; + mark = g_new (GtkScaleMark, 1); mark->value = value; mark->markup = g_strdup (markup); @@ -1680,6 +1786,3 @@ gtk_scale_buildable_custom_finished (GtkBuildable *buildable, g_slice_free (MarksSubparserData, marks_data); } } - -#define __GTK_SCALE_C__ -#include "gtkaliasdef.c"