Merge more ruler code

(bzr r11329)

3 files changed, 161 insertions, 403 deletions

diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index 6aecc4ada..61438a7d7 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -387,9 +387,9 @@ void SPDesktopWidget::init( SPDesktopWidget *dtw )
 
     /* Horizontal ruler */
     eventbox = gtk_event_box_new ();
-    dtw->hruler = sp_hruler_new ();
+    dtw->hruler = sp_ruler_new(GTK_ORIENTATION_HORIZONTAL);
     dtw->hruler_box = eventbox;
-    sp_ruler_set_metric (GTK_DEPRECATED_RULER (dtw->hruler), SP_PT);
+    sp_ruler_set_metric(SP_RULER(dtw->hruler), SP_PT);
     gtk_widget_set_tooltip_text (dtw->hruler_box, gettext(sp_unit_get_plural (&sp_unit_get_by_id(SP_UNIT_PT))));
     gtk_container_add (GTK_CONTAINER (eventbox), dtw->hruler);
     gtk_table_attach (GTK_TABLE (canvas_tbl), eventbox, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 
@@ -400,9 +400,9 @@ void SPDesktopWidget::init( SPDesktopWidget *dtw )
 
     /* Vertical ruler */
     eventbox = gtk_event_box_new ();
-    dtw->vruler = sp_vruler_new ();
+    dtw->vruler = sp_ruler_new(GTK_ORIENTATION_VERTICAL);
     dtw->vruler_box = eventbox;
-    sp_ruler_set_metric (GTK_DEPRECATED_RULER (dtw->vruler), SP_PT);
+    sp_ruler_set_metric (SP_RULER (dtw->vruler), SP_PT);
     gtk_widget_set_tooltip_text (dtw->vruler_box, gettext(sp_unit_get_plural (&sp_unit_get_by_id(SP_UNIT_PT))));
     gtk_container_add (GTK_CONTAINER (eventbox), GTK_WIDGET (dtw->vruler));
     gtk_table_attach (GTK_TABLE (canvas_tbl), eventbox, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 
@@ -1569,10 +1569,10 @@ SPDesktopWidget::viewSetPosition (Geom::Point p)
     Geom::Point const origin = ( p - ruler_origin );
     gdouble hlower, hupper, hmax_range;
     gdouble vlower, vupper, vmax_range;
-    gtk_deprecated_ruler_get_range(GTK_DEPRECATED_RULER(hruler), &hlower, &hupper, NULL, &hmax_range);
-    gtk_deprecated_ruler_set_range(GTK_DEPRECATED_RULER(hruler), hlower, hupper, origin[Geom::X], hmax_range);
-    gtk_deprecated_ruler_get_range(GTK_DEPRECATED_RULER(vruler), &vlower, &vupper, NULL, &vmax_range);
-    gtk_deprecated_ruler_set_range(GTK_DEPRECATED_RULER(vruler), vlower, vupper, origin[Geom::Y], 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);
 }
 
 void
@@ -1596,8 +1596,8 @@ sp_desktop_widget_update_hruler (SPDesktopWidget *dtw)
     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];
-    gtk_deprecated_ruler_get_range(GTK_DEPRECATED_RULER(dtw->hruler), NULL, NULL, &position, NULL);
-    gtk_deprecated_ruler_set_range(GTK_DEPRECATED_RULER(dtw->hruler), s,  e, position, (e - s));
+    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));
 }
 
 void
@@ -1614,8 +1614,8 @@ sp_desktop_widget_update_vruler (SPDesktopWidget *dtw)
     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];
-    gtk_deprecated_ruler_get_range(GTK_DEPRECATED_RULER(dtw->vruler), NULL, NULL, &position, NULL);
-    gtk_deprecated_ruler_set_range(GTK_DEPRECATED_RULER(dtw->vruler), s, e, position, (e - s));
+    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));
 }
 
 
@@ -1627,8 +1627,8 @@ void SPDesktopWidget::namedviewModified(SPObject *obj, guint flags)
         this->dt2r = 1.0 / nv->doc_units->unittobase;
         this->ruler_origin = Geom::Point(0,0); //nv->gridorigin;   Why was the grid origin used here?
 
