ruler (Merge from GIMP): Convert to no-window widget and provide separate accessors for position

(bzr r11973)

3 files changed, 236 insertions, 181 deletions

diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index 0fd8fd010..b94a70417 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -1717,12 +1717,8 @@ void
 SPDesktopWidget::viewSetPosition (Geom::Point p)
 {
     Geom::Point const origin = ( p - ruler_origin );
-    gdouble hlower, hupper, hmax_range;
-    gdouble vlower, vupper, vmax_range;
-    sp_ruler_get_range(SP_RULER(hruler), &hlower, &hupper, NULL, &hmax_range);
-    sp_ruler_set_range(SP_RULER(hruler), hlower, hupper, origin[Geom::X], hmax_range);
-    sp_ruler_get_range(SP_RULER(vruler), &vlower, &vupper, NULL, &vmax_range);
-    sp_ruler_set_range(SP_RULER(vruler), vlower, vupper, origin[Geom::Y], vmax_range);
+    sp_ruler_set_position(SP_RULER(hruler), origin[Geom::X]);
+    sp_ruler_set_position(SP_RULER(vruler), origin[Geom::Y]);
 }
 
 void
@@ -1741,13 +1737,11 @@ sp_desktop_widget_update_hruler (SPDesktopWidget *dtw)
      * coincides with the pixel buffer, everything will line up nicely.
      */
     Geom::IntRect viewbox = dtw->canvas->getViewboxIntegers();
-    gdouble position;
 
     double const scale = dtw->desktop->current_zoom();
     double s = viewbox.min()[Geom::X] / scale - dtw->ruler_origin[Geom::X];
     double e = viewbox.max()[Geom::X] / scale - dtw->ruler_origin[Geom::X];
-    sp_ruler_get_range(SP_RULER(dtw->hruler), NULL, NULL, &position, NULL);
-    sp_ruler_set_range(SP_RULER(dtw->hruler), s,  e, position, (e - s));
+    sp_ruler_set_range(SP_RULER(dtw->hruler), s,  e, (e - s));
 }
 
 void
@@ -1759,13 +1753,11 @@ sp_desktop_widget_update_vruler (SPDesktopWidget *dtw)
      * coincides with the pixel buffer, everything will line up nicely.
      */
     Geom::IntRect viewbox = dtw->canvas->getViewboxIntegers();
-    gdouble position;
 
     double const scale = dtw->desktop->current_zoom();
     double s = viewbox.min()[Geom::Y] / -scale - dtw->ruler_origin[Geom::Y];
     double e = viewbox.max()[Geom::Y] / -scale - dtw->ruler_origin[Geom::Y];
-    sp_ruler_get_range(SP_RULER(dtw->vruler), NULL, NULL, &position, NULL);
-    sp_ruler_set_range(SP_RULER(dtw->vruler), s, e, position, (e - s));
+    sp_ruler_set_range(SP_RULER(dtw->vruler), s, e, (e - s));
 }
 
 
diff --git a/src/widgets/ruler.cpp b/src/widgets/ruler.cpp
index 54a64cb56..d5dcd4709 100644
--- a/src/widgets/ruler.cpp
+++ b/src/widgets/ruler.cpp
@@ -37,6 +37,7 @@ struct _SPRulerPrivate
   GtkOrientation orientation;
   SPRulerMetric *metric;
 
+  GdkWindow       *input_window;
   cairo_surface_t *backing_store;
   
   gint slider_size;
@@ -59,27 +60,29 @@ enum {
   PROP_METRIC
 };
 
