/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 * Copyright (C) 2001 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  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 <math.h>

#include <stdlib.h>

#include "gdk/gdkkeysyms.h"

#include "gtkscale.h"

#include "gtkiconfactory.h"

#include "gtkicontheme.h"

#include "gtkmarshalers.h"

#include "gtkbindings.h"

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkbuildable.h"

#include "gtkbuilderprivate.h"

#include "gtkalias.h"

#define	MAX_DIGITS	(64)	/* don't change this,

				 * a) you don't need to and

				 * b) you might cause buffer owerflows in

				 *    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 _GtkScaleMark

{

  gdouble          value;

  gchar           *markup;

  GtkPositionType  position;

};

struct _GtkScalePrivate

{

  PangoLayout *layout;

  GSList      *marks;

};

enum {

  PROP_0,

  PROP_DIGITS,

  PROP_DRAW_VALUE,

  PROP_VALUE_POS

};

enum {

  FORMAT_VALUE,

  LAST_SIGNAL

};

static guint signals[LAST_SIGNAL];

static void     gtk_scale_set_property            (GObject        *object,

                                                   guint           prop_id,

                                                   const GValue   *value,

                                                   GParamSpec     *pspec);

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_range_border        (GtkRange       *range,

                                                   GtkBorder      *border);

static void     gtk_scale_get_mark_label_size     (GtkScale        *scale,

                                                   GtkPositionType  position,

                                                   gint            *count1,

                                                   gint            *width1,

                                                   gint            *height1,

                                                   gint            *count2,

                                                   gint            *width2,

                                                   gint            *height2);

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 void     gtk_scale_real_get_layout_offsets (GtkScale       *scale,

                                                   gint           *x,

                                                   gint           *y);

static void     gtk_scale_buildable_interface_init   (GtkBuildableIface *iface);

static gboolean gtk_scale_buildable_custom_tag_start (GtkBuildable  *buildable,

                                                      GtkBuilder    *builder,

                                                      GObject       *child,

                                                      const gchar   *tagname,

                                                      GMarkupParser *parser,

                                                      gpointer      *data);

static void     gtk_scale_buildable_custom_finished  (GtkBuildable  *buildable,

                                                      GtkBuilder    *builder,

                                                      GObject       *child,

                                                      const gchar   *tagname,

                                                      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))

static gint

compare_marks (gconstpointer a, gconstpointer b, gpointer data)

{

  gboolean inverted = GPOINTER_TO_INT (data);

  const GtkScaleMark *ma, *mb;

  gint val;

  val = inverted ? -1 : 1;

  ma = a; mb = b;

  return (ma->value > mb->value) ? val : ((ma->value < mb->value) ? -val : 0);

}

static void

gtk_scale_notify (GObject    *object,

                  GParamSpec *pspec)

{

  if (strcmp (pspec->name, "orientation") == 0)

    {

      GtkRange *range = GTK_RANGE (object);

      range->flippable = (range->orientation == GTK_ORIENTATION_HORIZONTAL);

    }

  else if (strcmp (pspec->name, "inverted") == 0)

    {

      GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (object);

      GtkScaleMark *mark;

      GSList *m;

      gint i, n;

      gdouble *values;

      priv->marks = g_slist_sort_with_data (priv->marks,

                                            compare_marks,

                                            GINT_TO_POINTER (gtk_range_get_inverted (GTK_RANGE (object))));

      n = g_slist_length (priv->marks);

      values = g_new (gdouble, n);

      for (m = priv->marks, i = 0; m; m = m->next, i++)

        {

          mark = m->data;

          values[i] = mark->value;

        }

      _gtk_range_set_stop_values (GTK_RANGE (object), values, n);

      g_free (values);

    }

  if (G_OBJECT_CLASS (gtk_scale_parent_class)->notify)

    G_OBJECT_CLASS (gtk_scale_parent_class)->notify (object, pspec);

}

static gboolean

single_string_accumulator (GSignalInvocationHint *ihint,

                           GValue                *return_accu,

                           const GValue          *handler_return,

                           gpointer               dummy)

{

  gboolean continue_emission;

  const gchar *str;

  str = g_value_get_string (handler_return);

  g_value_set_string (return_accu, str);

  continue_emission = str == NULL;

  return continue_emission;

}

#define add_slider_binding(binding_set, keyval, mask, scroll)              \

  gtk_binding_entry_add_signal (binding_set, keyval, mask,                 \

                                I_("move-slider"), 1, \

                                GTK_TYPE_SCROLL_TYPE, scroll)