-        sp_ruler_set_metric(GTK_DEPRECATED_RULER (this->vruler), nv->getDefaultMetric());
-        sp_ruler_set_metric(GTK_DEPRECATED_RULER (this->hruler), nv->getDefaultMetric());
+        sp_ruler_set_metric(SP_RULER (this->vruler), nv->getDefaultMetric());
+        sp_ruler_set_metric(SP_RULER (this->hruler), nv->getDefaultMetric());
 
         /* This loops through all the grandchildren of aux toolbox,
          * and for each that it finds, it performs an sp_search_by_data_recursive(),
diff --git a/src/widgets/ruler.cpp b/src/widgets/ruler.cpp
index 9f7e44444..80735c2cd 100644
--- a/src/widgets/ruler.cpp
+++ b/src/widgets/ruler.cpp
@@ -32,10 +32,10 @@
 
 #define ROUND(x) ((int) ((x) + 0.5))
 
-struct _GtkDeprecatedRulerPrivate
+struct _SPRulerPrivate
 {
   GtkOrientation orientation;
-  GtkDeprecatedRulerMetric *metric;
+  SPRulerMetric *metric;
   
   GdkPixmap *backing_store;
   
@@ -59,16 +59,16 @@ enum {
   PROP_METRIC
 };
 
-static void     gtk_deprecated_ruler_set_property    (GObject        *object,
+static void     sp_ruler_set_property    (GObject        *object,
                                                       guint            prop_id,
                                                       const GValue   *value,
                                                       GParamSpec     *pspec);
-static void     gtk_deprecated_ruler_get_property    (GObject        *object,
+static void     sp_ruler_get_property    (GObject        *object,
                                                       guint           prop_id,
                                                       GValue         *value,
                                                       GParamSpec     *pspec);
-static void     gtk_deprecated_ruler_realize         (GtkWidget      *widget);
-static void     gtk_deprecated_ruler_unrealize       (GtkWidget      *widget);
+static void     sp_ruler_realize         (GtkWidget      *widget);
+static void     sp_ruler_unrealize       (GtkWidget      *widget);
 static void     sp_ruler_size_request                (GtkWidget      *widget,
                                                       GtkRequisition *requisition);
 
@@ -82,22 +82,22 @@ static void     sp_ruler_get_preferred_height        (GtkWidget *widget,
 						      gint *natural_height);
 #endif
 
-static void     gtk_deprecated_ruler_size_allocate   (GtkWidget      *widget,
+static void     sp_ruler_size_allocate   (GtkWidget      *widget,
                                                       GtkAllocation  *allocation);
-static gboolean gtk_deprecated_ruler_motion_notify   (GtkWidget      *widget,
+static gboolean sp_ruler_motion_notify               (GtkWidget      *widget,
                                                       GdkEventMotion *event);
-static gboolean gtk_deprecated_ruler_expose          (GtkWidget      *widget,
+static gboolean sp_ruler_expose          (GtkWidget      *widget,
                                                       GdkEventExpose *event);
-static void     gtk_deprecated_ruler_make_pixmap     (GtkDeprecatedRuler *ruler);
-static void     sp_ruler_real_draw_ticks             (GtkDeprecatedRuler *ruler);
-static void     gtk_deprecated_ruler_real_draw_pos   (GtkDeprecatedRuler *ruler);
+static void     sp_ruler_make_pixmap     (SPRuler *ruler);
+static void     sp_ruler_real_draw_ticks             (SPRuler *ruler);
+static void     sp_ruler_real_draw_pos   (SPRuler *ruler);
 
 
-#define GTK_DEPRECATED_RULER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_DEPRECATED_TYPE_RULER, GtkDeprecatedRulerPrivate))
+#define SP_RULER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), SP_TYPE_RULER, SPRulerPrivate))
 
-// Note: const casts are due to GtkDeprecatedRuler being const-broken and not scheduled for any more fixes.
+// Note: const casts are due to SPRuler being const-broken and not scheduled for any more fixes.
 /// Ruler metrics.
-static GtkDeprecatedRulerMetric const sp_ruler_metrics[] = {
+static SPRulerMetric const sp_ruler_metrics[] = {
   // NOTE: the order of records in this struct must correspond to the SPMetric enum.
   {const_cast<gchar*>("NONE"),          const_cast<gchar*>(""),   1,         { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
   {const_cast<gchar*>("millimeters"),   const_cast<gchar*>("mm"), PX_PER_MM, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
@@ -110,33 +110,33 @@ static GtkDeprecatedRulerMetric const sp_ruler_metrics[] = {
   {const_cast<gchar*>("meters"),        const_cast<gchar*>("m"),  PX_PER_M,  { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 };
 
-G_DEFINE_TYPE_WITH_CODE (GtkDeprecatedRuler, gtk_deprecated_ruler, GTK_TYPE_WIDGET,
+G_DEFINE_TYPE_WITH_CODE (SPRuler, sp_ruler, GTK_TYPE_WIDGET,
                          G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
                                                 NULL))
 
 static void
-gtk_deprecated_ruler_class_init (GtkDeprecatedRulerClass *klass)
+sp_ruler_class_init (SPRulerClass *klass)
 {
   GObjectClass   *gobject_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class  = GTK_WIDGET_CLASS (klass);
 
-  gobject_class->set_property = gtk_deprecated_ruler_set_property;
-  gobject_class->get_property = gtk_deprecated_ruler_get_property;
+  gobject_class->set_property = sp_ruler_set_property;
+  gobject_class->get_property = sp_ruler_get_property;
 
-  widget_class->realize = gtk_deprecated_ruler_realize;
-  widget_class->unrealize = gtk_deprecated_ruler_unrealize;
+  widget_class->realize = sp_ruler_realize;
+  widget_class->unrealize = sp_ruler_unrealize;
 #if GTK_CHECK_VERSION(3,0,0)
   widget_class->get_preferred_width = sp_ruler_get_preferred_width;
   widget_class->get_preferred_height = sp_ruler_get_preferred_height;
 #else
   widget_class->size_request = sp_ruler_size_request;
 #endif
-  widget_class->size_allocate = gtk_deprecated_ruler_size_allocate;
-  widget_class->motion_notify_event = gtk_deprecated_ruler_motion_notify;
-  widget_class->expose_event = gtk_deprecated_ruler_expose;
+  widget_class->size_allocate = sp_ruler_size_allocate;
+  widget_class->motion_notify_event = sp_ruler_motion_notify;
+  widget_class->expose_event = sp_ruler_expose;
 
   klass->draw_ticks = sp_ruler_real_draw_ticks;
-  klass->draw_pos = gtk_deprecated_ruler_real_draw_pos;
+  klass->draw_pos = sp_ruler_real_draw_pos;
 
   g_object_class_override_property (gobject_class,
                                     PROP_ORIENTATION,
@@ -182,7 +182,7 @@ gtk_deprecated_ruler_class_init (GtkDeprecatedRulerClass *klass)
 							0.0,
 							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
   /**
-   * GtkDeprecatedRuler:metric:
+   * SPRuler:metric:
    *
    * The metric used for the ruler.
    *
@@ -197,17 +197,17 @@ gtk_deprecated_ruler_class_init (GtkDeprecatedRulerClass *klass)
 						      SP_PX,
 						      static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
 
-  g_type_class_add_private (gobject_class, sizeof (GtkDeprecatedRulerPrivate));
+  g_type_class_add_private (gobject_class, sizeof (SPRulerPrivate));
 }
 
 static void
-gtk_deprecated_ruler_init (GtkDeprecatedRuler *ruler)
+sp_ruler_init (SPRuler *ruler)
 {
   ruler->priv = G_TYPE_INSTANCE_GET_PRIVATE(ruler,
-		                            GTK_DEPRECATED_TYPE_RULER,
-					    GtkDeprecatedRulerPrivate);
+		                            SP_TYPE_RULER,
+					    SPRulerPrivate);
 
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = ruler->priv;
 
   priv->orientation = GTK_ORIENTATION_HORIZONTAL;
 
@@ -225,7 +225,7 @@ gtk_deprecated_ruler_init (GtkDeprecatedRuler *ruler)
 
 
 /**
- * gtk_deprecated_ruler_set_range:
+ * sp_ruler_set_range:
  * @ruler: the gtkdeprecatedruler
  * @lower: the lower limit of the ruler
  * @upper: the upper limit of the ruler
@@ -236,15 +236,15 @@ gtk_deprecated_ruler_init (GtkDeprecatedRuler *ruler)
  * This sets the range of the ruler. 
  */
 void