-static void     sp_ruler_set_property    (GObject        *object,
-                                                      guint            prop_id,
-                                                      const GValue   *value,
-                                                      GParamSpec     *pspec);
-static void     sp_ruler_get_property    (GObject        *object,
-                                                      guint           prop_id,
-                                                      GValue         *value,
-                                                      GParamSpec     *pspec);
-static void     sp_ruler_realize         (GtkWidget      *widget);
-static void     sp_ruler_unrealize       (GtkWidget      *widget);
-static void     sp_ruler_size_request                (GtkWidget      *widget,
-                                                      GtkRequisition *requisition);
+static void     sp_ruler_set_property         (GObject        *object,
+                                               guint           prop_id,
+                                               const GValue   *value,
+                                               GParamSpec     *pspec);
+static void     sp_ruler_get_property         (GObject        *object,
+                                               guint           prop_id,
+                                               GValue         *value,
+                                               GParamSpec     *pspec);
+static void     sp_ruler_realize              (GtkWidget      *widget);
+static void     sp_ruler_unrealize            (GtkWidget      *widget);
+static void     sp_ruler_map                  (GtkWidget      *widget);
+static void     sp_ruler_unmap                (GtkWidget      *widget);
+static void     sp_ruler_size_request         (GtkWidget      *widget,
+                                               GtkRequisition *requisition);
 
 #if GTK_CHECK_VERSION(3,0,0)
-static void     sp_ruler_get_preferred_width         (GtkWidget *widget, 
-                                                      gint      *minimal_width,
-						      gint      *natural_width);
+static void     sp_ruler_get_preferred_width  (GtkWidget      *widget, 
+                                               gint           *minimal_width,
+                                               gint           *natural_width);
 
