Hide non-public fields of ruler

(bzr r11326)

1 files changed, 116 insertions, 92 deletions

diff --git a/src/widgets/ruler.cpp b/src/widgets/ruler.cpp
index 845d56e1c..6fd9e2c86 100644
--- a/src/widgets/ruler.cpp
+++ b/src/widgets/ruler.cpp
@@ -32,6 +32,23 @@
 
 #define ROUND(x) ((int) ((x) + 0.5))
 
+struct _GtkDeprecatedRulerPrivate
+{
+  GtkOrientation orientation;
+  GtkDeprecatedRulerMetric *metric;
+  
+  GdkPixmap *backing_store;
+  
+  gint slider_size;
+  gint xsrc;
+  gint ysrc;
+
+  gdouble lower;    /* The upper limit of the ruler (in points) */
+  gdouble upper;    /* The lower limit of the ruler */
+  gdouble position; /* The position of the mark on the ruler */
+  gdouble max_size; /* The maximum size of the ruler */
+};
+
 enum {
   PROP_0,
   PROP_ORIENTATION,
@@ -42,13 +59,6 @@ enum {
   PROP_METRIC
 };
 
-typedef struct _GtkDeprecatedRulerPrivate GtkDeprecatedRulerPrivate;
-
-struct _GtkDeprecatedRulerPrivate
-{
-  GtkOrientation orientation;
-};
-
 static void     gtk_deprecated_ruler_set_property    (GObject        *object,
                                                       guint            prop_id,
                                                       const GValue   *value,
@@ -193,18 +203,22 @@ gtk_deprecated_ruler_class_init (GtkDeprecatedRulerClass *klass)
 static void
 gtk_deprecated_ruler_init (GtkDeprecatedRuler *ruler)
 {
-  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+  ruler->priv = G_TYPE_INSTANCE_GET_PRIVATE(ruler,
+		                            GTK_DEPRECATED_TYPE_RULER,
+					    GtkDeprecatedRulerPrivate);
+
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
 
   priv->orientation = GTK_ORIENTATION_HORIZONTAL;
 
-  ruler->backing_store = NULL;
-  ruler->xsrc = 0;
-  ruler->ysrc = 0;
-  ruler->slider_size = 0;
-  ruler->lower = 0;
-  ruler->upper = 0;
-  ruler->position = 0;
-  ruler->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);
 }
@@ -230,25 +244,27 @@ gtk_deprecated_ruler_set_range (GtkDeprecatedRuler *ruler,
 {
   g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
 
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+
   g_object_freeze_notify (G_OBJECT (ruler));
-  if (ruler->lower != lower)
+  if (priv->lower != lower)
     {
-      ruler->lower = lower;
+      priv->lower = lower;
       g_object_notify (G_OBJECT (ruler), "lower");
     }
-  if (ruler->upper != upper)
+  if (priv->upper != upper)
     {
-      ruler->upper = upper;
+      priv->upper = upper;
       g_object_notify (G_OBJECT (ruler), "upper");
     }
-  if (ruler->position != position)
+  if (priv->position != position)
     {
-      ruler->position = position;
+      priv->position = position;
       g_object_notify (G_OBJECT (ruler), "position");
     }
-  if (ruler->max_size != max_size)
+  if (priv->max_size != max_size)
     {
-      ruler->max_size = max_size;
+      priv->max_size = max_size;
       g_object_notify (G_OBJECT (ruler), "max-size");
     }
   g_object_thaw_notify (G_OBJECT (ruler));
@@ -277,15 +293,17 @@ gtk_deprecated_ruler_get_range (GtkDeprecatedRuler *ruler,
 		     gdouble  *max_size)
 {
   g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+  
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
 
   if (lower)
-    *lower = ruler->lower;
+    *lower = priv->lower;
   if (upper)
-    *upper = ruler->upper;
+    *upper = priv->upper;
   if (position)
-    *position = ruler->position;
+    *position = priv->position;
   if (max_size)
-    *max_size = ruler->max_size;
+    *max_size = priv->max_size;
 }
 
 static void
@@ -295,7 +313,7 @@ gtk_deprecated_ruler_set_property (GObject      *object,
 			GParamSpec   *pspec)
 {
   GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (object);
-  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
 
   switch (prop_id)
     {
@@ -304,20 +322,20 @@ gtk_deprecated_ruler_set_property (GObject      *object,
       gtk_widget_queue_resize (GTK_WIDGET (ruler));
       break;
     case PROP_LOWER:
-      gtk_deprecated_ruler_set_range (ruler, g_value_get_double (value), ruler->upper,
-			   ruler->position, ruler->max_size);
+      gtk_deprecated_ruler_set_range (ruler, g_value_get_double (value), priv->upper,
+			   priv->position, priv->max_size);
       break;
     case PROP_UPPER:
-      gtk_deprecated_ruler_set_range (ruler, ruler->lower, g_value_get_double (value),
-			   ruler->position, ruler->max_size);
+      gtk_deprecated_ruler_set_range (ruler, priv->lower, g_value_get_double (value),
+			   priv->position, priv->max_size);
       break;
     case PROP_POSITION:
-      gtk_deprecated_ruler_set_range (ruler, ruler->lower, ruler->upper,
-			   g_value_get_double (value), ruler->max_size);
+      gtk_deprecated_ruler_set_range (ruler, priv->lower, priv->upper,
+			   g_value_get_double (value), priv->max_size);
       break;
     case PROP_MAX_SIZE:
-      gtk_deprecated_ruler_set_range (ruler, ruler->lower, ruler->upper,
-			   ruler->position,  g_value_get_double (value));
+      gtk_deprecated_ruler_set_range (ruler, priv->lower, priv->upper,
+			   priv->position,  g_value_get_double (value));
       break;
     case PROP_METRIC:
       sp_ruler_set_metric(ruler, static_cast<SPMetric>(g_value_get_enum (value)));
@@ -335,7 +353,7 @@ gtk_deprecated_ruler_get_property (GObject      *object,
 			GParamSpec   *pspec)
 {
   GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (object);
-  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
 
   switch (prop_id)
     {
@@ -343,16 +361,16 @@ gtk_deprecated_ruler_get_property (GObject      *object,
       g_value_set_enum (value, priv->orientation);
       break;
     case PROP_LOWER:
-      g_value_set_double (value, ruler->lower);
+      g_value_set_double (value, priv->lower);
       break;
     case PROP_UPPER:
-      g_value_set_double (value, ruler->upper);
+      g_value_set_double (value, priv->upper);
       break;
     case PROP_POSITION:
-      g_value_set_double (value, ruler->position);
+      g_value_set_double (value, priv->position);
       break;
     case PROP_MAX_SIZE:
-      g_value_set_double (value, ruler->max_size);
+      g_value_set_double (value, priv->max_size);
       break;
     case PROP_METRIC:
       g_value_set_enum(value, sp_ruler_get_metric(ruler));
@@ -375,9 +393,10 @@ gtk_deprecated_ruler_get_property (GObject      *object,
 SPMetric sp_ruler_get_metric(GtkDeprecatedRuler *ruler)
 {
   g_return_val_if_fail(GTK_DEPRECATED_IS_RULER(ruler), static_cast<SPMetric>(0));
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
 
   for (size_t i = 0; i < G_N_ELEMENTS(sp_ruler_metrics); i++) {
-    if (ruler->metric == &sp_ruler_metrics[i]) {
+    if (priv->metric == &sp_ruler_metrics[i]) {
       return static_cast<SPMetric>(i);
     }
   }
@@ -453,11 +472,12 @@ static void
 gtk_deprecated_ruler_unrealize (GtkWidget *widget)
 {
   GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
 
-  if (ruler->backing_store)
+  if (priv->backing_store)
     {
-      g_object_unref (ruler->backing_store);
-      ruler->backing_store = NULL;
+      g_object_unref (priv->backing_store);
+      priv->backing_store = NULL;
     }
 
   GTK_WIDGET_CLASS (gtk_deprecated_ruler_parent_class)->unrealize (widget);
@@ -522,7 +542,7 @@ gtk_deprecated_ruler_motion_notify (GtkWidget      *widget,
 {
   GtkAllocation allocation;
   GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
-  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (widget);
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
   gint x;
   gint y;
 
@@ -533,14 +553,14 @@ gtk_deprecated_ruler_motion_notify (GtkWidget      *widget,
   gtk_widget_get_allocation(widget, &allocation);
 
   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
-    ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * x) / allocation.width;
+    priv->position = priv->lower + ((priv->upper - priv->lower) * x) / allocation.width;
   else
-    ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * y) / allocation.height;
+    priv->position = priv->lower + ((priv->upper - priv->lower) * y) / allocation.height;
 
   g_object_notify (G_OBJECT (ruler), "position");
 
   /*  Make sure the ruler has been allocated already  */
-  if (ruler->backing_store != NULL)
+  if (priv->backing_store != NULL)
     gtk_deprecated_ruler_draw_pos (ruler);
 
   return FALSE;
@@ -553,12 +573,13 @@ gtk_deprecated_ruler_expose (GtkWidget      *widget,
   if (gtk_widget_is_drawable (widget))
     {
       GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
+      GtkDeprecatedRulerPrivate *priv = ruler->priv;
       cairo_t *cr;
 
       gtk_deprecated_ruler_draw_ticks (ruler);
       
       cr = gdk_cairo_create(gtk_widget_get_window(widget));
-      gdk_cairo_set_source_pixmap (cr, ruler->backing_store, 0, 0);
+      gdk_cairo_set_source_pixmap (cr, priv->backing_store, 0, 0);
       gdk_cairo_rectangle (cr, &event->area);
       cairo_fill (cr);
       cairo_destroy (cr);
@@ -572,6 +593,7 @@ gtk_deprecated_ruler_expose (GtkWidget      *widget,
 static void
 gtk_deprecated_ruler_make_pixmap (GtkDeprecatedRuler *ruler)
 {
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
   GtkAllocation allocation;
   GtkWidget *widget;
   gint width;
@@ -581,23 +603,23 @@ gtk_deprecated_ruler_make_pixmap (GtkDeprecatedRuler *ruler)
 
   gtk_widget_get_allocation(widget, &allocation);
 
-  if (ruler->backing_store)
+  if (priv->backing_store)
     {
-      gdk_drawable_get_size (ruler->backing_store, &width, &height);
+      gdk_drawable_get_size (priv->backing_store, &width, &height);
       if ((width == allocation.width) &&
 	  (height == allocation.height))
 	return;
 
-      g_object_unref (ruler->backing_store);
+      g_object_unref (priv->backing_store);
     }
 
-  ruler->backing_store = gdk_pixmap_new (gtk_widget_get_window(widget),
+  priv->backing_store = gdk_pixmap_new (gtk_widget_get_window(widget),
 					 allocation.width,
 					 allocation.height,
 					 -1);
 
-  ruler->xsrc = 0;
-  ruler->ysrc = 0;
+  priv->xsrc = 0;
+  priv->ysrc = 0;
 }
 
 static void
@@ -605,7 +627,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
 {
   GtkAllocation allocation;
   GtkWidget *widget = GTK_WIDGET (ruler);
-  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
   GtkStyle *style;
   cairo_t *cr;
   gint i, j;
@@ -655,7 +677,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
 
 #define DETAILE(priv) (priv->orientation == GTK_ORIENTATION_HORIZONTAL ? "hruler" : "vruler");
 
-  gtk_paint_box (style, ruler->backing_store,
+  gtk_paint_box (style, priv->backing_store,
 		 GTK_STATE_NORMAL, GTK_SHADOW_OUT,
 		 NULL, widget,
                  priv->orientation == GTK_ORIENTATION_HORIZONTAL ?
@@ -663,7 +685,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
 		 0, 0,
 		 allocation.width, allocation.height);
 
-  cr = gdk_cairo_create (ruler->backing_store);
+  cr = gdk_cairo_create (priv->backing_store);
   gdk_cairo_set_source_color (cr, &style->fg[gtk_widget_get_state(widget)]);
 
   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
@@ -683,8 +705,8 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
                        allocation.height - 2 * ythickness);
     }
 
-  upper = ruler->upper / ruler->metric->pixels_per_unit;
-  lower = ruler->lower / ruler->metric->pixels_per_unit;
+  upper = priv->upper / priv->metric->pixels_per_unit;
+  lower = priv->lower / priv->metric->pixels_per_unit;
 
   if ((upper - lower) == 0)
     goto out;
@@ -702,7 +724,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
    *   of this displayed text. Use this height to find a scale which
    *   leaves sufficient room for drawing the ruler.
    */
-  scale = ceil (ruler->max_size / ruler->metric->pixels_per_unit);
+  scale = ceil (priv->max_size / priv->metric->pixels_per_unit);
   g_snprintf (unit_str, sizeof (unit_str), "%d", scale);
 
   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
@@ -710,7 +732,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
       text_width = strlen (unit_str) * digit_height + 1;
 
       for (scale = 0; scale < MAXIMUM_SCALES; scale++)
-        if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
+        if (priv->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
           break;
     }
   else
@@ -718,7 +740,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
       text_height = strlen (unit_str) * digit_height + 1;
 
       for (scale = 0; scale < MAXIMUM_SCALES; scale++)
-        if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_height)
+        if (priv->metric->ruler_scale[scale] * fabs(increment) > 2 * text_height)
           break;
     }
 
@@ -729,8 +751,8 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
   length = 0;
   for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--)
     {
-      subd_incr = (gdouble) ruler->metric->ruler_scale[scale] /
-	          (gdouble) ruler->metric->subdivide[i];
+      subd_incr = (gdouble) priv->metric->ruler_scale[scale] /
+	          (gdouble) priv->metric->subdivide[i];
       if (subd_incr * fabs(increment) <= MINIMUM_INCR)
 	continue;
 
@@ -780,7 +802,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
                   pango_layout_get_extents (layout, &logical_rect, NULL);
 
                   gtk_paint_layout (style,
-                                    ruler->backing_store,
+                                    priv->backing_store,
                                     gtk_widget_get_state (widget),
                                     FALSE,
                                     NULL,
@@ -797,7 +819,7 @@ gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
                       pango_layout_get_extents (layout, NULL, &logical_rect);
 
                       gtk_paint_layout (style,
-                                        ruler->backing_store,
+                                        priv->backing_store,
                                         gtk_widget_get_state (widget),
                                         FALSE,
                                         NULL,
@@ -824,7 +846,7 @@ gtk_deprecated_ruler_real_draw_pos (GtkDeprecatedRuler *ruler)
 {
   GtkAllocation allocation;
   GtkWidget *widget = GTK_WIDGET (ruler);
-  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
   GtkStyle *style;
   gint x, y;
   gint width, height;
@@ -866,12 +888,12 @@ gtk_deprecated_ruler_real_draw_pos (GtkDeprecatedRuler *ruler)
 	  cairo_t *cr = gdk_cairo_create(window);
 
 	  /*  If a backing store exists, restore the ruler  */
-	  if (ruler->backing_store)
+	  if (priv->backing_store)
             {
               cairo_t *cr = gdk_cairo_create(window);
 
-              gdk_cairo_set_source_pixmap (cr, ruler->backing_store, 0, 0);
-              cairo_rectangle (cr, ruler->xsrc, ruler->ysrc, bs_width, bs_height);
+              gdk_cairo_set_source_pixmap (cr, priv->backing_store, 0, 0);
+              cairo_rectangle (cr, priv->xsrc, priv->ysrc, bs_width, bs_height);
               cairo_fill (cr);
 
               cairo_destroy (cr);
@@ -879,17 +901,17 @@ gtk_deprecated_ruler_real_draw_pos (GtkDeprecatedRuler *ruler)
 
           if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
             {
-              increment = (gdouble) width / (ruler->upper - ruler->lower);
+              increment = (gdouble) width / (priv->upper - priv->lower);
 
-              x = ROUND ((ruler->position - ruler->lower) * increment) + (xthickness - bs_width) / 2 - 1;
+              x = ROUND ((priv->position - priv->lower) * increment) + (xthickness - bs_width) / 2 - 1;
               y = (height + bs_height) / 2 + ythickness;
             }
           else
             {
-              increment = (gdouble) height / (ruler->upper - ruler->lower);
+              increment = (gdouble) height / (priv->upper - priv->lower);
 
               x = (width + bs_width) / 2 + xthickness;
-              y = ROUND ((ruler->position - ruler->lower) * increment) + (ythickness - bs_height) / 2 - 1;
+              y = ROUND ((priv->position - priv->lower) * increment) + (ythickness - bs_height) / 2 - 1;
             }
 
 	  gdk_cairo_set_source_color(cr, &style->fg[gtk_widget_get_state(widget)]);
@@ -911,8 +933,8 @@ gtk_deprecated_ruler_real_draw_pos (GtkDeprecatedRuler *ruler)
 
 	  cairo_destroy (cr);
 
-	  ruler->xsrc = x;
-	  ruler->ysrc = y;
+	  priv->xsrc = x;
+	  priv->ysrc = y;
 	}
     }
 }
@@ -1154,6 +1176,7 @@ static void sp_vruler_get_preferred_height(GtkWidget *widget, gint *minimal_heig
 static void
 sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
 {
+    GtkDeprecatedRulerPrivate *priv = ruler->priv;
     gint width = 0;
     gint height = 0;
     gchar unit_str[32];
@@ -1192,7 +1215,7 @@ sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
         height = allocation.width;
     }
 
-    gtk_paint_box (style, ruler->backing_store,
+    gtk_paint_box (style, priv->backing_store,
                    GTK_STATE_NORMAL, GTK_SHADOW_NONE, NULL, widget,
                    orientation == GTK_ORIENTATION_HORIZONTAL ? "hruler" : "vruler",
                    0, 0, 
@@ -1202,8 +1225,8 @@ sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
     gdouble ruler_lower = 0;
     gdouble max_size = 0;
     gtk_deprecated_ruler_get_range(ruler, &ruler_lower, &ruler_upper, NULL, &max_size);
-    gdouble upper = ruler_upper / ruler->metric->pixels_per_unit; // upper and lower are expressed in ruler units
-    gdouble lower = ruler_lower / ruler->metric->pixels_per_unit;
+    gdouble upper = ruler_upper / priv->metric->pixels_per_unit; // upper and lower are expressed in ruler units
+    gdouble lower = ruler_lower / priv->metric->pixels_per_unit;
     /* "pixels_per_unit" should be "points_per_unit". This is the size of the unit
     * in 1/72nd's of an inch and has nothing to do with screen pixels */
 
@@ -1221,12 +1244,12 @@ sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
     *  text_width = gdk_string_width(font, unit_str), so that the result
     *  for the scale looks consistent with an accompanying vruler
     */
-    gint scale = (int)(ceil(max_size / ruler->metric->pixels_per_unit));
+    gint scale = (int)(ceil(max_size / priv->metric->pixels_per_unit));
     sprintf (unit_str, "%d", scale);
     gint text_dimension = strlen (unit_str) * digit_height + 1;
 
     for (scale = 0; scale < MAXIMUM_SCALES; scale++)
-        if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_dimension)
+        if (priv->metric->ruler_scale[scale] * fabs(increment) > 2 * text_dimension)
             break;
 
     if (scale == MAXIMUM_SCALES)
@@ -1235,8 +1258,8 @@ sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
     /* drawing starts here */
     gint length = 0;
     for (gint i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--) {
-        double subd_incr = ruler->metric->ruler_scale[scale] / 
-                    ruler->metric->subdivide[i];
+        double subd_incr = priv->metric->ruler_scale[scale] / 
+                    priv->metric->subdivide[i];
         if (subd_incr * fabs(increment) <= MINIMUM_INCR) 
             continue;
 
@@ -1268,17 +1291,17 @@ sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
             gint pos = int(Inkscape::round((cur - lower) * increment + 1e-12)) - UNUSED_PIXELS;
 
             if (orientation == GTK_ORIENTATION_HORIZONTAL) {
-                gdk_draw_line (ruler->backing_store, gc,
+                gdk_draw_line (priv->backing_store, gc,
                                pos, height + ythickness, 
                                pos, height - length + ythickness);
             } else {
-                gdk_draw_line (ruler->backing_store, gc,
+                gdk_draw_line (priv->backing_store, gc,
                                height + xthickness - length, pos,
                                height + xthickness, pos);
             }
 
             /* draw label */
-            double label_spacing_px = fabs((increment*(double)ruler->metric->ruler_scale[scale])/ruler->metric->subdivide[i]);
+            double label_spacing_px = fabs((increment*(double)priv->metric->ruler_scale[scale])/priv->metric->subdivide[i]);
             if (i == 0 && 
                 (label_spacing_px > 6*digit_height || tick_index%2 == 0 || cur == 0) && 
                 (label_spacing_px > 3*digit_height || tick_index%4 == 0 || cur == 0))
@@ -1290,14 +1313,14 @@ sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
 
                 if (orientation == GTK_ORIENTATION_HORIZONTAL) {
                     pango_layout_set_text (pango_layout, unit_str, -1);
-                    gdk_draw_layout (ruler->backing_store, gc,
+                    gdk_draw_layout (priv->backing_store, gc,
                                      pos + 2, 0, pango_layout);
                 } else {
                     for (gint j = 0; j < (int) strlen (unit_str); j++) {
                         digit_str[0] = unit_str[j];
                         pango_layout_set_text (pango_layout, digit_str, 1);
 
-                        gdk_draw_layout (ruler->backing_store, gc,
+                        gdk_draw_layout (priv->backing_store, gc,
                                          xthickness + 1, 
                                          pos + digit_height * (j) + 1,
                                          pango_layout); 
@@ -1320,11 +1343,12 @@ void sp_ruler_set_metric(GtkDeprecatedRuler *ruler, SPMetric metric)
   g_return_if_fail(ruler != NULL);
   g_return_if_fail(GTK_DEPRECATED_IS_RULER (ruler));
   g_return_if_fail((unsigned) metric < G_N_ELEMENTS(sp_ruler_metrics));
+  GtkDeprecatedRulerPrivate *priv = ruler->priv;
 
   if (metric == 0) 
 	return;
 
-  ruler->metric = const_cast<GtkDeprecatedRulerMetric *>(&sp_ruler_metrics[metric]);
+  priv->metric = const_cast<GtkDeprecatedRulerMetric *>(&sp_ruler_metrics[metric]);
 
   if (gtk_widget_is_drawable(GTK_WIDGET(ruler)))
     gtk_widget_queue_draw(GTK_WIDGET(ruler));