-gtk_deprecated_ruler_set_range (GtkDeprecatedRuler *ruler,
+sp_ruler_set_range (SPRuler *ruler,
 		     gdouble   lower,
 		     gdouble   upper,
 		     gdouble   position,
 		     gdouble   max_size)
 {
-  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+  g_return_if_fail (SP_IS_RULER (ruler));
 
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = ruler->priv;
 
   g_object_freeze_notify (G_OBJECT (ruler));
   if (priv->lower != lower)
@@ -274,27 +274,27 @@ gtk_deprecated_ruler_set_range (GtkDeprecatedRuler *ruler,
 }
 
 /**
- * gtk_deprecated_ruler_get_range:
- * @ruler: a #GtkDeprecatedRuler
+ * sp_ruler_get_range:
+ * @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.
  *
- * Retrieves values indicating the range and current position of a #GtkDeprecatedRuler.
- * See gtk_deprecated_ruler_set_range().
+ * Retrieves values indicating the range and current position of a #SPRuler.
+ * See sp_ruler_set_range().
  **/
 void
-gtk_deprecated_ruler_get_range (GtkDeprecatedRuler *ruler,
+sp_ruler_get_range (SPRuler *ruler,
 		     gdouble  *lower,
 		     gdouble  *upper,
 		     gdouble  *position,
 		     gdouble  *max_size)
 {
-  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+  g_return_if_fail (SP_IS_RULER (ruler));
   
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = ruler->priv;
 
   if (lower)
     *lower = priv->lower;
@@ -307,13 +307,13 @@ gtk_deprecated_ruler_get_range (GtkDeprecatedRuler *ruler,
 }
 
 static void
-gtk_deprecated_ruler_set_property (GObject      *object,
+sp_ruler_set_property (GObject      *object,
  			guint         prop_id,
 			const GValue *value,
 			GParamSpec   *pspec)
 {
-  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (object);
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRuler *ruler = SP_RULER (object);
+  SPRulerPrivate *priv = ruler->priv;
 
   switch (prop_id)
     {
@@ -322,19 +322,19 @@ 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), priv->upper,
+      sp_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, priv->lower, g_value_get_double (value),
+      sp_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, priv->lower, priv->upper,
+      sp_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, priv->lower, priv->upper,
+      sp_ruler_set_range (ruler, priv->lower, priv->upper,
 			   priv->position,  g_value_get_double (value));
       break;
     case PROP_METRIC:
@@ -347,13 +347,13 @@ gtk_deprecated_ruler_set_property (GObject      *object,
 }
 
 static void
-gtk_deprecated_ruler_get_property (GObject      *object,
+sp_ruler_get_property (GObject      *object,
 			guint         prop_id,
 			GValue       *value,
 			GParamSpec   *pspec)
 {
-  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (object);
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRuler *ruler = SP_RULER (object);
+  SPRulerPrivate *priv = ruler->priv;
 
   switch (prop_id)
     {
@@ -384,16 +384,16 @@ gtk_deprecated_ruler_get_property (GObject      *object,
 
 /**
  * sp_ruler_get_metric:
- * @ruler: a #GtkDeprecatedRuler
+ * @ruler: a #SPRuler
  *
- * Gets the units used for a #GtkDeprecatedRuler. See sp_ruler_set_metric().
+ * Gets the units used for a #SPRuler. See sp_ruler_set_metric().
  *
  * Return value: the units currently used for @ruler
  **/
-SPMetric sp_ruler_get_metric(GtkDeprecatedRuler *ruler)
+SPMetric sp_ruler_get_metric(SPRuler *ruler)
 {
-  g_return_val_if_fail(GTK_DEPRECATED_IS_RULER(ruler), static_cast<SPMetric>(0));
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  g_return_val_if_fail(SP_IS_RULER(ruler), static_cast<SPMetric>(0));
+  SPRulerPrivate *priv = ruler->priv;
 
   for (size_t i = 0; i < G_N_ELEMENTS(sp_ruler_metrics); i++) {
     if (priv->metric == &sp_ruler_metrics[i]) {
@@ -408,34 +408,34 @@ SPMetric sp_ruler_get_metric(GtkDeprecatedRuler *ruler)
 
 
 void
-gtk_deprecated_ruler_draw_ticks (GtkDeprecatedRuler *ruler)
+sp_ruler_draw_ticks (SPRuler *ruler)
 {
-  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+  g_return_if_fail (SP_IS_RULER (ruler));
 
-  if (GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_ticks)
-    GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_ticks (ruler);
+  if (SP_RULER_GET_CLASS (ruler)->draw_ticks)
+    SP_RULER_GET_CLASS (ruler)->draw_ticks (ruler);
 }
 
 void
-gtk_deprecated_ruler_draw_pos (GtkDeprecatedRuler *ruler)
+sp_ruler_draw_pos (SPRuler *ruler)
 {
-  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+  g_return_if_fail (SP_IS_RULER (ruler));
 
-  if (GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_pos)
-     GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_pos (ruler);
+  if (SP_RULER_GET_CLASS (ruler)->draw_pos)
+     SP_RULER_GET_CLASS (ruler)->draw_pos (ruler);
 }
 
 
 static void
-gtk_deprecated_ruler_realize (GtkWidget *widget)
+sp_ruler_realize (GtkWidget *widget)
 {
   GtkAllocation allocation;
-  GtkDeprecatedRuler *ruler;
+  SPRuler *ruler;
   GdkWindow *window;
   GdkWindowAttr attributes;
   gint attributes_mask;
 
-  ruler = GTK_DEPRECATED_RULER (widget);
+  ruler = SP_RULER (widget);
 
   gtk_widget_set_realized (widget, TRUE);
 
@@ -465,14 +465,14 @@ gtk_deprecated_ruler_realize (GtkWidget *widget)
   gtk_style_set_background(gtk_widget_get_style(widget),
 		           window, GTK_STATE_ACTIVE);
 
-  gtk_deprecated_ruler_make_pixmap (ruler);
+  sp_ruler_make_pixmap (ruler);
 }
 
 static void
-gtk_deprecated_ruler_unrealize (GtkWidget *widget)
+sp_ruler_unrealize (GtkWidget *widget)
 {
-  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRuler *ruler = SP_RULER (widget);
+  SPRulerPrivate *priv = ruler->priv;
 
   if (priv->backing_store)
     {
@@ -480,13 +480,13 @@ gtk_deprecated_ruler_unrealize (GtkWidget *widget)
       priv->backing_store = NULL;
     }
 
-  GTK_WIDGET_CLASS (gtk_deprecated_ruler_parent_class)->unrealize (widget);
+  GTK_WIDGET_CLASS (sp_ruler_parent_class)->unrealize (widget);
 }
 
 static void sp_ruler_size_request(GtkWidget *widget, 
 		                  GtkRequisition *requisition)
 {
-  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (widget);
+  SPRulerPrivate *priv = SP_RULER_GET_PRIVATE (widget);
   GtkStyle *style = gtk_widget_get_style(widget);
 
   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
@@ -518,10 +518,10 @@ static void sp_ruler_get_preferred_height(GtkWidget *widget, gint *minimal_heigh
 #endif
 
 static void
-gtk_deprecated_ruler_size_allocate (GtkWidget     *widget,
+sp_ruler_size_allocate (GtkWidget     *widget,
 			 GtkAllocation *allocation)
 {
-  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
+  SPRuler *ruler = SP_RULER (widget);
 
   gtk_widget_set_allocation(widget, allocation);
 
@@ -531,51 +531,21 @@ gtk_deprecated_ruler_size_allocate (GtkWidget     *widget,
 			     allocation->x, allocation->y,
 			     allocation->width, allocation->height);
 
-      gtk_deprecated_ruler_make_pixmap (ruler);
+      sp_ruler_make_pixmap (ruler);
     }
 }
 
 static gboolean
-gtk_deprecated_ruler_motion_notify (GtkWidget      *widget,
-                         GdkEventMotion *event)
-{
-  GtkAllocation allocation;
-  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
-  gint x;
-  gint y;
-
-  gdk_event_request_motions (event);
-  x = event->x;
-  y = event->y;
-
-  gtk_widget_get_allocation(widget, &allocation);
-
-  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
-    priv->position = priv->lower + ((priv->upper - priv->lower) * x) / allocation.width;
-  else
-    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 (priv->backing_store != NULL)
-    gtk_deprecated_ruler_draw_pos (ruler);
-
-  return FALSE;
-}
-
-static gboolean
-gtk_deprecated_ruler_expose (GtkWidget      *widget,
+sp_ruler_expose (GtkWidget      *widget,
 		  GdkEventExpose *event)
 {
   if (gtk_widget_is_drawable (widget))
     {
-      GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
-      GtkDeprecatedRulerPrivate *priv = ruler->priv;
+      SPRuler *ruler = SP_RULER (widget);
+      SPRulerPrivate *priv = ruler->priv;
       cairo_t *cr;
 
-      gtk_deprecated_ruler_draw_ticks (ruler);
+      sp_ruler_draw_ticks (ruler);
       
       cr = gdk_cairo_create(gtk_widget_get_window(widget));
       gdk_cairo_set_source_pixmap (cr, priv->backing_store, 0, 0);
@@ -583,16 +553,16 @@ gtk_deprecated_ruler_expose (GtkWidget      *widget,
       cairo_fill (cr);
       cairo_destroy (cr);
       
-      gtk_deprecated_ruler_draw_pos (ruler);
+      sp_ruler_draw_pos (ruler);
     }
 
   return FALSE;
 }
 
 static void
-gtk_deprecated_ruler_make_pixmap (GtkDeprecatedRuler *ruler)
+sp_ruler_make_pixmap (SPRuler *ruler)
 {
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = ruler->priv;
   GtkAllocation allocation;
   GtkWidget *widget;
   gint width;
@@ -623,11 +593,11 @@ gtk_deprecated_ruler_make_pixmap (GtkDeprecatedRuler *ruler)
 
 
 static void
-gtk_deprecated_ruler_real_draw_pos (GtkDeprecatedRuler *ruler)
+sp_ruler_real_draw_pos (SPRuler *ruler)
 {
   GtkAllocation allocation;
   GtkWidget *widget = GTK_WIDGET (ruler);
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = ruler->priv;
   GtkStyle *style;
   gint x, y;
   gint width, height;
@@ -724,202 +694,43 @@ gtk_deprecated_ruler_real_draw_pos (GtkDeprecatedRuler *ruler)
 
 #define UNUSED_PIXELS         2     // There appear to be two pixels that are not being used at each end of the ruler
 
-static void sp_hruler_class_init    (SPHRulerClass *klass);
-static void sp_hruler_init          (SPHRuler      *hruler);
-static gint sp_hruler_motion_notify (GtkWidget      *widget, GdkEventMotion *event);
-
-static GtkWidgetClass *hruler_parent_class;
-
-GType
-sp_hruler_get_type (void)
-{
-  static GType hruler_type = 0;
-
-  if (!hruler_type)
-    {
-      static const GTypeInfo hruler_info = {
-        sizeof (SPHRulerClass),
-	NULL, NULL,
-        (GClassInitFunc) sp_hruler_class_init,
-	NULL, NULL,
-        sizeof (SPHRuler),
-	0,
-        (GInstanceInitFunc) sp_hruler_init,
-	NULL
-      };
-  
-      hruler_type = g_type_register_static (gtk_deprecated_ruler_get_type (), "SPHRuler", &hruler_info, (GTypeFlags)0);
-    }
-
-  return hruler_type;
-}
-
-static void
-sp_hruler_class_init (SPHRulerClass *klass)
+GtkWidget* sp_ruler_new(GtkOrientation orientation)
 {
-  GtkWidgetClass *widget_class;
-  GtkDeprecatedRulerClass *ruler_class;
-
-  hruler_parent_class = (GtkWidgetClass *) g_type_class_peek_parent (klass);
-
-  widget_class = (GtkWidgetClass*) klass;
-  ruler_class = (GtkDeprecatedRulerClass*) klass;
-
-  widget_class->motion_notify_event = sp_hruler_motion_notify;
-
-  ruler_class->draw_ticks = sp_ruler_real_draw_ticks;
+  return GTK_WIDGET(g_object_new(SP_TYPE_RULER, 
+		                 "orientation", orientation,
+		                 NULL));
 }
 
-static void
-sp_hruler_init (SPHRuler *hruler)
+static gboolean sp_ruler_motion_notify(GtkWidget      *widget,
+			               GdkEventMotion *event)
 {
-  GtkWidget      *widget;
-  GtkRequisition  requisition;
-  GtkStyle       *style;
-
-  widget = GTK_WIDGET (hruler);
-  gtk_widget_get_requisition (widget, &requisition);
-  style = gtk_widget_get_style (widget);
-  requisition.width = style->xthickness * 2 + 1;
-  requisition.height = style->ythickness * 2 + RULER_HEIGHT;
-}
-
-
-GtkWidget*
-sp_hruler_new (void)
-{
-  return GTK_WIDGET (g_object_new (sp_hruler_get_type (), NULL));
-}
-
-static gint
-sp_hruler_motion_notify (GtkWidget      *widget,
-			  GdkEventMotion *event)
-{
-  GtkDeprecatedRuler      *ruler;
-  gdouble        lower, upper, max_size;
   GtkAllocation  allocation;
+  SPRuler *ruler = SP_RULER(widget);
+  SPRulerPrivate *priv = ruler->priv;
   
-  g_return_val_if_fail (widget != NULL, FALSE);
-  g_return_val_if_fail (SP_IS_HRULER (widget), FALSE);
-  g_return_val_if_fail (event != NULL, FALSE);
-
-  ruler = GTK_DEPRECATED_RULER (widget);
-  gtk_deprecated_ruler_get_range (ruler, &lower, &upper, NULL, &max_size);
-  gtk_widget_get_allocation (widget, &allocation);
-  double x = event->x; //Although event->x is double according to the docs, it only appears to return integers
-  double pos = lower + (upper - lower) * (x + UNUSED_PIXELS) / (allocation.width + 2*UNUSED_PIXELS);
-
-  gtk_deprecated_ruler_set_range(ruler, lower, upper, pos, max_size);
-
-  return FALSE;
-}
-
-// vruler
-
-static void sp_vruler_class_init    (SPVRulerClass *klass);
-static void sp_vruler_init          (SPVRuler      *vruler);
-static gint sp_vruler_motion_notify (GtkWidget      *widget,
-				      GdkEventMotion *event);
-
-static GtkWidgetClass *vruler_parent_class;
-
-GType
-sp_vruler_get_type (void)
-{
-  static GType vruler_type = 0;
-
-  if (!vruler_type)
-    {
-      static const GTypeInfo vruler_info = {
-	sizeof (SPVRulerClass),
-	NULL, NULL,
-	(GClassInitFunc) sp_vruler_class_init,
-	NULL, NULL,
-	sizeof (SPVRuler),
-	0,
-	(GInstanceInitFunc) sp_vruler_init,
-	NULL
-      };
-
-      vruler_type = g_type_register_static (gtk_deprecated_ruler_get_type (), "SPVRuler", &vruler_info, (GTypeFlags)0);
-    }
-
-  return vruler_type;
-}
-
-static void
-sp_vruler_class_init (SPVRulerClass *klass)
-{
-  GtkWidgetClass *widget_class;
-  GtkDeprecatedRulerClass *ruler_class;
-
-  vruler_parent_class = (GtkWidgetClass *) g_type_class_peek_parent (klass);
-
-  widget_class = (GtkWidgetClass*) klass;
-  ruler_class = (GtkDeprecatedRulerClass*) klass;
-
-  widget_class->motion_notify_event = sp_vruler_motion_notify;
-
-#if GTK_CHECK_VERSION(3,0,0)
-  widget_class->get_preferred_width = sp_ruler_get_preferred_width;
-  widget_class->get_preferred_height = sp_ruler_get_preferred_height;
-#else
-  widget_class->size_request = sp_ruler_size_request;
-#endif
-
-  ruler_class->draw_ticks = sp_ruler_real_draw_ticks;
-}
-
-static void
-sp_vruler_init (SPVRuler *vruler)
-{
-  GtkWidget      *widget;
-  GtkRequisition  requisition;
-  GtkStyle       *style;
-
-  widget = GTK_WIDGET (vruler);
-  gtk_widget_get_requisition (widget, &requisition);
-  style = gtk_widget_get_style (widget);
-  requisition.width = style->xthickness * 2 + RULER_WIDTH;
-  requisition.height = style->ythickness * 2 + 1;
-
-  g_object_set(G_OBJECT(vruler), "orientation", GTK_ORIENTATION_VERTICAL, NULL);
-}
-
-GtkWidget*
-sp_vruler_new (void)
-{
-  return GTK_WIDGET (g_object_new (sp_vruler_get_type (), NULL));
-}
-
-
-static gint
-sp_vruler_motion_notify (GtkWidget      *widget,
-			  GdkEventMotion *event)
-{
-  GtkDeprecatedRuler      *ruler;
-  gdouble        lower, upper, max_size;
-  GtkAllocation  allocation;
+  gdk_event_request_motions(event);
+  gint x = event->x;
+  gint y = event->y;
   
-  g_return_val_if_fail (widget != NULL, FALSE);
-  g_return_val_if_fail (SP_IS_VRULER (widget), FALSE);
-  g_return_val_if_fail (event != NULL, FALSE);
-
-  ruler = GTK_DEPRECATED_RULER (widget);
-  gtk_deprecated_ruler_get_range (ruler, &lower, &upper, NULL, &max_size);
-  gtk_widget_get_allocation (widget, &allocation);
-  double y = event->y; //Although event->y is double according to the docs, it only appears to return integers
-  double pos = lower + (upper - lower) * (y + UNUSED_PIXELS) / (allocation.height + 2*UNUSED_PIXELS);
+  gtk_widget_get_allocation(widget, &allocation);
+  
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    priv->position = priv->lower + (priv->upper - priv->lower) * (x + UNUSED_PIXELS) / (allocation.width + 2*UNUSED_PIXELS);
+  else
+    priv->position = priv->lower + (priv->upper - priv->lower) * (y + UNUSED_PIXELS) / (allocation.height + 2*UNUSED_PIXELS);
 
-  gtk_deprecated_ruler_set_range(ruler, lower, upper, pos, max_size);
+  g_object_notify(G_OBJECT(ruler), "position");
 
+  /*  Make sure the ruler has been allocated already  */
+  if (priv->backing_store != NULL)
+    sp_ruler_draw_pos(ruler);
+  
   return FALSE;
 }
 
-
-static void sp_ruler_real_draw_ticks(GtkDeprecatedRuler *ruler)
+static void sp_ruler_real_draw_ticks(SPRuler *ruler)
 {
-    GtkDeprecatedRulerPrivate *priv = ruler->priv;
+    SPRulerPrivate *priv = ruler->priv;
     gint width = 0;
     gint height = 0;
     gchar unit_str[32];
@@ -967,7 +778,7 @@ static void sp_ruler_real_draw_ticks(GtkDeprecatedRuler *ruler)
     gdouble ruler_upper = 0;
     gdouble ruler_lower = 0;
     gdouble max_size = 0;
-    gtk_deprecated_ruler_get_range(ruler, &ruler_lower, &ruler_upper, NULL, &max_size);
+    sp_ruler_get_range(ruler, &ruler_lower, &ruler_upper, NULL, &max_size);
     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
@@ -1081,17 +892,17 @@ static void sp_ruler_real_draw_ticks(GtkDeprecatedRuler *ruler)
 }
 
 
-void sp_ruler_set_metric(GtkDeprecatedRuler *ruler, SPMetric metric)
+void sp_ruler_set_metric(SPRuler *ruler, SPMetric metric)
 {
   g_return_if_fail(ruler != NULL);
-  g_return_if_fail(GTK_DEPRECATED_IS_RULER (ruler));
+  g_return_if_fail(SP_IS_RULER (ruler));
   g_return_if_fail((unsigned) metric < G_N_ELEMENTS(sp_ruler_metrics));
-  GtkDeprecatedRulerPrivate *priv = ruler->priv;
+  SPRulerPrivate *priv = ruler->priv;
 
   if (metric == 0) 
 	return;
 
-  priv->metric = const_cast<GtkDeprecatedRulerMetric *>(&sp_ruler_metrics[metric]);
+  priv->metric = const_cast<SPRulerMetric *>(&sp_ruler_metrics[metric]);
 
   if (gtk_widget_is_drawable(GTK_WIDGET(ruler)))
     gtk_widget_queue_draw(GTK_WIDGET(ruler));
diff --git a/src/widgets/ruler.h b/src/widgets/ruler.h
index f7cd8cd0f..4ba4f5f21 100644
--- a/src/widgets/ruler.h
+++ b/src/widgets/ruler.h
@@ -18,45 +18,39 @@
 #include <iostream>
 #include <glib.h>
 
-#define GTK_DEPRECATED_TYPE_RULER            (gtk_deprecated_ruler_get_type ())
-#define GTK_DEPRECATED_RULER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_DEPRECATED_TYPE_RULER, GtkDeprecatedRuler))
-#define GTK_DEPRECATED_RULER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_DEPRECATED_TYPE_RULER, GtkDeprecatedRulerClass))
-#define GTK_DEPRECATED_IS_RULER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_DEPRECATED_TYPE_RULER))
-#define GTK_DEPRECATED_IS_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_DEPRECATED_TYPE_RULER))
-#define GTK_DEPRECATED_RULER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_DEPRECATED_TYPE_RULER, GtkDeprecatedRulerClass))
+#define SP_TYPE_RULER            (sp_ruler_get_type ())
+#define SP_RULER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SP_TYPE_RULER, SPRuler))
+#define SP_RULER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SP_TYPE_RULER, SPRulerClass))
+#define SP_IS_RULER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_RULER))
+#define SP_IS_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SP_TYPE_RULER))
+#define SP_RULER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SP_TYPE_RULER, SPRulerClass))
 
 
-typedef struct _GtkDeprecatedRuler         GtkDeprecatedRuler;
-typedef struct _GtkDeprecatedRulerPrivate  GtkDeprecatedRulerPrivate;
-typedef struct _GtkDeprecatedRulerClass    GtkDeprecatedRulerClass;
-typedef struct _GtkDeprecatedRulerMetric   GtkDeprecatedRulerMetric;
+typedef struct _SPRuler         SPRuler;
+typedef struct _SPRulerPrivate  SPRulerPrivate;
+typedef struct _SPRulerClass    SPRulerClass;
+typedef struct _SPRulerMetric   SPRulerMetric;
 
 /* All distances below are in 1/72nd's of an inch. (According to
  * Adobe that's a point, but points are really 1/72.27 in.)
  */
-struct _GtkDeprecatedRuler
+struct _SPRuler
 {
   GtkWidget widget;
 
   /*< private >*/
-  GtkDeprecatedRulerPrivate *priv;
+  SPRulerPrivate *priv;
 };
 
-struct _GtkDeprecatedRulerClass
+struct _SPRulerClass
 {
   GtkWidgetClass parent_class;
 
-  void (* draw_ticks) (GtkDeprecatedRuler *ruler);
-  void (* draw_pos)   (GtkDeprecatedRuler *ruler);
-
-  /* Padding for future expansion */
-  void (*_gtk_reserved1) (void);
-  void (*_gtk_reserved2) (void);
-  void (*_gtk_reserved3) (void);
-  void (*_gtk_reserved4) (void);
+  void (* draw_ticks) (SPRuler *ruler);
+  void (* draw_pos)   (SPRuler *ruler);
 };
 
-struct _GtkDeprecatedRulerMetric
+struct _SPRulerMetric
 {
   gchar const *metric_name;
   gchar const *abbrev;
@@ -68,72 +62,25 @@ struct _GtkDeprecatedRulerMetric
 };
 
 
-GType           gtk_deprecated_ruler_get_type   (void) G_GNUC_CONST;
-void            gtk_deprecated_ruler_set_range  (GtkDeprecatedRuler       *ruler,
-                                                 gdouble         lower,
-                                                 gdouble         upper,
-                                                 gdouble         position,
-                                                 gdouble         max_size);
-void            gtk_deprecated_ruler_get_range  (GtkDeprecatedRuler       *ruler,
-                                                 gdouble        *lower,
-                                                 gdouble        *upper,
-                                                 gdouble        *position,
-                                                 gdouble        *max_size);
-
-void            gtk_deprecated_ruler_draw_ticks (GtkDeprecatedRuler       *ruler);
-void            gtk_deprecated_ruler_draw_pos   (GtkDeprecatedRuler       *ruler);
-
-
-void     sp_ruler_set_metric(GtkDeprecatedRuler *ruler, SPMetric  metric);
-SPMetric sp_ruler_get_metric(GtkDeprecatedRuler *ruler);
-
-
-#define SP_HRULER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, sp_hruler_get_type (), SPHRuler)
-#define SP_HRULER_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, sp_hruler_get_type (), SPHRulerClass)
-#define SP_IS_HRULER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, sp_hruler_get_type ())
-
-
-struct SPHRuler
-{
-  GtkDeprecatedRuler ruler;
-};
-
-struct SPHRulerClass
-{
-  GtkDeprecatedRulerClass parent_class;
-};
-
-
-GType    sp_hruler_get_type (void);
-GtkWidget* sp_hruler_new      (void);
-
-
-
-// vruler
-
-
-
-#define SP_VRULER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, sp_vruler_get_type (), SPVRuler)
-#define SP_VRULER_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, sp_vruler_get_type (), SPVRulerClass)
-#define SP_IS_VRULER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, sp_vruler_get_type ())
-
-
-struct SPVRuler
-{
-  GtkDeprecatedRuler ruler;
-};
-
-struct SPVRulerClass
-{
-  GtkDeprecatedRulerClass parent_class;
-};
-
-
-GType    sp_vruler_get_type (void);
-GtkWidget* sp_vruler_new      (void);
+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_draw_ticks (SPRuler        *ruler);
+void            sp_ruler_draw_pos   (SPRuler        *ruler);
 
 
+void     sp_ruler_set_metric(SPRuler *ruler, SPMetric  metric);
+SPMetric sp_ruler_get_metric(SPRuler *ruler);
 
 #endif /* __SP_RULER_H__ */