Import deprecated GtkRuler API. Probably worth tidying :-)

Fixed bugs:
  - https://launchpad.net/bugs/802125

(bzr r11023)

5 files changed, 1372 insertions, 46 deletions

diff --git a/src/ui/widget/ruler.cpp b/src/ui/widget/ruler.cpp
index cf0241fd1..a0ad3b391 100644
--- a/src/ui/widget/ruler.cpp
+++ b/src/ui/widget/ruler.cpp
@@ -20,7 +20,6 @@
 
 #include <glibmm/i18n.h>
 
-#include <gtkmm/ruler.h>
 #include "helper/units.h"
 #include "widgets/ruler.h"
 #include "ui/widget/ruler.h"
@@ -46,7 +45,7 @@ Ruler::init(SPDesktop *dt, Gtk::Widget &w)
     _canvas_widget = &w;
     _dragging = false;
     _guide = 0;
-    sp_ruler_set_metric(GTK_RULER(_r->gobj()), SP_PT);
+    sp_ruler_set_metric(GTK_DEPRECATED_RULER(_r->gobj()), SP_PT);
     _r->set_range(-500, 500, 0, 1000);
 }
 
@@ -67,7 +66,7 @@ void
 Ruler::update_metric()
 {
     if (!_dt) return;
-    sp_ruler_set_metric(GTK_RULER(_r->gobj()), _dt->namedview->getDefaultMetric());
+    sp_ruler_set_metric(GTK_DEPRECATED_RULER(_r->gobj()), _dt->namedview->getDefaultMetric());
 }
 
 /// Returns text to be used for tooltip for ruler.
@@ -168,7 +167,7 @@ Ruler::on_button_release_event(GdkEventButton *evb)
 HRuler::HRuler()
 {
     _dt = 0;
-    _r = static_cast<Gtk::HRuler*>(Glib::wrap(static_cast<GtkWidget*> (sp_hruler_new())));
+    _r = static_cast<Gtk::Deprecated::HRuler*>(Glib::wrap(static_cast<GtkWidget*> (sp_hruler_new())));
     add(*_r);
     _horiz_f = true;
 }
@@ -181,7 +180,7 @@ HRuler::~HRuler()
 VRuler::VRuler()
 {
     _dt = 0;
-    _r = static_cast<Gtk::VRuler*>(Glib::wrap(static_cast<GtkWidget*> (sp_vruler_new())));
+    _r = static_cast<Gtk::Deprecated::VRuler*>(Glib::wrap(static_cast<GtkWidget*> (sp_vruler_new())));
     add(*_r);
     _horiz_f = false;
 }