static void

gtk_scale_class_init (GtkScaleClass *class)

{

  GObjectClass   *gobject_class;

  GtkWidgetClass *widget_class;

  GtkRangeClass  *range_class;

  GtkBindingSet  *binding_set;

  gobject_class = G_OBJECT_CLASS (class);

  range_class = (GtkRangeClass*) class;

  widget_class = (GtkWidgetClass*) class;

  gobject_class->set_property = gtk_scale_set_property;

  gobject_class->get_property = gtk_scale_get_property;

  gobject_class->notify = gtk_scale_notify;

  gobject_class->finalize = gtk_scale_finalize;

  widget_class->style_set = gtk_scale_style_set;

  widget_class->screen_changed = gtk_scale_screen_changed;

  widget_class->expose_event = gtk_scale_expose;

  widget_class->size_request = gtk_scale_size_request;

  range_class->slider_detail = "Xscale";

  range_class->get_range_border = gtk_scale_get_range_border;

  class->get_layout_offsets = gtk_scale_real_get_layout_offsets;

  /**

   * GtkScale::format-value:

   * @scale: the object which received the signal

   * @value: the value to format

   *

   * Signal which allows you to change how the scale value is displayed.

   * Connect a signal handler which returns an allocated string representing 

   * @value. That string will then be used to display the scale's value.

   *

   * If no user-provided handlers are installed, the value will be displayed on

   * its own, rounded according to the value of the #GtkScale:digits property.

   *

   * Here's an example signal handler which displays a value 1.0 as

   * with "-->1.0<--".

   * |[

   * static gchar*

   * format_value_callback (GtkScale *scale,

   *                        gdouble   value)

   * {

   *   return g_strdup_printf ("-->%0.*g<--",

   *                           gtk_scale_get_digits (scale), value);

   *  }

   * ]|

   *

   * Return value: allocated string representing @value

   */

  signals[FORMAT_VALUE] =

    g_signal_new (I_("format-value"),

                  G_TYPE_FROM_CLASS (gobject_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkScaleClass, format_value),

                  single_string_accumulator, NULL,

                  _gtk_marshal_STRING__DOUBLE,

                  G_TYPE_STRING, 1,

                  G_TYPE_DOUBLE);

  g_object_class_install_property (gobject_class,

                                   PROP_DIGITS,

                                   g_param_spec_int ("digits",

						     P_("Digits"),

						     P_("The number of decimal places that are displayed in the value"),

						     -1,

						     MAX_DIGITS,

						     1,

						     GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_DRAW_VALUE,

                                   g_param_spec_boolean ("draw-value",

							 P_("Draw Value"),

							 P_("Whether the current value is displayed as a string next to the slider"),

							 TRUE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_VALUE_POS,

                                   g_param_spec_enum ("value-pos",

						      P_("Value Position"),

						      P_("The position in which the current value is displayed"),

						      GTK_TYPE_POSITION_TYPE,

						      GTK_POS_TOP,

						      GTK_PARAM_READWRITE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("slider-length",

							     P_("Slider Length"),

							     P_("Length of scale's slider"),

							     0,

							     G_MAXINT,

							     31,

							     GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("value-spacing",

							     P_("Value spacing"),

							     P_("Space between value text and the slider/trough area"),

							     0,

							     G_MAXINT,

							     2,

							     GTK_PARAM_READABLE));

  /* All bindings (even arrow keys) are on both h/v scale, because

   * blind users etc. don't care about scale orientation.

   */

  binding_set = gtk_binding_set_by_class (class);

  add_slider_binding (binding_set, GDK_Left, 0,

                      GTK_SCROLL_STEP_LEFT);

  add_slider_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_LEFT);

  add_slider_binding (binding_set, GDK_KP_Left, 0,

                      GTK_SCROLL_STEP_LEFT);

  add_slider_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_LEFT);

  add_slider_binding (binding_set, GDK_Right, 0,

                      GTK_SCROLL_STEP_RIGHT);

  add_slider_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_RIGHT);

  add_slider_binding (binding_set, GDK_KP_Right, 0,

                      GTK_SCROLL_STEP_RIGHT);

  add_slider_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_RIGHT);

  add_slider_binding (binding_set, GDK_Up, 0,

                      GTK_SCROLL_STEP_UP);

  add_slider_binding (binding_set, GDK_Up, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_UP);

  add_slider_binding (binding_set, GDK_KP_Up, 0,

                      GTK_SCROLL_STEP_UP);

  add_slider_binding (binding_set, GDK_KP_Up, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_UP);

  add_slider_binding (binding_set, GDK_Down, 0,

                      GTK_SCROLL_STEP_DOWN);

  add_slider_binding (binding_set, GDK_Down, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_DOWN);

  add_slider_binding (binding_set, GDK_KP_Down, 0,

                      GTK_SCROLL_STEP_DOWN);

  add_slider_binding (binding_set, GDK_KP_Down, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_DOWN);

  add_slider_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_LEFT);

  add_slider_binding (binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_LEFT);  

  add_slider_binding (binding_set, GDK_Page_Up, 0,

                      GTK_SCROLL_PAGE_UP);

  add_slider_binding (binding_set, GDK_KP_Page_Up, 0,

                      GTK_SCROLL_PAGE_UP);

  add_slider_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_RIGHT);

  add_slider_binding (binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_RIGHT);

  add_slider_binding (binding_set, GDK_Page_Down, 0,

                      GTK_SCROLL_PAGE_DOWN);

  add_slider_binding (binding_set, GDK_KP_Page_Down, 0,

                      GTK_SCROLL_PAGE_DOWN);

  /* Logical bindings (vs. visual bindings above) */

  add_slider_binding (binding_set, GDK_plus, 0,

                      GTK_SCROLL_STEP_FORWARD);  

  add_slider_binding (binding_set, GDK_minus, 0,

                      GTK_SCROLL_STEP_BACKWARD);  

  add_slider_binding (binding_set, GDK_plus, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_FORWARD);  

  add_slider_binding (binding_set, GDK_minus, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_BACKWARD);

  add_slider_binding (binding_set, GDK_KP_Add, 0,

                      GTK_SCROLL_STEP_FORWARD);  

  add_slider_binding (binding_set, GDK_KP_Subtract, 0,

                      GTK_SCROLL_STEP_BACKWARD);  

  add_slider_binding (binding_set, GDK_KP_Add, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_FORWARD);  

  add_slider_binding (binding_set, GDK_KP_Subtract, GDK_CONTROL_MASK,

                      GTK_SCROLL_PAGE_BACKWARD);

  add_slider_binding (binding_set, GDK_Home, 0,

                      GTK_SCROLL_START);

  add_slider_binding (binding_set, GDK_KP_Home, 0,

                      GTK_SCROLL_START);

  add_slider_binding (binding_set, GDK_End, 0,

                      GTK_SCROLL_END);

  add_slider_binding (binding_set, GDK_KP_End, 0,

                      GTK_SCROLL_END);

  g_type_class_add_private (gobject_class, sizeof (GtkScalePrivate));

}