-static void     sp_ruler_get_preferred_height        (GtkWidget *widget, 
-                                                      gint *minimal_height,
-						      gint *natural_height);
+static void     sp_ruler_get_preferred_height (GtkWidget      *widget, 
+                                               gint           *minimal_height,
+                                               gint           *natural_height);
 #endif
 
 static void     sp_ruler_size_allocate   (GtkWidget      *widget,
@@ -92,9 +95,9 @@ static gboolean sp_ruler_draw            (GtkWidget      *widget,
 static gboolean sp_ruler_expose          (GtkWidget      *widget,
                                           GdkEventExpose *event);
 #endif
-static void     sp_ruler_make_pixmap     (SPRuler *ruler);
 static void     sp_ruler_draw_ticks      (SPRuler *ruler);
 static void     sp_ruler_draw_pos        (SPRuler *ruler);
+static void     sp_ruler_make_pixmap     (SPRuler *ruler);
 
 #define SP_RULER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), SP_TYPE_RULER, SPRulerPrivate))
 
@@ -120,30 +123,34 @@ G_DEFINE_TYPE_WITH_CODE (SPRuler, sp_ruler, GTK_TYPE_WIDGET,
 static void
 sp_ruler_class_init (SPRulerClass *klass)
 {
-  GObjectClass   *gobject_class = G_OBJECT_CLASS (klass);
+  GObjectClass   *object_class  = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class  = GTK_WIDGET_CLASS (klass);
 
-  gobject_class->set_property = sp_ruler_set_property;
-  gobject_class->get_property = sp_ruler_get_property;
+  object_class->set_property         = sp_ruler_set_property;
+  object_class->get_property         = sp_ruler_get_property;
 
-  widget_class->realize = sp_ruler_realize;
-  widget_class->unrealize = sp_ruler_unrealize;
+  widget_class->realize              = sp_ruler_realize;
+  widget_class->unrealize            = sp_ruler_unrealize;
+  widget_class->map                  = sp_ruler_map;
+  widget_class->unmap                = sp_ruler_unmap;
+  widget_class->size_allocate        = sp_ruler_size_allocate;
 #if GTK_CHECK_VERSION(3,0,0)
-  widget_class->get_preferred_width = sp_ruler_get_preferred_width;
+  widget_class->get_preferred_width  = sp_ruler_get_preferred_width;
   widget_class->get_preferred_height = sp_ruler_get_preferred_height;
-  widget_class->draw = sp_ruler_draw;
+  widget_class->draw                 = sp_ruler_draw;
 #else
-  widget_class->size_request = sp_ruler_size_request;
-  widget_class->expose_event = sp_ruler_expose;
+  widget_class->size_request         = sp_ruler_size_request;
+  widget_class->expose_event         = sp_ruler_expose;
 #endif
-  widget_class->size_allocate = sp_ruler_size_allocate;
   widget_class->motion_notify_event = sp_ruler_motion_notify;
 
-  g_object_class_override_property (gobject_class,
+  g_type_class_add_private (object_class, sizeof (SPRulerPrivate));
+
+  g_object_class_override_property (object_class,
                                     PROP_ORIENTATION,
                                     "orientation");
 
-  g_object_class_install_property (gobject_class,
+  g_object_class_install_property (object_class,
                                    PROP_LOWER,
                                    g_param_spec_double ("lower",
 							_("Lower"),
@@ -153,7 +160,7 @@ sp_ruler_class_init (SPRulerClass *klass)
 							0.0,
 							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
 
-  g_object_class_install_property (gobject_class,
+  g_object_class_install_property (object_class,
                                    PROP_UPPER,
                                    g_param_spec_double ("upper",
 							_("Upper"),
@@ -163,7 +170,7 @@ sp_ruler_class_init (SPRulerClass *klass)
 							0.0,
 							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
 
-  g_object_class_install_property (gobject_class,
+  g_object_class_install_property (object_class,
                                    PROP_POSITION,
                                    g_param_spec_double ("position",
 							_("Position"),
@@ -173,7 +180,7 @@ sp_ruler_class_init (SPRulerClass *klass)
 							0.0,
 							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
 
-  g_object_class_install_property (gobject_class,
+  g_object_class_install_property (object_class,
                                    PROP_MAX_SIZE,
                                    g_param_spec_double ("max-size",
 							_("Max Size"),
@@ -189,7 +196,7 @@ sp_ruler_class_init (SPRulerClass *klass)
    *
    * TODO: This should probably use g_param_spec_enum
    */
-  g_object_class_install_property (gobject_class,
+  g_object_class_install_property (object_class,
                                    PROP_METRIC,
                                    g_param_spec_uint("metric",
 						      _("Metric"),
@@ -197,34 +204,28 @@ sp_ruler_class_init (SPRulerClass *klass)
 						      0, 8,
 						      SP_PX,
 						      static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
-
-  g_type_class_add_private (gobject_class, sizeof (SPRulerPrivate));
 }
 
 static void
 sp_ruler_init (SPRuler *ruler)
 {
-  ruler->priv = G_TYPE_INSTANCE_GET_PRIVATE(ruler,
-		                            SP_TYPE_RULER,
-					    SPRulerPrivate);
-
-  SPRulerPrivate *priv = ruler->priv;
-
-  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
-
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (ruler);
+
+  gtk_widget_set_has_window (GTK_WIDGET (ruler), FALSE);
+
+  priv->orientation   = GTK_ORIENTATION_HORIZONTAL;
+  priv->xsrc          = 0;
+  priv->ysrc          = 0;
+  priv->slider_size   = 0;
+  priv->lower         = 0;
+  priv->upper         = 0;
+  priv->position      = 0;
+  priv->max_size      = 0;
   priv->backing_store = NULL;
-  priv->xsrc = 0;
-  priv->ysrc = 0;
-  priv->slider_size = 0;
-  priv->lower = 0;
-  priv->upper = 0;
-  priv->position = 0;
-  priv->max_size = 0;
 
   sp_ruler_set_metric(ruler, SP_PX);
 }
 
-
 /**
  * sp_ruler_invalidate_ticks:
  * @ruler: the ruler to invalidate
@@ -235,22 +236,22 @@ sp_ruler_init (SPRuler *ruler)
  **/
 static void sp_ruler_invalidate_ticks(SPRuler *ruler)
 {
-	g_return_if_fail(SP_IS_RULER(ruler));
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (ruler);
+  g_return_if_fail(SP_IS_RULER(ruler));
 
-	if(ruler->priv->backing_store == NULL)
-		return;
+  if(priv->backing_store == NULL)
+      return;
 
-	sp_ruler_draw_ticks(ruler);
-	gtk_widget_queue_draw(GTK_WIDGET(ruler));
+  sp_ruler_draw_ticks(ruler);
+  gtk_widget_queue_draw(GTK_WIDGET(ruler));
 }
 
 
 /**
  * sp_ruler_set_range:
- * @ruler: the gtkdeprecatedruler
+ * @ruler: the SPRuler
  * @lower: the lower limit of the ruler
  * @upper: the upper limit of the ruler
- * @position: the mark on the ruler
  * @max_size: the maximum size of the ruler used when calculating the space to
  * leave for the text
  *
@@ -258,14 +259,15 @@ static void sp_ruler_invalidate_ticks(SPRuler *ruler)
  */
 void
 sp_ruler_set_range (SPRuler *ruler,
-		     gdouble   lower,
-		     gdouble   upper,
-		     gdouble   position,
-		     gdouble   max_size)
+		    gdouble   lower,
+		    gdouble   upper,
+		    gdouble   max_size)
 {
+  SPRulerPrivate *priv;
+  
   g_return_if_fail (SP_IS_RULER (ruler));
 
-  SPRulerPrivate *priv = ruler->priv;
+  priv = SP_RULER_GET_PRIVATE (ruler);
 
   g_object_freeze_notify (G_OBJECT (ruler));
   if (priv->lower != lower)
@@ -278,11 +280,6 @@ sp_ruler_set_range (SPRuler *ruler,
       priv->upper = upper;
       g_object_notify (G_OBJECT (ruler), "upper");
     }
-  if (priv->position != position)
-    {
-      priv->position = position;
-      g_object_notify (G_OBJECT (ruler), "position");
-    }
   if (priv->max_size != max_size)
     {
       priv->max_size = max_size;
@@ -298,7 +295,6 @@ sp_ruler_set_range (SPRuler *ruler,
  * @ruler: a #SPRuler
  * @lower: (allow-none): location to store lower limit of the ruler, or %NULL
  * @upper: (allow-none): location to store upper limit of the ruler, or %NULL
- * @position: (allow-none): location to store the current position of the mark on the ruler, or %NULL
  * @max_size: location to store the maximum size of the ruler used when calculating
  *            the space to leave for the text, or %NULL.
  *
@@ -309,19 +305,18 @@ void
 sp_ruler_get_range (SPRuler *ruler,
 		     gdouble  *lower,
 		     gdouble  *upper,
-		     gdouble  *position,
 		     gdouble  *max_size)
 {
+  SPRulerPrivate *priv;
+
   g_return_if_fail (SP_IS_RULER (ruler));
   
-  SPRulerPrivate *priv = ruler->priv;
+  priv = SP_RULER_GET_PRIVATE (ruler);
 
   if (lower)
     *lower = priv->lower;
   if (upper)
     *upper = priv->upper;
-  if (position)
-    *position = priv->position;
   if (max_size)
     *max_size = priv->max_size;
 }
@@ -333,7 +328,7 @@ sp_ruler_set_property (GObject      *object,
 			GParamSpec   *pspec)
 {
   SPRuler *ruler = SP_RULER (object);
-  SPRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (ruler);
 
   switch (prop_id)
     {
@@ -342,23 +337,28 @@ sp_ruler_set_property (GObject      *object,
       gtk_widget_queue_resize (GTK_WIDGET (ruler));
       break;
     case PROP_LOWER:
-      sp_ruler_set_range (ruler, g_value_get_double (value), priv->upper,
-			   priv->position, priv->max_size);
+      sp_ruler_set_range (ruler,
+                          g_value_get_double (value),
+                          priv->upper,
+			  priv->max_size);
       break;
     case PROP_UPPER:
-      sp_ruler_set_range (ruler, priv->lower, g_value_get_double (value),
-			   priv->position, priv->max_size);
+      sp_ruler_set_range (ruler,
+                          priv->lower,
+                          g_value_get_double (value),
+			  priv->max_size);
       break;
     case PROP_POSITION:
-      sp_ruler_set_range (ruler, priv->lower, priv->upper,
-			   g_value_get_double (value), priv->max_size);
+      sp_ruler_set_position (ruler, g_value_get_double (value));
       break;
     case PROP_MAX_SIZE:
-      sp_ruler_set_range (ruler, priv->lower, priv->upper,
-			   priv->position,  g_value_get_double (value));
+      sp_ruler_set_range (ruler,
+                          priv->lower,
+                          priv->upper,
+			  g_value_get_double (value));
       break;
     case PROP_METRIC:
-      sp_ruler_set_metric(ruler, static_cast<SPMetric>(g_value_get_enum (value)));
+      sp_ruler_set_metric (ruler, static_cast<SPMetric>(g_value_get_enum (value)));
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -373,7 +373,7 @@ sp_ruler_get_property (GObject      *object,
 			GParamSpec   *pspec)
 {
   SPRuler *ruler = SP_RULER (object);
-  SPRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (ruler);
 
   switch (prop_id)
     {
@@ -413,7 +413,7 @@ sp_ruler_get_property (GObject      *object,
 SPMetric sp_ruler_get_metric(SPRuler *ruler)
 {
   g_return_val_if_fail(SP_IS_RULER(ruler), static_cast<SPMetric>(0));
-  SPRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (ruler);
 
   for (size_t i = 0; i < G_N_ELEMENTS(sp_ruler_metrics); i++) {
     if (priv->metric == &sp_ruler_metrics[i]) {
@@ -427,65 +427,88 @@ SPMetric sp_ruler_get_metric(SPRuler *ruler)
 }
 
 
-static void sp_ruler_realize(GtkWidget *widget)
+static void
+sp_ruler_realize (GtkWidget *widget)
 {
-  GtkAllocation allocation;
-  SPRuler *ruler;
-  GdkWindow *window;
-  GdkWindowAttr attributes;
-  gint attributes_mask;
-
-  ruler = SP_RULER (widget);
-
-  gtk_widget_set_realized (widget, TRUE);
+  SPRuler        *ruler = SP_RULER (widget);
+  SPRulerPrivate *priv  = SP_RULER_GET_PRIVATE (ruler);
+  GtkAllocation   allocation;
+  GdkWindowAttr   attributes;
+  gint            attributes_mask;
 
-  gtk_widget_get_allocation(widget, &allocation);
+  GTK_WIDGET_CLASS (sp_ruler_parent_class)->realize (widget);
+  
+  gtk_widget_get_allocation (widget, &allocation);
 
   attributes.window_type = GDK_WINDOW_CHILD;
-  attributes.x = allocation.x;
-  attributes.y = allocation.y;
-  attributes.width = allocation.width;
-  attributes.height = allocation.height;
-  attributes.wclass = GDK_INPUT_OUTPUT;
-  attributes.visual = gtk_widget_get_visual (widget);
-  attributes.event_mask = gtk_widget_get_events (widget);
-  attributes.event_mask |= (GDK_EXPOSURE_MASK |
-			    GDK_POINTER_MOTION_MASK |
-			    GDK_POINTER_MOTION_HINT_MASK);
-
-  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
-
-  window = gdk_window_new(gtk_widget_get_parent_window (widget), 
-		          &attributes, attributes_mask);
-  gtk_widget_set_window(widget, window);
-  gdk_window_set_user_data(window, ruler);
-
+  attributes.x           = allocation.x;
+  attributes.y           = allocation.y;
+  attributes.width       = allocation.width;
+  attributes.height      = allocation.height;
+  attributes.wclass      = GDK_INPUT_ONLY;
 #if GTK_CHECK_VERSION(3,0,0)
-  gtk_style_context_set_background(gtk_widget_get_style_context(widget),
-                                   window);
+  attributes.event_mask  = (gtk_widget_get_events (widget) |
+                           GDK_EXPOSURE_MASK               |
+			   GDK_POINTER_MOTION_MASK         |
+			   GDK_POINTER_MOTION_HINT_MASK);
 #else
-  gtk_widget_style_attach(widget);
-  gtk_style_set_background(gtk_widget_get_style(widget),
-		           window, GTK_STATE_ACTIVE);
+  attributes.event_mask  = (gtk_widget_get_events (widget) |
+                           GDK_EXPOSURE_MASK               |
+			   GDK_POINTER_MOTION_MASK);
 #endif
 
+  attributes_mask = GDK_WA_X | GDK_WA_Y;
+
+  priv->input_window = gdk_window_new (gtk_widget_get_parent_window (widget), 
+                                       &attributes, attributes_mask);
+  gdk_window_set_user_data (priv->input_window, ruler);
+
   sp_ruler_make_pixmap (ruler);
 }
 
-static void sp_ruler_unrealize(GtkWidget *widget)
+static void
+sp_ruler_unrealize(GtkWidget *widget)
 {
-  SPRuler *ruler = SP_RULER (widget);
-  SPRulerPrivate *priv = ruler->priv;
+  SPRuler        *ruler = SP_RULER (widget);
+  SPRulerPrivate *priv  = SP_RULER_GET_PRIVATE (ruler);
 
   if (priv->backing_store)
     {
-      cairo_surface_destroy(priv->backing_store);
+      cairo_surface_destroy (priv->backing_store);
       priv->backing_store = NULL;
     }
 
+  if (priv->input_window)
+    {
+      gdk_window_destroy (priv->input_window);
+      priv->input_window = NULL;
+    }
+
   GTK_WIDGET_CLASS (sp_ruler_parent_class)->unrealize (widget);
 }
 
+static void
+sp_ruler_map (GtkWidget *widget)
+{
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (widget);
+
+  GTK_WIDGET_CLASS (sp_ruler_parent_class)->map (widget);
+
+  if (priv->input_window)
+    gdk_window_show (priv->input_window);
+}
+
+static void
+sp_ruler_unmap (GtkWidget *widget)
+{
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (widget);
+
+  if (priv->input_window)
+    gdk_window_hide (priv->input_window);
+  
+  GTK_WIDGET_CLASS (sp_ruler_parent_class)->unmap (widget);
+}
+
 static void sp_ruler_size_request(GtkWidget *widget, 
 		                  GtkRequisition *requisition)
 {
@@ -520,25 +543,22 @@ static void sp_ruler_get_preferred_height(GtkWidget *widget, gint *minimal_heigh
 }
 #endif
 
-static void sp_ruler_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
+static void
+sp_ruler_size_allocate (GtkWidget     *widget,
+                        GtkAllocation *allocation)
 {
-  SPRuler *ruler = SP_RULER(widget);
-  GtkAllocation old_allocation;
-  gtk_widget_get_allocation(widget, &old_allocation);
-
-  gboolean resized = (old_allocation.width != allocation->width ||
-		      old_allocation.height != allocation->height);
+  SPRuler        *ruler = SP_RULER(widget);
+  SPRulerPrivate *priv  = SP_RULER_GET_PRIVATE (ruler);
 
   gtk_widget_set_allocation(widget, allocation);
 
   if (gtk_widget_get_realized (widget))
     {
-      gdk_window_move_resize(gtk_widget_get_window(widget),
-			     allocation->x, allocation->y,
-			     allocation->width, allocation->height);
-
-      if(resized)
-        sp_ruler_make_pixmap (ruler);
+      gdk_window_move_resize (priv->input_window,
+                              allocation->x, allocation->y,
+                              allocation->width, allocation->height);
+        
+      sp_ruler_make_pixmap (ruler);
     }
 }
 
@@ -582,26 +602,24 @@ static gboolean sp_ruler_draw(GtkWidget *widget,
   return FALSE;
 }
 
-static void sp_ruler_make_pixmap(SPRuler *ruler)
+
+static void
+sp_ruler_make_pixmap (SPRuler *ruler)
 {
-  SPRulerPrivate *priv = ruler->priv;
-  GtkWidget *widget = GTK_WIDGET(ruler);
+  GtkWidget      *widget = GTK_WIDGET (ruler);
+  SPRulerPrivate *priv   = SP_RULER_GET_PRIVATE (ruler);
+  GtkAllocation   allocation;
 
-  GtkAllocation allocation;
   gtk_widget_get_allocation(widget, &allocation);
 
   if (priv->backing_store)
-      cairo_surface_destroy(priv->backing_store);
-
-  priv->backing_store = gdk_window_create_similar_surface(gtk_widget_get_window(widget),
-		                                          CAIRO_CONTENT_COLOR,
-							  allocation.width,
-							  allocation.height);
+      cairo_surface_destroy (priv->backing_store);
 
-  priv->xsrc = 0;
-  priv->ysrc = 0;
-
-  sp_ruler_draw_ticks(ruler);
+  priv->backing_store = 
+    gdk_window_create_similar_surface (gtk_widget_get_window (widget),
+                                       CAIRO_CONTENT_COLOR,
+                                       allocation.width,
+                                       allocation.height);
 }
 
 
@@ -689,7 +707,9 @@ sp_ruler_draw_pos (SPRuler *ruler)
           cairo_fill (cr);
         }
 
-      sp_ruler_get_range (ruler, &lower, &upper, &position, NULL);
+      position = sp_ruler_get_position (ruler);
+
+      sp_ruler_get_range (ruler, &lower, &upper, NULL);
 
       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
         {
@@ -756,12 +776,53 @@ GtkWidget* sp_ruler_new(GtkOrientation orientation)
 		                 NULL));
 }
 
+
+/**
+ * sp_ruler_set_position:
+ * @ruler: a #SPRuler
+ * @position: the position to set the ruler to
+ *
+ * This sets the position of the ruler.
+ */
+void
+sp_ruler_set_position (SPRuler *ruler,
+                       gdouble  position)
+{
+    SPRulerPrivate *priv;
+
+    g_return_if_fail (SP_IS_RULER (ruler));
+    
+    priv = SP_RULER_GET_PRIVATE (ruler);
+
+    if (priv->position != position)
+    {
+        priv->position = position;
+        g_object_notify (G_OBJECT (ruler), "position");
+
+        sp_ruler_draw_pos (ruler);
+    }
+}
+
+/**
+ * sp_ruler_get_position:
+ * @ruler: a #SPRuler
+ *
+ * Return value: the current position of the @ruler widget.
+ */
+gdouble
+sp_ruler_get_position (SPRuler *ruler)
+{
+    g_return_val_if_fail (SP_IS_RULER (ruler), 0.0);
+
+    return SP_RULER_GET_PRIVATE (ruler)->position;
+}
+
 static gboolean sp_ruler_motion_notify(GtkWidget      *widget,
 			               GdkEventMotion *event)
 {
   GtkAllocation  allocation;
   SPRuler *ruler = SP_RULER(widget);
-  SPRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (ruler);
   
   gdk_event_request_motions(event);
   gint x = event->x;
@@ -979,7 +1040,7 @@ void sp_ruler_set_metric(SPRuler *ruler, SPMetric metric)
   g_return_if_fail(ruler != NULL);
   g_return_if_fail(SP_IS_RULER (ruler));
   g_return_if_fail((unsigned) metric < G_N_ELEMENTS(sp_ruler_metrics));
-  SPRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (ruler);
 
   if (metric == 0) 
 	return;
diff --git a/src/widgets/ruler.h b/src/widgets/ruler.h
index 992d9a385..9874372f1 100644
--- a/src/widgets/ruler.h
+++ b/src/widgets/ruler.h
@@ -59,20 +59,22 @@ struct _SPRulerMetric
 };
 
 
-GType           sp_ruler_get_type   (void) G_GNUC_CONST;
-GtkWidget*      sp_ruler_new        (GtkOrientation  orientation);
-void            sp_ruler_set_range  (SPRuler        *ruler,
-                                     gdouble         lower,
-                                     gdouble         upper,
-                                     gdouble         position,
-                                     gdouble         max_size);
-void            sp_ruler_get_range  (SPRuler        *ruler,
-                                     gdouble        *lower,
-                                     gdouble        *upper,
-                                     gdouble        *position,
-                                     gdouble        *max_size);
-void     sp_ruler_set_metric(SPRuler *ruler, SPMetric  metric);
-SPMetric sp_ruler_get_metric(SPRuler *ruler);
+GType           sp_ruler_get_type     (void) G_GNUC_CONST;
+GtkWidget*      sp_ruler_new          (GtkOrientation  orientation);
+void            sp_ruler_set_position (SPRuler      *ruler,
+                                       gdouble       set_position);
+gdouble         sp_ruler_get_position (SPRuler      *ruler);
+void            sp_ruler_set_range    (SPRuler        *ruler,
+                                       gdouble         lower,
+                                       gdouble         upper,
+                                       gdouble         max_size);
+void            sp_ruler_get_range    (SPRuler        *ruler,
+                                       gdouble        *lower,
+                                       gdouble        *upper,
+                                       gdouble        *max_size);
+void            sp_ruler_set_metric   (SPRuler        *ruler,
+                                       SPMetric        metric);
+SPMetric        sp_ruler_get_metric   (SPRuler        *ruler);
 
 #endif /* __SP_RULER_H__ */