diff --git a/src/ui/widget/ruler.h b/src/ui/widget/ruler.h
index 1a455a325..e29b8f8a4 100644
--- a/src/ui/widget/ruler.h
+++ b/src/ui/widget/ruler.h
@@ -18,9 +18,406 @@ class  SPDesktop;
 namespace Glib {
     class ustring;
 }
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkDeprecatedRuler GtkDeprecatedRuler;
+typedef struct _GtkDeprecatedRulerClass GtkDeprecatedRulerClass;
+typedef struct _GtkDeprecatedVRuler GtkDeprecatedVRuler;
+typedef struct _GtkDeprecatedVRulerClass GtkDeprecatedVRulerClass;
+typedef struct _GtkDeprecatedHRuler GtkDeprecatedHRuler;
+typedef struct _GtkDeprecatedHRulerClass GtkDeprecatedHRulerClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+// This is an import of the now-deprecated Gtk::Ruler class.
+
 namespace Gtk {
-    class Ruler;
+namespace Deprecated {
+class Ruler_Class;
+class VRuler_Class;
+class HRuler_Class;
+
+/** Base class for horizontal or vertical rulers.
+ *
+ * This is an abstract base for Gtk::HRuler and
+ * Gtk::VRuler.  Users should only instantiate those types.
+ */
+
+class Ruler : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Ruler CppObjectType;
+  typedef Ruler_Class CppClassType;
+  typedef GtkDeprecatedRuler BaseObjectType;
+  typedef GtkDeprecatedRulerClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Ruler();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Ruler_Class;
+  static CppClassType ruler_class_;
+
+  // noncopyable
+  Ruler(const Ruler&);
+  Ruler& operator=(const Ruler&);
+
+protected:
+  explicit Ruler(const Glib::ConstructParams& construct_params);
+  explicit Ruler(GtkDeprecatedRuler* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+
+
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkDeprecatedRuler*       gobj()       { return reinterpret_cast<GtkDeprecatedRuler*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkDeprecatedRuler* gobj() const { return reinterpret_cast<GtkDeprecatedRuler*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+protected:
+  Ruler();
+
+public:
+
+
+  /** Sets the desired metric of the ruler.  The possible choices are:
+   * <ul><li>Gtk::PIXELS
+   * <li>Gtk::INCHES
+   * <li>Gtk::CENTIMETERS
+   * </ul>The default metric is Gtk::PIXELS.
+   */
+  void set_metric(MetricType metric =  PIXELS);
+
+  
+  /** Gets the units used for a Gtk::Ruler. See set_metric().
+   * @return The units currently used for @a ruler
+   * 
+   *  @a Deprecated: 2.24: Gtk::Ruler has been removed from GTK 3 for being
+   * unmaintained and too specialized. There is no replacement.
+   */
+  MetricType get_metric() const;
+  
+#ifndef GTKMM_DISABLE_DEPRECATED
+
+  /** Gets the units used for a Gtk::Ruler. See set_metric().
+   * @deprecated Use the const version
+   * @return The units currently used for @a ruler
+   * 
+   *  @a Deprecated: 2.24: Gtk::Ruler has been removed from GTK 3 for being
+   * unmaintained and too specialized. There is no replacement.
+   */
+  MetricType get_metric();
+#endif // GTKMM_DISABLE_DEPRECATED
+
+
+#ifndef GTKMM_DISABLE_DEPRECATED
+
+//TODO: Remove these when we can break ABI:
+
+  /** @deprecated Use get_range() instead.
+   */
+   double get_range_lower() const;
+ 
+  /** @deprecated Use get_range() instead.
+   */
+   double get_range_upper() const;
+ #endif // GTKMM_DISABLE_DEPRECATED
+
+
+  /** sets the range of the ruler.
+   * <i>upper</i> and <i>lower</i> arguments denote the extents of the Ruler.
+   * <i>max_size</i> is the largest number displayed by the ruler.
+   * <i>position</i> gives the initial value of the ruler.
+   * Rulers do not have sane defaults so this function should always be called.
+   */
+  void set_range(double lower, double upper, double position, double max_size);
+  
+  /** Retrieves values indicating the range and current position of a Gtk::Ruler.
+   * See set_range().
+   * 
+   *  @a Deprecated: 2.24: Gtk::Ruler has been removed from GTK 3 for being
+   * unmaintained and too specialized. There is no replacement.
+   * @param lower Location to store lower limit of the ruler, or <tt>0</tt>.
+   * @param upper Location to store upper limit of the ruler, or <tt>0</tt>.
+   * @param position Location to store the current position of the mark on the ruler, or <tt>0</tt>.
+   * @param max_size Location to store the maximum size of the ruler used when calculating
+   * the space to leave for the text, or <tt>0</tt>.
+   */
+  void get_range(double& lower, double& upper, double& position, double& max_size);
+
+
+  /** draw tick marks on the ruler
+   */
+  void draw_ticks();
+
+
+  /** draw a position indicator on the ruler
+   */
+  void draw_pos();
+
+    virtual void draw_ticks_vfunc();
+
+    virtual void draw_pos_vfunc();
+
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** Lower limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_lower() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** Lower limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_lower() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** Upper limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_upper() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** Upper limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_upper() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** Position of mark on the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_position() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** Position of mark on the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_position() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** Maximum size of the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_max_size() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** Maximum size of the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_max_size() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The metric used for the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<MetricType> property_metric() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The metric used for the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<MetricType> property_metric() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+
+};
+
+
+/** Vertical Ruler */
+class VRuler : public Ruler
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VRuler CppObjectType;
+  typedef VRuler_Class CppClassType;
+  typedef GtkDeprecatedVRuler BaseObjectType;
+  typedef GtkDeprecatedVRulerClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VRuler();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VRuler_Class;
+  static CppClassType vruler_class_;
+
+  // noncopyable
+  VRuler(const VRuler&);
+  VRuler& operator=(const VRuler&);
+
+protected:
+  explicit VRuler(const Glib::ConstructParams& construct_params);
+  explicit VRuler(GtkDeprecatedVRuler* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+
+
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkDeprecatedVRuler*       gobj()       { return reinterpret_cast<GtkDeprecatedVRuler*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkDeprecatedVRuler* gobj() const { return reinterpret_cast<GtkDeprecatedVRuler*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  VRuler();
+
+
+}; //class VRuler
+
+/** Horizontal Ruler */
+class HRuler : public Ruler
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HRuler CppObjectType;
+  typedef HRuler_Class CppClassType;
+  typedef GtkDeprecatedHRuler BaseObjectType;
+  typedef GtkDeprecatedHRulerClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HRuler();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HRuler_Class;
+  static CppClassType hruler_class_;
+
+  // noncopyable
+  HRuler(const HRuler&);
+  HRuler& operator=(const HRuler&);
+
+protected:
+  explicit HRuler(const Glib::ConstructParams& construct_params);
+  explicit HRuler(GtkDeprecatedHRuler* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+
+
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkDeprecatedHRuler*       gobj()       { return reinterpret_cast<GtkDeprecatedHRuler*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkDeprecatedHRuler* gobj() const { return reinterpret_cast<GtkDeprecatedHRuler*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  HRuler();
+
+
+}; // class HRuler
+
+
 }
+}
+
+
+
 namespace Inkscape {
 namespace UI {
 namespace Widget {
@@ -41,7 +438,7 @@ protected:
     SPDesktop    *_dt;
     SPCanvasItem *_guide;
     Gtk::Widget  *_canvas_widget;
-    Gtk::Ruler   *_r;
+    Gtk::Deprecated::Ruler   *_r;
     bool         _horiz_f, _dragging;
 
     virtual bool on_button_press_event (GdkEventButton *);
diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index cd7031dea..a2f74bb75 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -367,7 +367,7 @@ void SPDesktopWidget::init( SPDesktopWidget *dtw )
     eventbox = gtk_event_box_new ();
     dtw->hruler = sp_hruler_new ();
     dtw->hruler_box = eventbox;
-    sp_ruler_set_metric (GTK_RULER (dtw->hruler), SP_PT);
+    sp_ruler_set_metric (GTK_DEPRECATED_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), 
@@ -380,7 +380,7 @@ void SPDesktopWidget::init( SPDesktopWidget *dtw )
     eventbox = gtk_event_box_new ();
     dtw->vruler = sp_vruler_new ();
     dtw->vruler_box = eventbox;
-    sp_ruler_set_metric (GTK_RULER (dtw->vruler), SP_PT);
+    sp_ruler_set_metric (GTK_DEPRECATED_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, 
@@ -1510,10 +1510,10 @@ SPDesktopWidget::viewSetPosition (Geom::Point p)
     Geom::Point const origin = ( p - ruler_origin );
     gdouble hlower, hupper, hmax_range;
     gdouble vlower, vupper, vmax_range;
-    gtk_ruler_get_range(GTK_RULER(hruler), &hlower, &hupper, NULL, &hmax_range);
-    gtk_ruler_set_range(GTK_RULER(hruler), hlower, hupper, origin[Geom::X], hmax_range);
-    gtk_ruler_get_range(GTK_RULER(vruler), &vlower, &vupper, NULL, &vmax_range);
-    gtk_ruler_set_range(GTK_RULER(vruler), vlower, vupper, origin[Geom::Y], 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);
 }
 
 void
@@ -1537,8 +1537,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_ruler_get_range(GTK_RULER(dtw->hruler), NULL, NULL, &position, NULL);
-    gtk_ruler_set_range(GTK_RULER(dtw->hruler), s,  e, position, (e - s));
+    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));
 }
 
 void
@@ -1555,8 +1555,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_ruler_get_range(GTK_RULER(dtw->vruler), NULL, NULL, &position, NULL);
-    gtk_ruler_set_range(GTK_RULER(dtw->vruler), s, e, position, (e - s));
+    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));
 }
 
 
@@ -1568,8 +1568,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_RULER (this->vruler), nv->getDefaultMetric());
-        sp_ruler_set_metric(GTK_RULER (this->hruler), nv->getDefaultMetric());
+        sp_ruler_set_metric(GTK_DEPRECATED_RULER (this->vruler), nv->getDefaultMetric());
+        sp_ruler_set_metric(GTK_DEPRECATED_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 74384161e..8dbd771a6 100644
--- a/src/widgets/ruler.cpp
+++ b/src/widgets/ruler.cpp
@@ -22,13 +22,859 @@
 #include "ruler.h"
 #include "unit-constants.h"
 #include "round.h"
+#include <glibmm/i18n.h>
+
+#define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
 
 #define MINIMUM_INCR          5
 #define MAXIMUM_SUBDIVIDE     5
 #define MAXIMUM_SCALES        10
+
+#define ROUND(x) ((int) ((x) + 0.5))
+
+enum {
+  PROP_0,
+  PROP_ORIENTATION,
+  PROP_LOWER,
+  PROP_UPPER,
+  PROP_POSITION,
+  PROP_MAX_SIZE,
+  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,
+                                                      GParamSpec     *pspec);
+static void     gtk_deprecated_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     gtk_deprecated_ruler_size_request    (GtkWidget      *widget,
+                                                      GtkRequisition *requisition);
+static void     gtk_deprecated_ruler_size_allocate   (GtkWidget      *widget,
+                                                      GtkAllocation  *allocation);
+static gboolean gtk_deprecated_ruler_motion_notify   (GtkWidget      *widget,
+                                                      GdkEventMotion *event);
+static gboolean gtk_deprecated_ruler_expose          (GtkWidget      *widget,
+                                                      GdkEventExpose *event);
+static void     gtk_deprecated_ruler_make_pixmap     (GtkDeprecatedRuler       *ruler);
+static void     gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler       *ruler);
+static void     gtk_deprecated_ruler_real_draw_pos   (GtkDeprecatedRuler       *ruler);
+
+
+static const GtkDeprecatedRulerMetric ruler_metrics[] =
+{
+  { "Pixel", "Pi", 1.0, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
+  { "Inches", "In", 72.0, { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 }, { 1, 2, 4, 8, 16 }},
+  { "Centimeters", "Cn", 28.35, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
+};
+#define GTK_DEPRECATED_RULER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_DEPRECATED_TYPE_RULER, GtkDeprecatedRulerPrivate))
+
+
+G_DEFINE_TYPE_WITH_CODE (GtkDeprecatedRuler, gtk_deprecated_ruler, GTK_TYPE_WIDGET,
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
+                                                NULL))
+
+static void
+gtk_deprecated_ruler_class_init (GtkDeprecatedRulerClass *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;
+
+  widget_class->realize = gtk_deprecated_ruler_realize;
+  widget_class->unrealize = gtk_deprecated_ruler_unrealize;
+  widget_class->size_request = gtk_deprecated_ruler_size_request;
+  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;
+
+  klass->draw_ticks = gtk_deprecated_ruler_real_draw_ticks;
+  klass->draw_pos = gtk_deprecated_ruler_real_draw_pos;
+
+  g_object_class_override_property (gobject_class,
+                                    PROP_ORIENTATION,
+                                    "orientation");
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_LOWER,
+                                   g_param_spec_double ("lower",
+							_("Lower"),
+							_("Lower limit of ruler"),
+							-G_MAXDOUBLE,
+							G_MAXDOUBLE,
+							0.0,
+							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_UPPER,
+                                   g_param_spec_double ("upper",
+							_("Upper"),
+							_("Upper limit of ruler"),
+							-G_MAXDOUBLE,
+							G_MAXDOUBLE,
+							0.0,
+							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_POSITION,
+                                   g_param_spec_double ("position",
+							_("Position"),
+							_("Position of mark on the ruler"),
+							-G_MAXDOUBLE,
+							G_MAXDOUBLE,
+							0.0,
+							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_MAX_SIZE,
+                                   g_param_spec_double ("max-size",
+							_("Max Size"),
+							_("Maximum size of the ruler"),
+							-G_MAXDOUBLE,
+							G_MAXDOUBLE,
+							0.0,
+							static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
+  /**
+   * GtkDeprecatedRuler:metric:
+   *
+   * The metric used for the ruler.
+   */
+  g_object_class_install_property (gobject_class,
+                                   PROP_METRIC,
+                                   g_param_spec_enum ("metric",
+						      _("Metric"),
+						      _("The metric used for the ruler"),
+						      GTK_TYPE_METRIC_TYPE, 
+						      GTK_PIXELS,
+						      static_cast<GParamFlags>(GTK_PARAM_READWRITE)));  
+
+  g_type_class_add_private (gobject_class, sizeof (GtkDeprecatedRulerPrivate));
+}
+
+static void
+gtk_deprecated_ruler_init (GtkDeprecatedRuler *ruler)
+{
+  GtkWidget *widget = GTK_WIDGET (ruler);
+  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+
+  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
+
+  widget->requisition.width  = widget->style->xthickness * 2 + 1;
+  widget->requisition.height = widget->style->ythickness * 2 + RULER_WIDTH;
+
+  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;
+
+  gtk_deprecated_ruler_set_metric (ruler, GTK_PIXELS);
+}
+
+
+/**
+ * gtk_deprecated_ruler_set_range:
+ * @ruler: the gtkdeprecatedruler
+ * @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
+ *
+ * This sets the range of the ruler. 
+ */
+void
+gtk_deprecated_ruler_set_range (GtkDeprecatedRuler *ruler,
+		     gdouble   lower,
+		     gdouble   upper,
+		     gdouble   position,
+		     gdouble   max_size)
+{
+  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+
+  g_object_freeze_notify (G_OBJECT (ruler));
+  if (ruler->lower != lower)
+    {
+      ruler->lower = lower;
+      g_object_notify (G_OBJECT (ruler), "lower");
+    }
+  if (ruler->upper != upper)
+    {
+      ruler->upper = upper;
+      g_object_notify (G_OBJECT (ruler), "upper");
+    }
+  if (ruler->position != position)
+    {
+      ruler->position = position;
+      g_object_notify (G_OBJECT (ruler), "position");
+    }
+  if (ruler->max_size != max_size)
+    {
+      ruler->max_size = max_size;
+      g_object_notify (G_OBJECT (ruler), "max-size");
+    }
+  g_object_thaw_notify (G_OBJECT (ruler));
+
+  if (gtk_widget_is_drawable (GTK_WIDGET (ruler)))
+    gtk_widget_queue_draw (GTK_WIDGET (ruler));
+}
+
+/**
+ * gtk_deprecated_ruler_get_range:
+ * @ruler: a #GtkDeprecatedRuler
+ * @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().
+ **/
+void
+gtk_deprecated_ruler_get_range (GtkDeprecatedRuler *ruler,
+		     gdouble  *lower,
+		     gdouble  *upper,
+		     gdouble  *position,
+		     gdouble  *max_size)
+{
+  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+
+  if (lower)
+    *lower = ruler->lower;
+  if (upper)
+    *upper = ruler->upper;
+  if (position)
+    *position = ruler->position;
+  if (max_size)
+    *max_size = ruler->max_size;
+}
+
+static void
+gtk_deprecated_ruler_set_property (GObject      *object,
+ 			guint         prop_id,
+			const GValue *value,
+			GParamSpec   *pspec)
+{
+  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (object);
+  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      priv->orientation = static_cast<GtkOrientation>(g_value_get_enum (value));
+      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);
+      break;
+    case PROP_UPPER:
+      gtk_deprecated_ruler_set_range (ruler, ruler->lower, g_value_get_double (value),
+			   ruler->position, ruler->max_size);
+      break;
+    case PROP_POSITION:
+      gtk_deprecated_ruler_set_range (ruler, ruler->lower, ruler->upper,
+			   g_value_get_double (value), ruler->max_size);
+      break;
+    case PROP_MAX_SIZE:
+      gtk_deprecated_ruler_set_range (ruler, ruler->lower, ruler->upper,
+			   ruler->position,  g_value_get_double (value));
+      break;
+    case PROP_METRIC:
+      gtk_deprecated_ruler_set_metric (ruler, static_cast<GtkMetricType>(g_value_get_enum (value)));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_deprecated_ruler_get_property (GObject      *object,
+			guint         prop_id,
+			GValue       *value,
+			GParamSpec   *pspec)
+{
+  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (object);
+  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      g_value_set_enum (value, priv->orientation);
+      break;
+    case PROP_LOWER:
+      g_value_set_double (value, ruler->lower);
+      break;
+    case PROP_UPPER:
+      g_value_set_double (value, ruler->upper);
+      break;
+    case PROP_POSITION:
+      g_value_set_double (value, ruler->position);
+      break;
+    case PROP_MAX_SIZE:
+      g_value_set_double (value, ruler->max_size);
+      break;
+    case PROP_METRIC:
+      g_value_set_enum (value, gtk_deprecated_ruler_get_metric (ruler));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+void
+gtk_deprecated_ruler_set_metric (GtkDeprecatedRuler      *ruler,
+		      GtkMetricType  metric)
+{
+  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+
+  ruler->metric = (GtkDeprecatedRulerMetric *) &ruler_metrics[metric];
+
+  if (gtk_widget_is_drawable (GTK_WIDGET (ruler)))
+    gtk_widget_queue_draw (GTK_WIDGET (ruler));
+
+  g_object_notify (G_OBJECT (ruler), "metric");
+}
+
+/**
+ * gtk_deprecated_ruler_get_metric:
+ * @ruler: a #GtkDeprecatedRuler
+ *
+ * Gets the units used for a #GtkDeprecatedRuler. See gtk_deprecated_ruler_set_metric().
+ *
+ * Return value: the units currently used for @ruler
+ **/
+GtkMetricType
+gtk_deprecated_ruler_get_metric (GtkDeprecatedRuler *ruler)
+{
+  gint i;
+
+  g_return_val_if_fail (GTK_DEPRECATED_IS_RULER (ruler), static_cast<GtkMetricType>(0));
+
+  for (i = 0; i < G_N_ELEMENTS (ruler_metrics); i++)
+    if (ruler->metric == &ruler_metrics[i])
+      return static_cast<GtkMetricType>(i);
+
+  g_assert_not_reached ();
+
+  return static_cast<GtkMetricType>(0);
+}
+
+
+void
+gtk_deprecated_ruler_draw_ticks (GtkDeprecatedRuler *ruler)
+{
+  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+
+  if (GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_ticks)
+    GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_ticks (ruler);
+}
+
+void
+gtk_deprecated_ruler_draw_pos (GtkDeprecatedRuler *ruler)
+{
+  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
+
+  if (GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_pos)
+     GTK_DEPRECATED_RULER_GET_CLASS (ruler)->draw_pos (ruler);
+}
+
+
+static void
+gtk_deprecated_ruler_realize (GtkWidget *widget)
+{
+  GtkDeprecatedRuler *ruler;
+  GdkWindowAttr attributes;
+  gint attributes_mask;
+
+  ruler = GTK_DEPRECATED_RULER (widget);
+
+  gtk_widget_set_realized (widget, TRUE);
+
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.x = widget->allocation.x;
+  attributes.y = widget->allocation.y;
+  attributes.width = widget->allocation.width;
+  attributes.height = widget->allocation.height;
+  attributes.wclass = GDK_INPUT_OUTPUT;
+  attributes.visual = gtk_widget_get_visual (widget);
+  attributes.colormap = gtk_widget_get_colormap (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 | GDK_WA_COLORMAP;
+
+  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
+  gdk_window_set_user_data (widget->window, ruler);
+
+  widget->style = gtk_style_attach (widget->style, widget->window);
+  gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
+
+  gtk_deprecated_ruler_make_pixmap (ruler);
+}
+
+static void
+gtk_deprecated_ruler_unrealize (GtkWidget *widget)
+{
+  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
+
+  if (ruler->backing_store)
+    {
+      g_object_unref (ruler->backing_store);
+      ruler->backing_store = NULL;
+    }
+
+  GTK_WIDGET_CLASS (gtk_deprecated_ruler_parent_class)->unrealize (widget);
+}
+
+static void
+gtk_deprecated_ruler_size_request (GtkWidget      *widget,
+                        GtkRequisition *requisition)
+{
+  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (widget);
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      requisition->width  = widget->style->xthickness * 2 + 1;
+      requisition->height = widget->style->ythickness * 2 + RULER_WIDTH;
+    }
+  else
+    {
+      requisition->width  = widget->style->xthickness * 2 + RULER_WIDTH;
+      requisition->height = widget->style->ythickness * 2 + 1;
+    }
+}
+
+static void
+gtk_deprecated_ruler_size_allocate (GtkWidget     *widget,
+			 GtkAllocation *allocation)
+{
+  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
+
+  widget->allocation = *allocation;
+
+  if (gtk_widget_get_realized (widget))
+    {
+      gdk_window_move_resize (widget->window,
+			      allocation->x, allocation->y,
+			      allocation->width, allocation->height);
+
+      gtk_deprecated_ruler_make_pixmap (ruler);
+    }
+}
+
+static gboolean
+gtk_deprecated_ruler_motion_notify (GtkWidget      *widget,
+                         GdkEventMotion *event)
+{
+  GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
+  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (widget);
+  gint x;
+  gint y;
+
+  gdk_event_request_motions (event);
+  x = event->x;
+  y = event->y;
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * x) / widget->allocation.width;
+  else
+    ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * y) / widget->allocation.height;
+
+  g_object_notify (G_OBJECT (ruler), "position");
+
+  /*  Make sure the ruler has been allocated already  */
+  if (ruler->backing_store != NULL)
+    gtk_deprecated_ruler_draw_pos (ruler);
+
+  return FALSE;
+}
+
+static gboolean
+gtk_deprecated_ruler_expose (GtkWidget      *widget,
+		  GdkEventExpose *event)
+{
+  if (gtk_widget_is_drawable (widget))
+    {
+      GtkDeprecatedRuler *ruler = GTK_DEPRECATED_RULER (widget);
+      cairo_t *cr;
+
+      gtk_deprecated_ruler_draw_ticks (ruler);
+      
+      cr = gdk_cairo_create (widget->window);
+      gdk_cairo_set_source_pixmap (cr, ruler->backing_store, 0, 0);
+      gdk_cairo_rectangle (cr, &event->area);
+      cairo_fill (cr);
+      cairo_destroy (cr);
+      
+      gtk_deprecated_ruler_draw_pos (ruler);
+    }
+
+  return FALSE;
+}
+
+static void
+gtk_deprecated_ruler_make_pixmap (GtkDeprecatedRuler *ruler)
+{
+  GtkWidget *widget;
+  gint width;
+  gint height;
+
+  widget = GTK_WIDGET (ruler);
+
+  if (ruler->backing_store)
+    {
+      gdk_drawable_get_size (ruler->backing_store, &width, &height);
+      if ((width == widget->allocation.width) &&
+	  (height == widget->allocation.height))
+	return;
+
+      g_object_unref (ruler->backing_store);
+    }
+
+  ruler->backing_store = gdk_pixmap_new (widget->window,
+					 widget->allocation.width,
+					 widget->allocation.height,
+					 -1);
+
+  ruler->xsrc = 0;
+  ruler->ysrc = 0;
+}
+
+static void
+gtk_deprecated_ruler_real_draw_ticks (GtkDeprecatedRuler *ruler)
+{
+  GtkWidget *widget = GTK_WIDGET (ruler);
+  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+  cairo_t *cr;
+  gint i, j;
+  gint width, height;
+  gint xthickness;
+  gint ythickness;
+  gint length, ideal_length;
+  gdouble lower, upper;		/* Upper and lower limits, in ruler units */
+  gdouble increment;		/* Number of pixels per unit */
+  gint scale;			/* Number of units per major unit */
+  gdouble subd_incr;
+  gdouble start, end, cur;
+  gchar unit_str[32];
+  gint digit_height;
+  gint digit_offset;
+  gint text_width;
+  gint text_height;
+  gint pos;
+  PangoLayout *layout;
+  PangoRectangle logical_rect, ink_rect;
+
+  if (!gtk_widget_is_drawable (widget))
+    return;
+
+  xthickness = widget->style->xthickness;
+  ythickness = widget->style->ythickness;
+
+  layout = gtk_widget_create_pango_layout (widget, "012456789");
+  pango_layout_get_extents (layout, &ink_rect, &logical_rect);
+
+  digit_height = PANGO_PIXELS (ink_rect.height) + 2;
+  digit_offset = ink_rect.y;
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      width = widget->allocation.width;
+      height = widget->allocation.height - ythickness * 2;
+    }
+  else
+    {
+      width = widget->allocation.height;
+      height = widget->allocation.width - ythickness * 2;
+    }
+
+#define DETAILE(priv) (priv->orientation == GTK_ORIENTATION_HORIZONTAL ? "hruler" : "vruler");
+
+  gtk_paint_box (widget->style, ruler->backing_store,
+		 GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+		 NULL, widget,
+                 priv->orientation == GTK_ORIENTATION_HORIZONTAL ?
+                 "hruler" : "vruler",
+		 0, 0,
+		 widget->allocation.width, widget->allocation.height);
+
+  cr = gdk_cairo_create (ruler->backing_store);
+  gdk_cairo_set_source_color (cr, &widget->style->fg[widget->state]);
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      cairo_rectangle (cr,
+                       xthickness,
+                       height + ythickness,
+                       widget->allocation.width - 2 * xthickness,
+                       1);
+    }
+  else
+    {
+      cairo_rectangle (cr,
+                       height + xthickness,
+                       ythickness,
+                       1,
+                       widget->allocation.height - 2 * ythickness);
+    }
+
+  upper = ruler->upper / ruler->metric->pixels_per_unit;
+  lower = ruler->lower / ruler->metric->pixels_per_unit;
+
+  if ((upper - lower) == 0)
+    goto out;
+
+  increment = (gdouble) width / (upper - lower);
+
+  /* determine the scale H
+   *  We calculate the text size as for the vruler instead of using
+   *  text_width = gdk_string_width(font, unit_str), so that the result
+   *  for the scale looks consistent with an accompanying vruler
+   */
+  /* determine the scale V
+   *   use the maximum extents of the ruler to determine the largest
+   *   possible number to be displayed.  Calculate the height in pixels
+   *   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);
+  g_snprintf (unit_str, sizeof (unit_str), "%d", scale);
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      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)
+          break;
+    }
+  else
+    {
+      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)
+          break;
+    }
+
+  if (scale == MAXIMUM_SCALES)
+    scale = MAXIMUM_SCALES - 1;
+
+  /* drawing starts here */
+  length = 0;
+  for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--)
+    {
+      subd_incr = (gdouble) ruler->metric->ruler_scale[scale] /
+	          (gdouble) ruler->metric->subdivide[i];
+      if (subd_incr * fabs(increment) <= MINIMUM_INCR)
+	continue;
+
+      /* Calculate the length of the tickmarks. Make sure that
+       * this length increases for each set of ticks
+       */
+      ideal_length = height / (i + 1) - 1;
+      if (ideal_length > ++length)
+	length = ideal_length;
+
+      if (lower < upper)
+	{
+	  start = floor (lower / subd_incr) * subd_incr;
+	  end   = ceil  (upper / subd_incr) * subd_incr;
+	}
+      else
+	{
+	  start = floor (upper / subd_incr) * subd_incr;
+	  end   = ceil  (lower / subd_incr) * subd_incr;
+	}
+
+      for (cur = start; cur <= end; cur += subd_incr)
+	{
+	  pos = ROUND ((cur - lower) * increment);
+
+          if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+            {
+              cairo_rectangle (cr,
+                               pos, height + ythickness - length,
+                               1,   length);
+            }
+          else
+            {
+              cairo_rectangle (cr,
+                               height + xthickness - length, pos,
+                               length,                       1);
+            }
+
+	  /* draw label */
+	  if (i == 0)
+	    {
+	      g_snprintf (unit_str, sizeof (unit_str), "%d", (int) cur);
+
+              if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+                {
+                  pango_layout_set_text (layout, unit_str, -1);
+                  pango_layout_get_extents (layout, &logical_rect, NULL);
+
+                  gtk_paint_layout (widget->style,
+                                    ruler->backing_store,
+                                    gtk_widget_get_state (widget),
+                                    FALSE,
+                                    NULL,
+                                    widget,
+                                    "hruler",
+                                    pos + 2, ythickness + PANGO_PIXELS (logical_rect.y - digit_offset),
+                                    layout);
+                }
+              else
+                {
+                  for (j = 0; j < (int) strlen (unit_str); j++)
+                    {
+                      pango_layout_set_text (layout, unit_str + j, 1);
+                      pango_layout_get_extents (layout, NULL, &logical_rect);
+
+                      gtk_paint_layout (widget->style,
+                                        ruler->backing_store,
+                                        gtk_widget_get_state (widget),
+                                        FALSE,
+                                        NULL,
+                                        widget,
+                                        "vruler",
+                                        xthickness + 1,
+                                        pos + digit_height * j + 2 + PANGO_PIXELS (logical_rect.y - digit_offset),
+                                        layout);
+                    }
+                }
+	    }
+	}
+    }
+
+  cairo_fill (cr);
+out:
+  cairo_destroy (cr);
+
+  g_object_unref (layout);
+}
+
+static void
+gtk_deprecated_ruler_real_draw_pos (GtkDeprecatedRuler *ruler)
+{
+  GtkWidget *widget = GTK_WIDGET (ruler);
+  GtkDeprecatedRulerPrivate *priv = GTK_DEPRECATED_RULER_GET_PRIVATE (ruler);
+  gint x, y;
+  gint width, height;
+  gint bs_width, bs_height;
+  gint xthickness;
+  gint ythickness;
+  gdouble increment;
+
+  if (gtk_widget_is_drawable (widget))
+    {
+      xthickness = widget->style->xthickness;
+      ythickness = widget->style->ythickness;
+      width = widget->allocation.width;
+      height = widget->allocation.height;
+
+      if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+        {
+          height -= ythickness * 2;
+
+          bs_width = height / 2 + 2;
+          bs_width |= 1;  /* make sure it's odd */
+          bs_height = bs_width / 2 + 1;
+        }
+      else
+        {
+          width -= xthickness * 2;
+
+          bs_height = width / 2 + 2;
+          bs_height |= 1;  /* make sure it's odd */
+          bs_width = bs_height / 2 + 1;
+        }
+
+      if ((bs_width > 0) && (bs_height > 0))
+	{
+	  cairo_t *cr = gdk_cairo_create (widget->window);
+
+	  /*  If a backing store exists, restore the ruler  */
+	  if (ruler->backing_store)
+            {
+              cairo_t *cr = gdk_cairo_create (widget->window);
+
+              gdk_cairo_set_source_pixmap (cr, ruler->backing_store, 0, 0);
+              cairo_rectangle (cr, ruler->xsrc, ruler->ysrc, bs_width, bs_height);
+              cairo_fill (cr);
+
+              cairo_destroy (cr);
+            }
+
+          if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+            {
+              increment = (gdouble) width / (ruler->upper - ruler->lower);
+
+              x = ROUND ((ruler->position - ruler->lower) * increment) + (xthickness - bs_width) / 2 - 1;
+              y = (height + bs_height) / 2 + ythickness;
+            }
+          else
+            {
+              increment = (gdouble) height / (ruler->upper - ruler->lower);
+
+              x = (width + bs_width) / 2 + xthickness;
+              y = ROUND ((ruler->position - ruler->lower) * increment) + (ythickness - bs_height) / 2 - 1;
+            }
+
+	  gdk_cairo_set_source_color (cr, &widget->style->fg[widget->state]);
+
+	  cairo_move_to (cr, x, y);
+
+          if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+            {
+              cairo_line_to (cr, x + bs_width / 2.0, y + bs_height);
+              cairo_line_to (cr, x + bs_width,       y);
+            }
+          else
+            {
+              cairo_line_to (cr, x + bs_width, y + bs_height / 2.0);
+              cairo_line_to (cr, x,            y + bs_height);
+            }
+
+	  cairo_fill (cr);
+
+	  cairo_destroy (cr);
+
+	  ruler->xsrc = x;
+	  ruler->ysrc = y;
+	}
+    }
+}
+
+
+
+
+
 #define UNUSED_PIXELS         2     // There appear to be two pixels that are not being used at each end of the ruler
 
-static void sp_ruler_common_draw_ticks (GtkRuler *ruler);
+static void sp_ruler_common_draw_ticks (GtkDeprecatedRuler *ruler);
 
 static void sp_hruler_class_init    (SPHRulerClass *klass);
 static void sp_hruler_init          (SPHRuler      *hruler);
@@ -54,7 +900,7 @@ sp_hruler_get_type (void)
 	NULL
       };
   
-      hruler_type = g_type_register_static (gtk_ruler_get_type (), "SPHRuler", &hruler_info, (GTypeFlags)0);
+      hruler_type = g_type_register_static (gtk_deprecated_ruler_get_type (), "SPHRuler", &hruler_info, (GTypeFlags)0);
     }
 
   return hruler_type;
@@ -64,12 +910,12 @@ static void
 sp_hruler_class_init (SPHRulerClass *klass)
 {
   GtkWidgetClass *widget_class;
-  GtkRulerClass *ruler_class;
+  GtkDeprecatedRulerClass *ruler_class;
 
   hruler_parent_class = (GtkWidgetClass *) g_type_class_peek_parent (klass);
 
   widget_class = (GtkWidgetClass*) klass;
-  ruler_class = (GtkRulerClass*) klass;
+  ruler_class = (GtkDeprecatedRulerClass*) klass;
 
   widget_class->motion_notify_event = sp_hruler_motion_notify;
 
@@ -101,7 +947,7 @@ static gint
 sp_hruler_motion_notify (GtkWidget      *widget,
 			  GdkEventMotion *event)
 {
-  GtkRuler      *ruler;
+  GtkDeprecatedRuler      *ruler;
   gdouble        lower, upper, max_size;
   GtkAllocation  allocation;
   
@@ -109,13 +955,13 @@ sp_hruler_motion_notify (GtkWidget      *widget,
   g_return_val_if_fail (SP_IS_HRULER (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
-  ruler = GTK_RULER (widget);
-  gtk_ruler_get_range (ruler, &lower, &upper, NULL, &max_size);
+  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_ruler_set_range(ruler, lower, upper, pos, max_size);
+  gtk_deprecated_ruler_set_range(ruler, lower, upper, pos, max_size);
 
   return FALSE;
 }
@@ -148,7 +994,7 @@ sp_vruler_get_type (void)
 	NULL
       };
 
-      vruler_type = g_type_register_static (gtk_ruler_get_type (), "SPVRuler", &vruler_info, (GTypeFlags)0);
+      vruler_type = g_type_register_static (gtk_deprecated_ruler_get_type (), "SPVRuler", &vruler_info, (GTypeFlags)0);
     }
 
   return vruler_type;
@@ -158,12 +1004,12 @@ static void
 sp_vruler_class_init (SPVRulerClass *klass)
 {
   GtkWidgetClass *widget_class;
-  GtkRulerClass *ruler_class;
+  GtkDeprecatedRulerClass *ruler_class;
 
   vruler_parent_class = (GtkWidgetClass *) g_type_class_peek_parent (klass);
 
   widget_class = (GtkWidgetClass*) klass;
-  ruler_class = (GtkRulerClass*) klass;
+  ruler_class = (GtkDeprecatedRulerClass*) klass;
 
   widget_class->motion_notify_event = sp_vruler_motion_notify;
   widget_class->size_request = sp_vruler_size_request;
@@ -198,7 +1044,7 @@ static gint
 sp_vruler_motion_notify (GtkWidget      *widget,
 			  GdkEventMotion *event)
 {
-  GtkRuler      *ruler;
+  GtkDeprecatedRuler      *ruler;
   gdouble        lower, upper, max_size;
   GtkAllocation  allocation;
   
@@ -206,13 +1052,13 @@ sp_vruler_motion_notify (GtkWidget      *widget,
   g_return_val_if_fail (SP_IS_VRULER (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
-  ruler = GTK_RULER (widget);
-  gtk_ruler_get_range (ruler, &lower, &upper, NULL, &max_size);
+  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_ruler_set_range(ruler, lower, upper, pos, max_size);
+  gtk_deprecated_ruler_set_range(ruler, lower, upper, pos, max_size);
 
   return FALSE;
 }
@@ -225,7 +1071,7 @@ sp_vruler_size_request (GtkWidget *widget, GtkRequisition *requisition)
 }
 
 static void
-sp_ruler_common_draw_ticks(GtkRuler *ruler)
+sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
 {
     gint width = 0;
     gint height = 0;
@@ -274,7 +1120,7 @@ sp_ruler_common_draw_ticks(GtkRuler *ruler)
     gdouble ruler_upper = 0;
     gdouble ruler_lower = 0;
     gdouble max_size = 0;
-    gtk_ruler_get_range(ruler, &ruler_lower, &ruler_upper, NULL, &max_size);
+    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;
     /* "pixels_per_unit" should be "points_per_unit". This is the size of the unit
@@ -387,9 +1233,9 @@ sp_ruler_common_draw_ticks(GtkRuler *ruler)
     }
 }
 
-// Note: const casts are due to GtkRuler being const-broken and not scheduled for any more fixes.
+// Note: const casts are due to GtkDeprecatedRuler being const-broken and not scheduled for any more fixes.
 /// Ruler metrics.
-static GtkRulerMetric const sp_ruler_metrics[] = {
+static GtkDeprecatedRulerMetric 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 }},
@@ -403,17 +1249,17 @@ static GtkRulerMetric const sp_ruler_metrics[] = {
 };
 
 void
-sp_ruler_set_metric (GtkRuler *ruler,
+sp_ruler_set_metric (GtkDeprecatedRuler *ruler,
 		     SPMetric  metric)
 {
   g_return_if_fail (ruler != NULL);
-  g_return_if_fail (GTK_IS_RULER (ruler));
+  g_return_if_fail (GTK_DEPRECATED_IS_RULER (ruler));
   g_return_if_fail((unsigned) metric < G_N_ELEMENTS(sp_ruler_metrics));
 
   if (metric == 0) 
 	return;
 
-  ruler->metric = const_cast<GtkRulerMetric *>(&sp_ruler_metrics[metric]);
+  ruler->metric = const_cast<GtkDeprecatedRulerMetric *>(&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 a774f12ef..3ead23d96 100644
--- a/src/widgets/ruler.h
+++ b/src/widgets/ruler.h
@@ -18,8 +18,92 @@
 #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))
 
-void sp_ruler_set_metric (GtkRuler * ruler, SPMetric  metric);
+
+typedef struct _GtkDeprecatedRuler        GtkDeprecatedRuler;
+typedef struct _GtkDeprecatedRulerClass   GtkDeprecatedRulerClass;
+typedef struct _GtkDeprecatedRulerMetric  GtkDeprecatedRulerMetric;
+
+/* 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
+{
+  GtkWidget widget;
+
+  GdkPixmap *GSEAL (backing_store);
+  GdkGC *GSEAL (non_gr_exp_gc);		/* unused */
+  GtkDeprecatedRulerMetric *GSEAL (metric);
+  gint GSEAL (xsrc);
+  gint GSEAL (ysrc);
+  gint GSEAL (slider_size);
+
+  /* The upper limit of the ruler (in points) */
+  gdouble GSEAL (lower);
+  /* The lower limit of the ruler */
+  gdouble GSEAL (upper);
+  /* The position of the mark on the ruler */
+  gdouble GSEAL (position);
+  /* The maximum size of the ruler */
+  gdouble GSEAL (max_size);
+};
+
+struct _GtkDeprecatedRulerClass
+{
+  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);
+};
+
+struct _GtkDeprecatedRulerMetric
+{
+  gchar *metric_name;
+  gchar *abbrev;
+  /* This 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 */
+  gdouble pixels_per_unit;
+  gdouble ruler_scale[10];
+  gint subdivide[5];        /* five possible modes of subdivision */
+};
+
+
+GType           gtk_deprecated_ruler_get_type   (void) G_GNUC_CONST;
+void            gtk_deprecated_ruler_set_metric (GtkDeprecatedRuler       *ruler,
+                                                 GtkMetricType   metric);
+GtkMetricType   gtk_deprecated_ruler_get_metric (GtkDeprecatedRuler       *ruler);
+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);
 
 
 #define SP_HRULER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, sp_hruler_get_type (), SPHRuler)
@@ -29,12 +113,12 @@ void sp_ruler_set_metric (GtkRuler * ruler, SPMetric  metric);
 
 struct SPHRuler
 {
-  GtkRuler ruler;
+  GtkDeprecatedRuler ruler;
 };
 
 struct SPHRulerClass
 {
-  GtkRulerClass parent_class;
+  GtkDeprecatedRulerClass parent_class;
 };
 
 
@@ -54,12 +138,12 @@ GtkWidget* sp_hruler_new      (void);
 
 struct SPVRuler
 {
-  GtkRuler ruler;
+  GtkDeprecatedRuler ruler;
 };
 
 struct SPVRulerClass
 {
-  GtkRulerClass parent_class;
+  GtkDeprecatedRulerClass parent_class;
 };