static void

gtk_scale_init (GtkScale *scale)

{

  GtkRange *range = GTK_RANGE (scale);

  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;

  scale->draw_value = TRUE;

  scale->value_pos = GTK_POS_TOP;

  scale->digits = 1;

  range->round_digits = scale->digits;

  range->flippable = (range->orientation == GTK_ORIENTATION_HORIZONTAL);

}

static void

gtk_scale_set_property (GObject      *object,

			guint         prop_id,

			const GValue *value,

			GParamSpec   *pspec)

{

  GtkScale *scale;

  scale = GTK_SCALE (object);

  switch (prop_id)

    {

    case PROP_DIGITS:

      gtk_scale_set_digits (scale, g_value_get_int (value));

      break;

    case PROP_DRAW_VALUE:

      gtk_scale_set_draw_value (scale, g_value_get_boolean (value));

      break;

    case PROP_VALUE_POS:

      gtk_scale_set_value_pos (scale, g_value_get_enum (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_scale_get_property (GObject      *object,

			guint         prop_id,

			GValue       *value,

			GParamSpec   *pspec)

{

  GtkScale *scale;

  scale = GTK_SCALE (object);

  switch (prop_id)

    {

    case PROP_DIGITS:

      g_value_set_int (value, scale->digits);

      break;

    case PROP_DRAW_VALUE:

      g_value_set_boolean (value, scale->draw_value);

      break;

    case PROP_VALUE_POS:

      g_value_set_enum (value, scale->value_pos);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

#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.

 *

 * Creates a new #GtkScale.

 *

 * Return value: a new #GtkScale

 *

 * Since: 2.16

 **/

GtkWidget *

gtk_scale_new (GtkOrientation  orientation,

               GtkAdjustment  *adjustment)

{

  g_return_val_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment),

                        NULL);

  return g_object_new (GTK_TYPE_SCALE,

                       "orientation", orientation,

                       "adjustment",  adjustment,

                       NULL);

}

/**

 * gtk_scale_new_with_range:

 * @orientation: the scale's orientation.

 * @min: minimum value

 * @max: maximum value

 * @step: step increment (tick size) used with keyboard shortcuts

 *

 * Creates a new scale widget with the given orientation that lets the

 * user input a number between @min and @max (including @min and @max)

 * with the increment @step.  @step must be nonzero; it's the distance

 * the slider moves when using the arrow keys to adjust the scale

 * value.

 *

 * Note that the way in which the precision is derived works best if @step

 * is a power of ten. If the resulting precision is not suitable for your

 * needs, use gtk_scale_set_digits() to correct it.

 *

 * Return value: a new #GtkScale

 *

 * Since: 2.16

 **/

GtkWidget *

gtk_scale_new_with_range (GtkOrientation orientation,

                          gdouble        min,

                          gdouble        max,

                          gdouble        step)

{

  GtkObject *adj;

  gint digits;

  g_return_val_if_fail (min < max, NULL);

  g_return_val_if_fail (step != 0.0, NULL);

  adj = gtk_adjustment_new (min, min, max, step, 10 * step, 0);

  if (fabs (step) >= 1.0 || step == 0.0)

    {

      digits = 0;

    }

  else

    {

      digits = abs ((gint) floor (log10 (fabs (step))));

      if (digits > 5)

        digits = 5;

    }

  return g_object_new (GTK_TYPE_SCALE,

                       "orientation", orientation,

                       "adjustment",  adj,

                       "digits",      digits,

                       NULL);

}

#endif

/**

 * gtk_scale_set_digits:

 * @scale: a #GtkScale

 * @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 to this number of digits,

 * so the retrieved value matches the displayed one, if #GtkScale:draw-value is

 * %TRUE when the value changes. If you want to enforce rounding the value when

 * #GtkScale:draw-value is %FALSE, you can set #GtkRange:round-digits instead.

 *

 */

void

gtk_scale_set_digits (GtkScale *scale,

		      gint      digits)

{

  GtkRange *range;

  g_return_if_fail (GTK_IS_SCALE (scale));

  range = GTK_RANGE (scale);

  digits = CLAMP (digits, -1, MAX_DIGITS);

  if (scale->digits != digits)

    {

      scale->digits = digits;

      if (scale->draw_value)

	range->round_digits = digits;

      _gtk_scale_clear_layout (scale);

      gtk_widget_queue_resize (GTK_WIDGET (scale));

      g_object_notify (G_OBJECT (scale), "digits");

    }

}

/**

 * gtk_scale_get_digits:

 * @scale: a #GtkScale

 *

 * Gets the number of decimal places that are displayed in the value.

 *

 * Returns: the number of decimal places that are displayed

 */

gint

gtk_scale_get_digits (GtkScale *scale)

{

  g_return_val_if_fail (GTK_IS_SCALE (scale), -1);

  return scale->digits;

}

/**

 * gtk_scale_set_draw_value:

 * @scale: a #GtkScale

 * @draw_value: %TRUE to draw the value

 * 

 * Specifies whether the current value is displayed as a string next 

 * to the slider.

 */

void

gtk_scale_set_draw_value (GtkScale *scale,

			  gboolean  draw_value)

{

  g_return_if_fail (GTK_IS_SCALE (scale));

  draw_value = draw_value != FALSE;

  if (scale->draw_value != draw_value)

    {

      scale->draw_value = draw_value;

      if (draw_value)

	GTK_RANGE (scale)->round_digits = scale->digits;

      else

	GTK_RANGE (scale)->round_digits = -1;

      _gtk_scale_clear_layout (scale);

      gtk_widget_queue_resize (GTK_WIDGET (scale));

      g_object_notify (G_OBJECT (scale), "draw-value");

    }

}

/**

 * gtk_scale_get_draw_value:

 * @scale: a #GtkScale

 *

 * Returns whether the current value is displayed as a string 

 * next to the slider.

 *

 * Returns: whether the current value is displayed as a string

 */

gboolean

gtk_scale_get_draw_value (GtkScale *scale)

{

  g_return_val_if_fail (GTK_IS_SCALE (scale), FALSE);

  return scale->draw_value;

}

/**

 * gtk_scale_set_value_pos:

 * @scale: a #GtkScale

 * @pos: the position in which the current value is displayed

 * 

 * Sets the position in which the current value is displayed.

 */

void

gtk_scale_set_value_pos (GtkScale        *scale,

			 GtkPositionType  pos)

{

  GtkWidget *widget;

  g_return_if_fail (GTK_IS_SCALE (scale));

  if (scale->value_pos != pos)

    {

      scale->value_pos = pos;

      widget = GTK_WIDGET (scale);

      _gtk_scale_clear_layout (scale);

      if (gtk_widget_get_visible (widget) && gtk_widget_get_mapped (widget))

	gtk_widget_queue_resize (widget);

      g_object_notify (G_OBJECT (scale), "value-pos");

    }

}

/**

 * gtk_scale_get_value_pos:

 * @scale: a #GtkScale

 *

 * Gets the position in which the current value is displayed.

 *

 * Returns: the position in which the current value is displayed

 */

GtkPositionType

gtk_scale_get_value_pos (GtkScale *scale)

{

  g_return_val_if_fail (GTK_IS_SCALE (scale), 0);

  return scale->value_pos;

}

static void

gtk_scale_get_range_border (GtkRange  *range,

                            GtkBorder *border)

{

  GtkScalePrivate *priv;

  GtkWidget *widget;

  GtkScale *scale;

  gint w, h;

  widget = GTK_WIDGET (range);

  scale = GTK_SCALE (range);

  priv = GTK_SCALE_GET_PRIVATE (scale);

  _gtk_scale_get_value_size (scale, &w, &h);

  border->left = 0;

  border->right = 0;

  border->top = 0;

  border->bottom = 0;

  if (scale->draw_value)

    {

      gint value_spacing;

      gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL);

      switch (scale->value_pos)

        {

        case GTK_POS_LEFT:

          border->left += w + value_spacing;

          break;

        case GTK_POS_RIGHT:

          border->right += w + value_spacing;

          break;

        case GTK_POS_TOP:

          border->top += h + value_spacing;

          break;

        case GTK_POS_BOTTOM:

          border->bottom += h + value_spacing;

          break;

        }

    }

  if (priv->marks)

    {

      gint slider_width;

      gint value_spacing;

      gint n1, w1, h1, n2, w2, h2;

      gtk_widget_style_get (widget, 

                            "slider-width", &slider_width,

                            "value-spacing", &value_spacing, 

                            NULL);

      if (GTK_RANGE (scale)->orientation == GTK_ORIENTATION_HORIZONTAL)

        {

          gtk_scale_get_mark_label_size (scale, GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2;;

          if (n1 > 0)

            border->top += h1 + value_spacing + slider_width / 2;

          if (n2 > 0)

            border->bottom += h2 + value_spacing + slider_width / 2; 

        }

      else

        {

          gtk_scale_get_mark_label_size (scale, GTK_POS_LEFT, &n1, &w1, &h1, &n2, &w2, &h2;;

          if (n1 > 0)

            border->left += w1 + value_spacing + slider_width / 2;

          if (n2 > 0)

            border->right += w2 + value_spacing + slider_width / 2;

        }

    }

}

/* FIXME this could actually be static at the moment. */

void

_gtk_scale_get_value_size (GtkScale *scale,

                           gint     *width,

                           gint     *height)

{

  GtkRange *range;

  g_return_if_fail (GTK_IS_SCALE (scale));

  if (scale->draw_value)

    {

      PangoLayout *layout;

      PangoRectangle logical_rect;

      gchar *txt;

      range = GTK_RANGE (scale);

      layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);

      txt = _gtk_scale_format_value (scale, range->adjustment->lower);

      pango_layout_set_text (layout, txt, -1);

      g_free (txt);

      pango_layout_get_pixel_extents (layout, NULL, &logical_rect);

      if (width)

	*width = logical_rect.width;

      if (height)

	*height = logical_rect.height;

      txt = _gtk_scale_format_value (scale, range->adjustment->upper);

      pango_layout_set_text (layout, txt, -1);

      g_free (txt);

      pango_layout_get_pixel_extents (layout, NULL, &logical_rect);

      if (width)

	*width = MAX (*width, logical_rect.width);

      if (height)

	*height = MAX (*height, logical_rect.height);

      g_object_unref (layout);

    }

  else

    {

      if (width)

	*width = 0;

      if (height)

	*height = 0;

    }

}

static void

gtk_scale_get_mark_label_size (GtkScale        *scale,

                               GtkPositionType  position,

                               gint            *count1,

                               gint            *width1,

                               gint            *height1,

                               gint            *count2,

                               gint            *width2,

                               gint            *height2)

{

  GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);

  PangoLayout *layout;

  PangoRectangle logical_rect;

  GSList *m;