[dia] renderer: wrap class methods



commit 78509d532b89bfeb6773f748eec55ef45e33cb96
Author: Zander Brown <zbrown gnome org>
Date:   Sun Sep 15 09:35:54 2019 +0100

    renderer: wrap class methods
    
    This improves readability and allows tools like gtk-doc (and eventually g-ir-scanner) to see the methods

 app/connectionpoint_ops.c                 |    5 +-
 app/display.c                             |    7 +-
 app/grid.c                                |  126 +--
 app/handle_ops.c                          |    8 +-
 app/magnify.c                             |   10 +-
 bindings/dia-renderer.cpp                 |  118 +--
 lib/arrows.c                              |  290 +++----
 lib/arrows.h                              |    1 +
 lib/bezier-common.c                       |   16 +-
 lib/bezier-common.h                       |    3 +-
 lib/diaarrowchooser.c                     |   16 +-
 lib/diacellrendererproperty.h             |    3 +-
 lib/diagramdata.c                         |   10 +-
 lib/diagramdata.h                         |    5 +-
 lib/diaimportrenderer.c                   |   24 +-
 lib/diainteractiverenderer.h              |    3 +-
 lib/diapathrenderer.c                     |   20 +-
 lib/diarenderer.c                         | 1191 +++++++++++++++++++++++------
 lib/diarenderer.h                         |  580 +++++++++-----
 lib/diasvgrenderer.c                      |   83 +-
 lib/diatransformrenderer.c                |  173 +++--
 lib/diatypes.h                            |    5 +-
 lib/group.c                               |    4 +-
 lib/layer.c                               |   13 +-
 lib/libdia.def                            |   29 +-
 lib/object.h                              |    1 +
 lib/prop_basic.c                          |    1 +
 lib/properties.h                          |   75 +-
 lib/renderer/diacairo-interactive.c       |    9 +-
 lib/renderer/diacairo-renderer.c          |   76 +-
 lib/renderer/diacairo.h                   |    3 +
 lib/standard-path.c                       |   67 +-
 lib/text.c                                |   90 ++-
 lib/text.h                                |    7 +-
 objects/AADL/aadlbus.c                    |   23 +-
 objects/AADL/aadldata.c                   |   29 +-
 objects/AADL/aadldevice.c                 |   52 +-
 objects/AADL/aadlmemory.c                 |   29 +-
 objects/AADL/aadlpackage.c                |   26 +-
 objects/AADL/aadlport.c                   |  391 +++++-----
 objects/AADL/aadlprocess.c                |   35 +-
 objects/AADL/aadlprocessor.c              |   39 +-
 objects/AADL/aadlsubprogram.c             |   29 +-
 objects/AADL/aadlsystem.c                 |   28 +-
 objects/Database/compound.c               |   21 +-
 objects/Database/reference.c              |   58 +-
 objects/Database/table.c                  |  321 ++++----
 objects/ER/attribute.c                    |   65 +-
 objects/ER/entity.c                       |   59 +-
 objects/ER/participation.c                |   93 ++-
 objects/ER/relationship.c                 |   64 +-
 objects/FS/flow-ortho.c                   |   56 +-
 objects/FS/flow.c                         |   45 +-
 objects/FS/function.c                     |   39 +-
 objects/GRAFCET/action.c                  |   37 +-
 objects/GRAFCET/action_text_draw.c        |   59 +-
 objects/GRAFCET/boolequation.c            |  134 ++--
 objects/GRAFCET/condition.c               |   30 +-
 objects/GRAFCET/step.c                    |   66 +-
 objects/GRAFCET/transition.c              |   24 +-
 objects/GRAFCET/vector.c                  |   37 +-
 objects/GRAFCET/vergent.c                 |   45 +-
 objects/Istar/actor.c                     |   29 +-
 objects/Istar/goal.c                      |   26 +-
 objects/Istar/link.c                      |   30 +-
 objects/Istar/other.c                     |   21 +-
 objects/Jackson/domain.c                  |   27 +-
 objects/Jackson/phenomenon.c              |   34 +-
 objects/Jackson/requirement.c             |   13 +-
 objects/KAOS/goal.c                       |   35 +-
 objects/KAOS/metaandorrel.c               |  125 ++-
 objects/KAOS/metabinrel.c                 |   46 +-
 objects/KAOS/other.c                      |  112 ++-
 objects/Misc/analog_clock.c               |   85 +-
 objects/Misc/diagram_as_object.c          |   94 ++-
 objects/Misc/grid_object.c                |   36 +-
 objects/Misc/measure.c                    |   72 +-
 objects/Misc/n_gon.c                      |   53 +-
 objects/Misc/tree.c                       |   24 +-
 objects/SADT/annotation.c                 |   40 +-
 objects/SADT/arrow.c                      |  123 +--
 objects/SADT/box.c                        |   33 +-
 objects/UML/activity.c                    |   17 +-
 objects/UML/actor.c                       |   51 +-
 objects/UML/association.c                 |   61 +-
 objects/UML/branch.c                      |   12 +-
 objects/UML/class.c                       |  320 ++++----
 objects/UML/classicon.c                   |   80 +-
 objects/UML/component.c                   |   47 +-
 objects/UML/component_feature.c           |   19 +-
 objects/UML/constraint.c                  |   37 +-
 objects/UML/dependency.c                  |   42 +-
 objects/UML/fork.c                        |   17 +-
 objects/UML/generalization.c              |   43 +-
 objects/UML/implements.c                  |   46 +-
 objects/UML/large_package.c               |   51 +-
 objects/UML/lifeline.c                    |   63 +-
 objects/UML/message.c                     |   90 +--
 objects/UML/node.c                        |   33 +-
 objects/UML/note.c                        |   29 +-
 objects/UML/object.c                      |   95 +--
 objects/UML/realizes.c                    |   45 +-
 objects/UML/small_package.c               |   36 +-
 objects/UML/state.c                       |  123 +--
 objects/UML/state_term.c                  |   43 +-
 objects/UML/transition.c                  |   45 +-
 objects/UML/usecase.c                     |   23 +-
 objects/chronogram/chronoline.c           |  158 ++--
 objects/chronogram/chronoref.c            |   36 +-
 objects/custom/custom_object.c            |  360 +++++----
 objects/flowchart/box.c                   |   23 +-
 objects/flowchart/diamond.c               |   23 +-
 objects/flowchart/ellipse.c               |   30 +-
 objects/flowchart/parallelogram.c         |   25 +-
 objects/network/basestation.c             |   64 +-
 objects/network/bus.c                     |   26 +-
 objects/network/radiocell.c               |   26 +-
 objects/network/wanlink.c                 |   75 +-
 objects/standard/arc.c                    |   89 +--
 objects/standard/bezier.c                 |   57 +-
 objects/standard/beziergon.c              |   26 +-
 objects/standard/box.c                    |   58 +-
 objects/standard/ellipse.c                |   71 +-
 objects/standard/image.c                  |   52 +-
 objects/standard/line.c                   |   42 +-
 objects/standard/outline.c                |   28 +-
 objects/standard/polygon.c                |   29 +-
 objects/standard/polyline.c               |   32 +-
 objects/standard/textobj.c                |   17 +-
 objects/standard/zigzagline.c             |   29 +-
 plug-ins/cgm/cgm.c                        |  126 ++-
 plug-ins/drs/dia-render-script-import.c   |  174 +++--
 plug-ins/drs/dia-render-script-renderer.c |  241 +++---
 plug-ins/drs/dia-render-script-renderer.h |    3 +
 plug-ins/drs/dia-render-script.c          |   27 +-
 plug-ins/dxf/dxf-export.c                 |  111 ++-
 plug-ins/hpgl/hpgl.c                      |   78 +-
 plug-ins/metapost/render_metapost.c       |  186 +++--
 plug-ins/metapost/render_metapost.h       |    5 +-
 plug-ins/pgf/render_pgf.c                 |  238 +++---
 plug-ins/pgf/render_pgf.h                 |   13 +-
 plug-ins/postscript/diapsrenderer.c       |  154 ++--
 plug-ins/postscript/diapsrenderer.h       |    3 +
 plug-ins/pstricks/render_pstricks.c       |  171 +++--
 plug-ins/pstricks/render_pstricks.h       |   13 +-
 plug-ins/python/pydia-render.c            |   92 +--
 plug-ins/svg/render_svg.c                 |   43 +-
 plug-ins/vdx/vdx-export.c                 |  128 +++-
 plug-ins/wmf/wmf.cpp                      |  215 ++++--
 plug-ins/wpg/wpg-import.c                 |  147 ++--
 plug-ins/wpg/wpg.c                        |  159 ++--
 plug-ins/xfig/xfig-export.c               |   97 ++-
 152 files changed, 6776 insertions(+), 4556 deletions(-)
---
diff --git a/app/connectionpoint_ops.c b/app/connectionpoint_ops.c
index a50edd35..44e4d69c 100644
--- a/app/connectionpoint_ops.c
+++ b/app/connectionpoint_ops.c
@@ -62,13 +62,12 @@ object_draw_connectionpoints(DiaObject *obj, DDisplay *ddisp)
   int i;
   static Color midpoint_color = { 1.0, 0.0, 0.0, 1.0 };
   DiaRenderer *renderer = ddisp->renderer;
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (ddisp->renderer);
   DiaInteractiveRendererInterface *irenderer =
     DIA_INTERACTIVE_RENDERER_GET_IFACE (ddisp->renderer);
 
   /* this does not change for any of the points */
-  renderer_ops->set_linewidth (renderer, 0.0);
-  renderer_ops->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, 0.0);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   /* optimization to only draw the connection points at all if the size
    * of the object (bounding box) is bigger than the summed size of the
diff --git a/app/display.c b/app/display.c
index a997b4a9..0d85e4b2 100644
--- a/app/display.c
+++ b/app/display.c
@@ -463,7 +463,7 @@ ddisplay_obj_render (DiaObject   *obj,
     irenderer->draw_object_highlighted (DIA_INTERACTIVE_RENDERER (renderer), obj, hltype);
   } else  {
     /* maybe the renderer does not support highlighting */
-    DIA_RENDERER_GET_CLASS (renderer)->draw_object (renderer, obj, NULL);
+    dia_renderer_draw_object (renderer, obj, NULL);
   }
 
   if (ddisp->show_cx_pts &&
@@ -492,8 +492,7 @@ ddisplay_render_pixmap (DDisplay  *ddisp,
   renderer = DIA_INTERACTIVE_RENDERER_GET_IFACE (ddisp->renderer);
 
   /* Erase background */
-  g_return_if_fail (renderer->fill_pixel_rect != NULL);
-  DIA_RENDERER_GET_CLASS (ddisp->renderer)->begin_render (ddisp->renderer, update);
+  dia_renderer_begin_render (ddisp->renderer, update);
   if (update) {
     int x0, y0, x1, y1;
 
@@ -535,7 +534,7 @@ ddisplay_render_pixmap (DDisplay  *ddisp,
     }
     list = g_list_next(list);
   }
-  DIA_RENDERER_GET_CLASS (ddisp->renderer)->end_render (ddisp->renderer);
+  dia_renderer_end_render (ddisp->renderer);
 }
 
 void
diff --git a/app/grid.c b/app/grid.c
index 6dcaf00f..70df0280 100644
--- a/app/grid.c
+++ b/app/grid.c
@@ -116,10 +116,10 @@ grid_draw_horizontal_lines(DDisplay *ddisp, Rectangle *update, real length)
   while (y < height) {
     if (major_lines) {
       if (major_count == 0) {
-        DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+        dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
       } else {
-        DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_DOTTED,
-                                                          ddisplay_untransform_length (ddisp, 31));
+        dia_renderer_set_linestyle (renderer, LINESTYLE_DOTTED,
+                                    ddisplay_untransform_length (ddisp, 31));
       }
       major_count = (major_count + 1) % major_lines;
     }
@@ -160,13 +160,13 @@ grid_draw_vertical_lines(DDisplay *ddisp, Rectangle *update, real length)
     ddisplay_transform_coords (ddisp, pos, update->top, &x, &y);
     if (major_lines) {
       if (major_count == 0) {
-        DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (DIA_INTERACTIVE_RENDERER (renderer),
-                                                          LINESTYLE_SOLID,
-                                                          0.0);
+        dia_renderer_set_linestyle (renderer,
+                                    LINESTYLE_SOLID,
+                                    0.0);
       } else {
-        DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (DIA_INTERACTIVE_RENDERER (renderer),
-                                                          LINESTYLE_DOTTED,
-                                                          ddisplay_untransform_length (ddisp, 31));
+        dia_renderer_set_linestyle (renderer,
+                                    LINESTYLE_DOTTED,
+                                    ddisplay_untransform_length (ddisp, 31));
       }
       major_count = (major_count + 1) % major_lines;
     }
@@ -195,12 +195,15 @@ grid_draw_hex(DDisplay *ddisp, Rectangle *update, real length)
   while (vert_pos <= update->bottom) {
     horiz_pos = ceil( (update->left) / (3 * length) ) * length * 3 - length * 2.5;
     while (horiz_pos <= update->right) {
-      ddisplay_transform_coords(ddisp, horiz_pos, vert_pos, &x, &y);
-      ddisplay_transform_coords(ddisp, horiz_pos + length, vert_pos, &to_x, &y);
+      ddisplay_transform_coords (ddisp, horiz_pos, vert_pos, &x, &y);
+      ddisplay_transform_coords (ddisp, horiz_pos + length, vert_pos, &to_x, &y);
 
-      irenderer->draw_pixel_line(renderer,
-                                x, y, to_x, y,
-                                &ddisp->diagram->grid.colour);
+      irenderer->draw_pixel_line (DIA_INTERACTIVE_RENDERER (renderer),
+                                  x,
+                                  y,
+                                  to_x,
+                                  y,
+                                  &ddisp->diagram->grid.colour);
       horiz_pos += 3 * length;
     }
 
@@ -215,9 +218,12 @@ grid_draw_hex(DDisplay *ddisp, Rectangle *update, real length)
       ddisplay_transform_coords(ddisp, horiz_pos, vert_pos, &x, &y);
       ddisplay_transform_coords(ddisp, horiz_pos+length, vert_pos, &to_x, &y);
 
-      irenderer->draw_pixel_line(renderer,
-                                x, y, to_x, y,
-                                &ddisp->diagram->grid.colour);
+      irenderer->draw_pixel_line (DIA_INTERACTIVE_RENDERER (renderer),
+                                  x,
+                                  y,
+                                  to_x,
+                                  y,
+                                  &ddisp->diagram->grid.colour);
       horiz_pos += 3 * length;
     }
 
@@ -225,47 +231,59 @@ grid_draw_hex(DDisplay *ddisp, Rectangle *update, real length)
   }
 
   /* First \'s and /'s */
-  vert_pos = ceil( update->top / (length * sqrt(3)) ) * length * sqrt(3) - length * sqrt(3);
+  vert_pos = ceil ( update->top / (length * sqrt(3)) ) * length * sqrt(3) - length * sqrt(3);
   while (vert_pos <= update->bottom) {
-    horiz_pos = ceil( (update->left) / (3 * length) ) * length * 3 - length * 2.5;
+    horiz_pos = ceil ( (update->left) / (3 * length) ) * length * 3 - length * 2.5;
     while (horiz_pos <= update->right) {
-      ddisplay_transform_coords(ddisp, horiz_pos + length, vert_pos, &x, &y);
-      ddisplay_transform_coords(ddisp, horiz_pos + 1.5 * length, vert_pos + length * sqrt(3) * 0.5, &to_x, 
&to_y);
+      ddisplay_transform_coords (ddisp, horiz_pos + length, vert_pos, &x, &y);
+      ddisplay_transform_coords (ddisp, horiz_pos + 1.5 * length, vert_pos + length * sqrt(3) * 0.5, &to_x, 
&to_y);
 
-      irenderer->draw_pixel_line(renderer,
-                                x, y, to_x, to_y,
-                                &ddisp->diagram->grid.colour);
+      irenderer->draw_pixel_line (DIA_INTERACTIVE_RENDERER (renderer),
+                                  x,
+                                  y,
+                                  to_x,
+                                  to_y,
+                                  &ddisp->diagram->grid.colour);
 
-      ddisplay_transform_coords(ddisp, horiz_pos, vert_pos, &x, &y);
-      ddisplay_transform_coords(ddisp, horiz_pos - 0.5 * length, vert_pos + length * sqrt(3) * 0.5, &to_x, 
&to_y);
+      ddisplay_transform_coords (ddisp, horiz_pos, vert_pos, &x, &y);
+      ddisplay_transform_coords (ddisp, horiz_pos - 0.5 * length, vert_pos + length * sqrt(3) * 0.5, &to_x, 
&to_y);
 
-      irenderer->draw_pixel_line(renderer,
-                                x, y, to_x, to_y,
-                                &ddisp->diagram->grid.colour);
-      horiz_pos += 3 * length;
+      irenderer->draw_pixel_line (DIA_INTERACTIVE_RENDERER (renderer),
+                                  x,
+                                  y,
+                                  to_x,
+                                  to_y,
+                                  &ddisp->diagram->grid.colour);
+                                  horiz_pos += 3 * length;
     }
 
     vert_pos += sqrt(3) * length;
   }
 
   /*  Second \'s and /'s */
-  vert_pos = ceil( update->top / (length * sqrt(3)) ) * length * sqrt(3) - 0.5 * sqrt(3) * length;
+  vert_pos = ceil ( update->top / (length * sqrt(3)) ) * length * sqrt(3) - 0.5 * sqrt(3) * length;
   while (vert_pos <= update->bottom) {
-    horiz_pos = ceil( (update->left) / (3 * length) ) * length * 3 - length;
+    horiz_pos = ceil ( (update->left) / (3 * length) ) * length * 3 - length;
     while (horiz_pos <= update->right) {
-      ddisplay_transform_coords(ddisp, horiz_pos, vert_pos, &x, &y);
-      ddisplay_transform_coords(ddisp, horiz_pos - 0.5 * length, vert_pos + 0.5 * sqrt(3) * length, &to_x, 
&to_y);
+      ddisplay_transform_coords (ddisp, horiz_pos, vert_pos, &x, &y);
+      ddisplay_transform_coords (ddisp, horiz_pos - 0.5 * length, vert_pos + 0.5 * sqrt(3) * length, &to_x, 
&to_y);
 
-      irenderer->draw_pixel_line(renderer,
-                                x, y, to_x, to_y,
-                                &ddisp->diagram->grid.colour);
+      irenderer->draw_pixel_line (DIA_INTERACTIVE_RENDERER (renderer),
+                                  x,
+                                  y,
+                                  to_x,
+                                  to_y,
+                                  &ddisp->diagram->grid.colour);
 
-      ddisplay_transform_coords(ddisp, horiz_pos + length, vert_pos, &x, &y);
-      ddisplay_transform_coords(ddisp, horiz_pos + 1.5 * length, vert_pos + 0.5 * sqrt(3) * length, &to_x, 
&to_y);
+      ddisplay_transform_coords (ddisp, horiz_pos + length, vert_pos, &x, &y);
+      ddisplay_transform_coords (ddisp, horiz_pos + 1.5 * length, vert_pos + 0.5 * sqrt(3) * length, &to_x, 
&to_y);
 
-      irenderer->draw_pixel_line(renderer,
-                                x, y, to_x, to_y,
-                                &ddisp->diagram->grid.colour);
+      irenderer->draw_pixel_line (DIA_INTERACTIVE_RENDERER (renderer),
+                                  x,
+                                  y,
+                                  to_x,
+                                  to_y,
+                                  &ddisp->diagram->grid.colour);
       horiz_pos += 3 * length;
     }
 
@@ -294,17 +312,17 @@ grid_draw(DDisplay *ddisp, Rectangle *update)
        ddisp->diagram->grid.visible_y;
     }
 
-    DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer, 0.0);
+    dia_renderer_set_linewidth (renderer, 0.0);
 
     if (ddisp->diagram->grid.hex) {
-      grid_draw_hex(ddisp, update, width_w);
+      grid_draw_hex (ddisp, update, width_w);
     } else {
-      if (ddisplay_transform_length(ddisp, width_y) >= 2.0 &&
-         ddisplay_transform_length(ddisp, width_x) >= 2.0) {
-       /* Vertical lines: */
-       grid_draw_vertical_lines(ddisp, update, width_x);
-       /* Horizontal lines: */
-       grid_draw_horizontal_lines(ddisp, update, width_y);
+      if (ddisplay_transform_length (ddisp, width_y) >= 2.0 &&
+          ddisplay_transform_length (ddisp, width_x) >= 2.0) {
+        /* Vertical lines: */
+        grid_draw_vertical_lines (ddisp, update, width_x);
+        /* Horizontal lines: */
+        grid_draw_horizontal_lines (ddisp, update, width_y);
       }
     }
   }
@@ -327,12 +345,12 @@ pagebreak_draw (DDisplay *ddisp, Rectangle *update)
     real pheight = dia->data->paper.height;
     int x, y;
 
-    DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, 0.0);
+    dia_renderer_set_linewidth (renderer, 0.0);
     if (prefs.pagebreak.solid) {
-      DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+      dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
     } else {
-      DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_DOTTED,
-                                                        ddisplay_untransform_length (ddisp, 31));
+      dia_renderer_set_linestyle (renderer, LINESTYLE_DOTTED,
+                                  ddisplay_untransform_length (ddisp, 31));
     }
 
     if (dia->data->paper.fitto) {
diff --git a/app/handle_ops.c b/app/handle_ops.c
index 052cf4f2..46c20b64 100644
--- a/app/handle_ops.c
+++ b/app/handle_ops.c
@@ -68,10 +68,10 @@ handle_draw (Handle *handle, DDisplay *ddisp)
     color = &handle_color[handle->type + (some_selected ? NUM_HANDLE_TYPES : 0)];
   }
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, 0.0);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
 
 
   irenderer->fill_pixel_rect (DIA_INTERACTIVE_RENDERER (renderer),
diff --git a/app/magnify.c b/app/magnify.c
index 0513be83..0e4d0324 100644
--- a/app/magnify.c
+++ b/app/magnify.c
@@ -21,6 +21,7 @@
 
 #include "magnify.h"
 #include "cursor.h"
+#include "diainteractiverenderer.h"
 
 struct _MagnifyTool {
   Tool tool;
@@ -46,8 +47,9 @@ magnify_button_press(MagnifyTool *tool, GdkEventButton *event,
 }
 
 static void
-magnify_button_release(MagnifyTool *tool, GdkEventButton *event,
-                      DDisplay *ddisp)
+magnify_button_release (MagnifyTool    *tool,
+                        GdkEventButton *event,
+                        DDisplay       *ddisp)
 {
   Rectangle *visible;
   Point p1, p2, tl;
@@ -57,7 +59,7 @@ magnify_button_release(MagnifyTool *tool, GdkEventButton *event,
 
   tool->box_active = FALSE;
 
-  dia_interactive_renderer_set_selection (ddisp->renderer,
+  dia_interactive_renderer_set_selection (DIA_INTERACTIVE_RENDERER (ddisp->renderer),
                                           FALSE, 0, 0, 0, 0);
   ddisplay_flush (ddisp);
 
@@ -115,7 +117,7 @@ magnify_motion(MagnifyTool *tool, GdkEventMotion *event,
     tl.x = MIN (tool->x, event->x); tl.y = MIN (tool->y, event->y);
     br.x = MAX (tool->x, event->x); br.y = MAX (tool->y, event->y);
 
-    dia_interactive_renderer_set_selection (ddisp->renderer,
+    dia_interactive_renderer_set_selection (DIA_INTERACTIVE_RENDERER (ddisp->renderer),
                                             TRUE,
                                             tl.x, tl.y, br.x - tl.x, br.y - tl.y);
     ddisplay_flush (ddisp);
diff --git a/bindings/dia-renderer.cpp b/bindings/dia-renderer.cpp
index a3461b9a..aca9708e 100644
--- a/bindings/dia-renderer.cpp
+++ b/bindings/dia-renderer.cpp
@@ -27,223 +27,223 @@
 #include "dia-renderer.h"
 
 // return width in pixels, only for interactive renderers
-int 
+int
 dia::Renderer::get_width_pixels () const
 {
     assert (self);
-    return DIA_RENDERER_GET_CLASS(self)->get_width_pixels (self);
+    return dia_renderer_get_width_pixels (self);
 }
 //  return width in pixels, only for interactive renderers
-int 
+int
 dia::Renderer::get_height_pixels () const
 {
     assert (self);
-    return DIA_RENDERER_GET_CLASS(self)->get_height_pixels (self);
+    return dia_renderer_get_height_pixels (self);
 }
 // simply calls the objects draw function, which calls this again
-void 
+void
 dia::Renderer::draw_object (Object* o)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_object (self, o->Self(), NULL);
+    dia_renderer_draw_object (self, o->Self(), NULL);
 }
 // Returns the EXACT width of text in cm, using the current font.
-double 
+double
 dia::Renderer::get_text_width (const gchar *text, int length) const
 {
     assert (self);
-    return DIA_RENDERER_GET_CLASS(self)->get_text_width (self, text, length);
+    return dia_renderer_get_text_width (self, text, length);
 }
 // called before any rendering takes palce
-void 
+void
 dia::Renderer::begin_render (const Rectangle *update)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->begin_render (self, update);
+    dia_renderer_begin_render (self, update);
 }
 // finished rendering
-void 
+void
 dia::Renderer::end_render ()
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->end_render (self);
+    dia_renderer_end_render (self);
 }
 // set current linewidth
-void 
+void
 dia::Renderer::set_linewidth (double w)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->set_linewidth (self, w);
+    dia_renderer_set_linewidth (self, w);
 }
 // set current linecaps
-void 
+void
 dia::Renderer::set_linecaps (LineCaps mode)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->set_linecaps (self, mode);
+    dia_renderer_set_linecaps (self, mode);
 }
 // set current linejoin
-void 
+void
 dia::Renderer::set_linejoin (LineJoin join)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->set_linejoin (self, join);
+    dia_renderer_set_linejoin (self, join);
 }
 // set current linestyle
-void 
+void
 dia::Renderer::set_linestyle (LineStyle style, real dash_length)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->set_linestyle (self, style, dash_length);
+    dia_renderer_set_linestyle (self, style, dash_length);
 }
 // set current font
-void 
+void
 dia::Renderer::set_font (Font* font, double height)
 {
     assert (self);
     //FIXME: implement
 }
 // Draw a line from start to end, using color and the current line style
-void 
+void
 dia::Renderer::draw_line (Point *start, Point *end, Color *color)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_line (self, start, end, color);
+    dia_renderer_draw_line (self, start, end, color);
 }
 // Fill and/or stroke a rectangle, given its upper-left and lower-right corners
-void 
+void
 dia::Renderer::draw_rect (Point *ul_corner, Point *lr_corner, Color *fill, Color *stroke)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_rect (self, ul_corner, lr_corner, fill, stroke);
+    dia_renderer_draw_rect (self, ul_corner, lr_corner, fill, stroke);
 }
 // Draw an arc, given its center, the bounding box (widget, height), the start angle and the end angle
-void 
+void
 dia::Renderer::draw_arc (Point *center, double width, double height,
                         double angle1, double angle2,
                         Color *color)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_arc (self, center, width, height, angle1, angle2, color);
+    dia_renderer_draw_arc (self, center, width, height, angle1, angle2, color);
 }
 // Same a DrawArcFunc except the arc is filled (a pie-chart)
-void 
+void
 dia::Renderer::fill_arc (Point *center, double width, double height,
                         double angle1, double angle2,
                         Color *color)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->fill_arc (self, center, width, height, angle1, angle2, color);
+    dia_renderer_fill_arc (self, center, width, height, angle1, angle2, color);
 }
 // Draw an ellipse, given its center and the bounding box
-void 
+void
 dia::Renderer::draw_ellipse (Point *center, double width, double height, Color *fill, Color *stroke)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_ellipse (self, center, width, height, fill, stroke);
+    dia_renderer_draw_ellipse (self, center, width, height, fill, stroke);
 }
 // Print a string at pos, using the current font
-void 
+void
 dia::Renderer::draw_string (const gchar *text, Point *pos, Alignment alignment, Color *color)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_string (self, text, pos, alignment, color);
+    dia_renderer_draw_string (self, text, pos, alignment, color);
 }
 // Draw an image, given its bounding box
-void 
+void
 dia::Renderer::draw_image (Point *point, double width, double height, Image* image)
 {
     assert (self);
-    //FIXME: DIA_RENDERER_GET_CLASS(self)->draw_image (self, point, width, height, image);
+    //FIXME: dia_renderer_draw_image (self, point, width, height, image);
 }
 
 // draw a bezier line - possibly as approximation consisting of straight lines
-void 
+void
 dia::Renderer::draw_bezier (BezPoint *points, int numpoints, Color *color)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_bezier (self, points, numpoints, color);
+    dia_renderer_draw_bezier (self, points, numpoints, color);
 }
 // fill a bezier line - possibly as approximation consisting of a polygon
-void 
+void
 dia::Renderer::draw_beziergon (BezPoint *points, int numpoints, Color *fill, Color *stroke)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_beziergon (self, points, numpoints, fill, stroke);
+    dia_renderer_draw_beziergon (self, points, numpoints, fill, stroke);
 }
 // drawing a polyline - or fallback to single line segments
-void 
+void
 dia::Renderer::draw_polyline (Point *points, int num_points, Color *color)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_polyline (self, points, num_points, color);
+    dia_renderer_draw_polyline (self, points, num_points, color);
 }
 // Draw a polygon, using the current line and/or fill style
-void 
+void
 dia::Renderer::draw_polygon (Point *points, int num_points, Color *fill, Color *stroke)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_polygon (self, points, num_points, fill, stroke);
+    dia_renderer_draw_polygon (self, points, num_points, fill, stroke);
 }
 // draw a Text.  It holds its own information like position, style, ...
-void 
+void
 dia::Renderer::draw_text (Text* text)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_text (self, text);
+    dia_renderer_draw_text (self, text);
 }
 // Draw a polyline with round corners
 void
 dia::Renderer::draw_rounded_polyline (Point *points, int num_points, Color *color, double radius )
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_rounded_polyline (self, points, num_points, color, radius);
+    dia_renderer_draw_rounded_polyline (self, points, num_points, color, radius);
 }
 // specialized draw_rect() with round corners
-void 
+void
 dia::Renderer::draw_rounded_rect (Point *ul_corner, Point *lr_corner,
                                  Color *fill, Color *stroke, real radius)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_rounded_rect (self, ul_corner, lr_corner, fill, stroke, radius);
+    dia_renderer_draw_rounded_rect (self, ul_corner, lr_corner, fill, stroke, radius);
 }
 // specialized draw_line() for renderers with an own concept of Arrow
-void 
-dia::Renderer::draw_line_with_arrows  (Point *start, Point *end, real line_width, Color *line_color, 
+void
+dia::Renderer::draw_line_with_arrows  (Point *start, Point *end, real line_width, Color *line_color,
                                        Arrow *start_arrow, Arrow *end_arrow)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_line_with_arrows (self, start, end, line_width, line_color, 
start_arrow, end_arrow);
+    dia_renderer_draw_line_with_arrows (self, start, end, line_width, line_color, start_arrow, end_arrow);
 }
 // specialized draw_line() for renderers with an own concept of Arrow
-void 
+void
 dia::Renderer::draw_arc_with_arrows  (Point *start, Point *end, Point *midpoint, real line_width, Color 
*color,
                                       Arrow *start_arrow, Arrow *end_arrow)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_arc_with_arrows (self, start, end, midpoint, line_width, color, 
start_arrow, end_arrow);
+    dia_renderer_draw_arc_with_arrows (self, start, end, midpoint, line_width, color, start_arrow, 
end_arrow);
 }
 // specialized draw_polyline() for renderers with an own concept of Arrow
-void 
+void
 dia::Renderer::draw_polyline_with_arrows (Point *points, int num_points, real line_width, Color *color,
                                           Arrow *start_arrow, Arrow *end_arrow)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_polyline_with_arrows (self, points, num_points, line_width, color, 
start_arrow, end_arrow);
+    dia_renderer_draw_polyline_with_arrows (self, points, num_points, line_width, color, start_arrow, 
end_arrow);
 }
 // specialized draw_rounded_polyline() for renderers with an own concept of Arrow
-void 
+void
 dia::Renderer::draw_rounded_polyline_with_arrows (Point *points, int num_points, real line_width, Color 
*color,
                                                  Arrow *start_arrow, Arrow *end_arrow, real radius)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_rounded_polyline_with_arrows (self, points, num_points, line_width, 
color, start_arrow, end_arrow, radius);
+    dia_renderer_draw_rounded_polyline_with_arrows (self, points, num_points, line_width, color, 
start_arrow, end_arrow, radius);
 }
 // specialized draw_bezier() for renderers with an own concept of Arrow
-void 
+void
 dia::Renderer::draw_bezier_with_arrows (BezPoint *points, int num_points, real line_width, Color *color,
                                         Arrow *start_arrow, Arrow *end_arrow)
 {
     assert (self);
-    DIA_RENDERER_GET_CLASS(self)->draw_bezier_with_arrows (self, points, num_points, line_width, color, 
start_arrow, end_arrow);
+    dia_renderer_draw_bezier_with_arrows (self, points, num_points, line_width, color, start_arrow, 
end_arrow);
 }
diff --git a/lib/arrows.c b/lib/arrows.c
index c07f2a5b..dac4a204 100644
--- a/lib/arrows.c
+++ b/lib/arrows.c
@@ -462,10 +462,10 @@ draw_none_or_many (DiaRenderer *renderer,
   calculate_double_arrow (&second_to, &second_from, to, from, length);
   /* use the middle of the arrow */
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   draw_empty_ellipse (renderer,
                       &second_to,
@@ -518,14 +518,14 @@ draw_one_exactly (DiaRenderer *renderer,
   point_copy_add_scaled (&be,&bs,&vt,-width/2.0);
   point_add_scaled (&bs,&vt,width/2.0);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer,&bs,&be,fg_color);
+  dia_renderer_draw_line (renderer,&bs,&be,fg_color);
 
   point_copy_add_scaled (&bs,to,&vl,length);
 
   point_copy_add_scaled (&be,&bs,&vt,-width/2.0);
   point_add_scaled (&bs,&vt,width/2.0);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer,&bs,&be,fg_color);
+  dia_renderer_draw_line (renderer,&bs,&be,fg_color);
 }
 
 /**
@@ -566,12 +566,12 @@ draw_one_or_many (DiaRenderer *renderer,
 
   calculate_arrow (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[0], &poly[2], fg_color);
+  dia_renderer_draw_line (renderer, &poly[0], &poly[2], fg_color);
 }
 
 /**
@@ -617,7 +617,7 @@ draw_one_or_none (DiaRenderer *renderer,
   point_copy_add_scaled (&be,&bs,&vt,-width/2.0);
   point_add_scaled (&bs,&vt,width/2.0);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer,&bs,&be,fg_color);
+  dia_renderer_draw_line (renderer,&bs,&be,fg_color);
   /* the ellipse */
   calculate_double_arrow (&second_to, &second_from, to, from, length);
   draw_empty_ellipse (renderer, &second_to, &second_from, length/2, width, linewidth, fg_color);
@@ -650,12 +650,12 @@ draw_crow_foot (DiaRenderer *renderer,
 
   calculate_crow (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[0], &poly[1], fg_color);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[0], &poly[2], fg_color);
+  dia_renderer_draw_line (renderer, &poly[0], &poly[1], fg_color);
+  dia_renderer_draw_line (renderer, &poly[0], &poly[2], fg_color);
 }
 
 /**
@@ -684,12 +684,12 @@ draw_lines (DiaRenderer *renderer,
 
   calculate_arrow (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polyline (renderer, poly, 3, fg_color);
+  dia_renderer_draw_polyline (renderer, poly, 3, fg_color);
 }
 
 static int
@@ -730,10 +730,10 @@ draw_fill_ellipse (DiaRenderer *renderer,
   BezPoint bp[5];
   Point vl,vt;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth(renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin(renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (!bg_color) {
     /* no bg_color means filled ellipse ; we then compensate for the line width
@@ -772,17 +772,17 @@ draw_fill_ellipse (DiaRenderer *renderer,
   point_copy_add_scaled (&bp[2].p1,&bp[1].p3,&vl,length / 4.0);
   point_copy_add_scaled (&bp[3].p2,&bp[3].p3,&vl,length / 4.0);
   if (bg_color) {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer,
-                                                       bp,
-                                                       sizeof(bp)/sizeof(bp[0]),
-                                                       bg_color,
-                                                       fg_color);
+    dia_renderer_draw_beziergon (renderer,
+                                 bp,
+                                 sizeof(bp)/sizeof(bp[0]),
+                                 bg_color,
+                                 fg_color);
   } else {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer,
-                                                       bp,
-                                                       sizeof(bp)/sizeof(bp[0]),
-                                                       fg_color,
-                                                       NULL);
+    dia_renderer_draw_beziergon (renderer,
+                                 bp,
+                                 sizeof(bp)/sizeof(bp[0]),
+                                 fg_color,
+                                 NULL);
   }
 }
 
@@ -811,10 +811,10 @@ draw_empty_ellipse (DiaRenderer *renderer,
   Point vl,vt;
   Point disp;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   point_copy (&vl,from);
   point_sub (&vl,to);
@@ -853,7 +853,7 @@ draw_empty_ellipse (DiaRenderer *renderer,
   point_copy_add_scaled (&bp[2].p1,&bp[1].p3,&vl,length / 4.0);
   point_copy_add_scaled (&bp[3].p2,&bp[3].p3,&vl,length / 4.0);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_bezier (renderer,bp,sizeof(bp)/sizeof(bp[0]),fg_color);
+  dia_renderer_draw_bezier (renderer,bp,sizeof(bp)/sizeof(bp[0]),fg_color);
 }
 
 static int
@@ -921,10 +921,10 @@ draw_fill_box (DiaRenderer *renderer,
   Point poly[6];
   real lw_factor,clength,cwidth;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (fg_color == bg_color) {
     /* Filled dot */
@@ -939,11 +939,11 @@ draw_fill_box (DiaRenderer *renderer,
   calculate_box (poly, to, from, clength, cwidth);
 
   if (fg_color == bg_color) {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4, fg_color, NULL);
+    dia_renderer_draw_polygon (renderer, poly, 4, fg_color, NULL);
   } else {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4, bg_color, fg_color);
+    dia_renderer_draw_polygon (renderer, poly, 4, bg_color, fg_color);
   }
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer,&poly[4],&poly[5],fg_color);
+  dia_renderer_draw_line (renderer,&poly[4],&poly[5],fg_color);
 }
 
 static int
@@ -986,10 +986,10 @@ draw_fill_dot (DiaRenderer *renderer,
   Point bs,be;
   real lw_factor,clength,cwidth;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (fg_color == bg_color) {
     /* Filled dot */
@@ -1042,14 +1042,14 @@ draw_fill_dot (DiaRenderer *renderer,
     point_copy_add_scaled (&doe,to,&vl,length);
     point_copy_add_scaled (&dos,to,&vl,length/2);
 
-    DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer,&dos,&doe,fg_color);
+    dia_renderer_draw_line (renderer,&dos,&doe,fg_color);
   } else {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer,bp,sizeof(bp)/sizeof(bp[0]),bg_color,NULL);
+    dia_renderer_draw_beziergon (renderer,bp,sizeof(bp)/sizeof(bp[0]),bg_color,NULL);
   }
   if (fg_color != bg_color) {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_bezier (renderer,bp,sizeof(bp)/sizeof(bp[0]),fg_color);
+    dia_renderer_draw_bezier (renderer,bp,sizeof(bp)/sizeof(bp[0]),fg_color);
   }
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer,&bs,&be,fg_color);
+  dia_renderer_draw_line (renderer,&bs,&be,fg_color);
 }
 
 /**
@@ -1080,10 +1080,10 @@ draw_integral (DiaRenderer *renderer,
   BezPoint bp[2];
   Point vl,vt;
   Point bs,be, bs2,be2;
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   point_copy (&vl,from); point_sub (&vl,to);
   if (point_len (&vl) > 0)
@@ -1112,9 +1112,9 @@ draw_integral (DiaRenderer *renderer,
   point_copy_add_scaled (&bp[1].p1,&bp[0].p1,&vl,.35*length);
   point_copy_add_scaled (&bp[1].p2,&bp[1].p3,&vl,-.35*length);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &bs2, &be2, fg_color);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &bs, &be, fg_color);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_bezier (renderer,bp,sizeof(bp)/sizeof(bp[0]),fg_color);
+  dia_renderer_draw_line (renderer, &bs2, &be2, fg_color);
+  dia_renderer_draw_line (renderer, &bs, &be, fg_color);
+  dia_renderer_draw_bezier (renderer,bp,sizeof(bp)/sizeof(bp[0]),fg_color);
 }
 
 static int
@@ -1183,14 +1183,14 @@ draw_slashed (DiaRenderer *renderer,
 
   calculate_slashed (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[0], &poly[1], fg_color);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[2], &poly[3], fg_color);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[4], &poly[5], fg_color);
+  dia_renderer_draw_line (renderer, &poly[0], &poly[1], fg_color);
+  dia_renderer_draw_line (renderer, &poly[2], &poly[3], fg_color);
+  dia_renderer_draw_line (renderer, &poly[4], &poly[5], fg_color);
 }
 
 /**
@@ -1272,12 +1272,12 @@ draw_halfhead (DiaRenderer *renderer,
 
   calculate_halfhead (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polyline (renderer, poly, 3, fg_color);
+  dia_renderer_draw_polyline (renderer, poly, 3, fg_color);
 }
 
 /**
@@ -1306,11 +1306,11 @@ draw_triangle (DiaRenderer *renderer,
 
   calculate_arrow (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 3, bg_color, fg_color);
+  dia_renderer_draw_polygon (renderer, poly, 3, bg_color, fg_color);
 }
 
 /**
@@ -1395,12 +1395,12 @@ draw_diamond (DiaRenderer *renderer,
 
   calculate_diamond (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4, fill, stroke);
+  dia_renderer_draw_polygon (renderer, poly, 4, fill, stroke);
 }
 
 /**
@@ -1429,12 +1429,12 @@ draw_half_diamond (DiaRenderer *renderer,
 
   calculate_diamond (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polyline (renderer, poly+1, 3, fg_color);
+  dia_renderer_draw_polyline (renderer, poly+1, 3, fg_color);
 }
 
 /**
@@ -1520,14 +1520,14 @@ draw_slashed_cross (DiaRenderer *renderer,
 
   calculate_slashed_cross (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[0],&poly[1], fg_color);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[2],&poly[3], fg_color);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[4],&poly[5], fg_color);
+  dia_renderer_draw_line (renderer, &poly[0],&poly[1], fg_color);
+  dia_renderer_draw_line (renderer, &poly[2],&poly[3], fg_color);
+  dia_renderer_draw_line (renderer, &poly[4],&poly[5], fg_color);
 }
 
 static int
@@ -1597,12 +1597,12 @@ draw_backslash (DiaRenderer *renderer,
 
   calculate_backslash (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[0], &poly[1], fg_color);
+  dia_renderer_draw_line (renderer, &poly[0], &poly[1], fg_color);
 }
 
 /**
@@ -1631,13 +1631,13 @@ draw_cross (DiaRenderer *renderer,
 
   calculate_arrow (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[0],&poly[2], fg_color);
-  /*DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &poly[4],&poly[5], color); */
+  dia_renderer_draw_line (renderer, &poly[0],&poly[2], fg_color);
+  /*dia_renderer_draw_line (renderer, &poly[4],&poly[5], color); */
 }
 
 /**
@@ -1802,14 +1802,14 @@ draw_concave_triangle (DiaRenderer *renderer,
 
   calculate_concave (poly, to, from, length, width);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (fg_color == bg_color) {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4, bg_color, bg_color);
+    dia_renderer_draw_polygon (renderer, poly, 4, bg_color, bg_color);
   } else {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4, NULL, fg_color);
+    dia_renderer_draw_polygon (renderer, poly, 4, NULL, fg_color);
   }
 }
 
@@ -1842,10 +1842,10 @@ draw_rounded (DiaRenderer *renderer,
   real rapport;
   real angle_start;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   delta = *from;
 
@@ -1863,14 +1863,14 @@ draw_rounded (DiaRenderer *renderer,
   angle_start = 90.0 - dia_asin ((p.y - to->y) / rayon) * (180.0 / G_PI);
   if (p.x - to->x < 0) { angle_start = 360.0 - angle_start; }
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_arc (renderer, &p, width, length, angle_start, angle_start - 
180.0, fg_color);
+  dia_renderer_draw_arc (renderer, &p, width, length, angle_start, angle_start - 180.0, fg_color);
 
   if (len > 0.0) {
     /* scan-build complains about may be used uninitialized, but nothing is changing len since init */
     p.x += delta.x * rapport;
     p.y += delta.y * rapport;
   }
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &p, to, fg_color);
+  dia_renderer_draw_line (renderer, &p, to, fg_color);
 }
 
 /**
@@ -1903,9 +1903,9 @@ draw_open_rounded (DiaRenderer *renderer,
   real len, rayon;
   real angle_start;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   delta = *from;
 
@@ -1922,14 +1922,14 @@ draw_open_rounded (DiaRenderer *renderer,
   angle_start = 90.0 - dia_asin ((p.y - to->y) / rayon) * (180.0 / 3.14);
   if (p.x - to->x < 0) { angle_start = 360.0 - angle_start;  }
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_arc (renderer,
-                                               &p,
-                                               width,
-                                               length,
-                                               angle_start - 180.0,
-                                               angle_start,
-                                               fg_color);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_draw_arc (renderer,
+                         &p,
+                         width,
+                         length,
+                         angle_start - 180.0,
+                         angle_start,
+                         fg_color);
 }
 
 /**
@@ -1960,10 +1960,10 @@ draw_filled_dot_n_triangle (DiaRenderer *renderer,
   real rapport;
   Point poly[3];
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps (renderer, LINECAPS_BUTT);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, linewidth);
 
   delta = *from;
 
@@ -1980,12 +1980,12 @@ draw_filled_dot_n_triangle (DiaRenderer *renderer,
     p_dot.x += delta.x * rapport;
     p_dot.y += delta.y * rapport;
   }
-  DIA_RENDERER_GET_CLASS (renderer)->draw_ellipse (renderer,
-                                                   &p_dot,
-                                                   width,
-                                                   width,
-                                                   fg_color,
-                                                   NULL);
+  dia_renderer_draw_ellipse (renderer,
+                             &p_dot,
+                             width,
+                             width,
+                             fg_color,
+                             NULL);
   /* triangle */
   if (len > 0.0) {
     rapport = width / len;
@@ -1993,7 +1993,7 @@ draw_filled_dot_n_triangle (DiaRenderer *renderer,
     p_tri.y += delta.y * rapport;
   }
   calculate_arrow (poly, &p_tri, from, length, width);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 3, fg_color, NULL);
+  dia_renderer_draw_polygon (renderer, poly, 3, fg_color, NULL);
 }
 
 /**
@@ -2035,15 +2035,15 @@ draw_three_dots (DiaRenderer *renderer,
   dot_width = width * 0.2;
   hole_width = width / 3 - dot_width;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, linewidth);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   for (i = 0; i < 3; i++) {
     dot_from.x = to->x - i  * (dot_width + hole_width) * delta.x;
     dot_from.y = to->y - i  * (dot_width + hole_width) * delta.y;
     dot_to.x = to->x - ((i + 1) * dot_width + i * hole_width) * delta.x;
     dot_to.y = to->y - ((i + 1) * dot_width + i * hole_width) * delta.y;
-    DIA_RENDERER_GET_CLASS (renderer)->draw_line (renderer, &dot_from, &dot_to, fg_color);
+    dia_renderer_draw_line (renderer, &dot_from, &dot_to, fg_color);
   }
 }
 
@@ -2389,8 +2389,8 @@ arrow_draw (DiaRenderer *renderer,
     p2.x = bbox.right;
     p2.y = bbox.bottom;
 
-    DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer,0.01);
-    DIA_RENDERER_GET_CLASS (renderer)->draw_rect (renderer, &p1, &p2, NULL, &col);
+    dia_renderer_set_linewidth (renderer,0.01);
+    dia_renderer_draw_rect (renderer, &p1, &p2, NULL, &col);
   }
 }
 
diff --git a/lib/arrows.h b/lib/arrows.h
index 2efd65cf..4ff6541e 100644
--- a/lib/arrows.h
+++ b/lib/arrows.h
@@ -23,6 +23,7 @@
 #include "color.h"
 #include "dia_xml.h"
 #include "diacontext.h"
+#include "diarenderer.h"
 
 /* NOTE: Add new arrow types at the end, or the enums
    will change order leading to file incompatibilities. */
diff --git a/lib/bezier-common.c b/lib/bezier-common.c
index 524a8e99..995d9679 100644
--- a/lib/bezier-common.c
+++ b/lib/bezier-common.c
@@ -165,24 +165,24 @@ beziercommon_closest_segment (BezierCommon *bezier,
  */
 void
 bezier_draw_control_lines (int          num_points,
-                          BezPoint    *points,
-                          DiaRenderer *renderer)
+                           BezPoint    *points,
+                           DiaRenderer *renderer)
 {
   Color line_colour = { 0.0, 0.0, 0.6, 1.0 };
   Point startpoint;
   int i;
 
   /* setup renderer ... */
-  DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer, 0);
-  DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_DOTTED, 1);
-  DIA_RENDERER_GET_CLASS(renderer)->set_linejoin(renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS(renderer)->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, 0);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DOTTED, 1);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   startpoint = points[0].p1;
   for (i = 1; i < num_points; i++) {
-    DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &startpoint, &points[i].p1, &line_colour);
+    dia_renderer_draw_line (renderer, &startpoint, &points[i].p1, &line_colour);
     if (points[i].type == BEZ_CURVE_TO) {
-      DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &points[i].p2, &points[i].p3, &line_colour);
+      dia_renderer_draw_line  (renderer, &points[i].p2, &points[i].p3, &line_colour);
       startpoint = points[i].p3;
     } else {
       startpoint = points[i].p1;
diff --git a/lib/bezier-common.h b/lib/bezier-common.h
index 428de71e..7f605870 100644
--- a/lib/bezier-common.h
+++ b/lib/bezier-common.h
@@ -26,6 +26,7 @@
 
 #include "diatypes.h"
 #include "geometry.h" /* for real */
+#include "diarenderer.h"
 
 typedef enum {
   BEZ_CORNER_SYMMETRIC,
@@ -51,4 +52,4 @@ int  beziercommon_closest_segment (BezierCommon *bezier, const Point *point, rea
 
 void bezier_draw_control_lines (int num_points, BezPoint *pts, DiaRenderer *renderer);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/lib/diaarrowchooser.c b/lib/diaarrowchooser.c
index e9d51032..2e444ede 100644
--- a/lib/diaarrowchooser.c
+++ b/lib/diaarrowchooser.c
@@ -162,7 +162,6 @@ dia_arrow_preview_expose(GtkWidget *widget, GdkEventExpose *event)
     gint x, y;
     GdkWindow *win;
     int linewidth = 2;
-    DiaRendererClass *renderer_ops;
     cairo_surface_t *surface;
     cairo_t *ctx;
 
@@ -203,9 +202,8 @@ dia_arrow_preview_expose(GtkWidget *widget, GdkEventExpose *event)
     renderer->with_alpha = TRUE;
     renderer->surface = cairo_surface_reference (surface);
 
-    renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-    renderer_ops->begin_render(DIA_RENDERER (renderer), NULL);
-    renderer_ops->set_linewidth(DIA_RENDERER (renderer), linewidth);
+    dia_renderer_begin_render (DIA_RENDERER (renderer), NULL);
+    dia_renderer_set_linewidth (DIA_RENDERER (renderer), linewidth);
     {
       Color color_bg, color_fg;
       GtkStyle *style = gtk_widget_get_style (widget);
@@ -215,15 +213,15 @@ dia_arrow_preview_expose(GtkWidget *widget, GdkEventExpose *event)
 
       GDK_COLOR_TO_DIA(bg, color_bg);
       GDK_COLOR_TO_DIA(fg, color_fg);
-      renderer_ops->draw_line(DIA_RENDERER (renderer), &from, &to, &color_fg);
+      dia_renderer_draw_line (DIA_RENDERER (renderer), &from, &to, &color_fg);
       arrow_draw (DIA_RENDERER (renderer), arrow_type.type,
                   &arrow_head, &from,
-                 arrow_type.length,
-                 arrow_type.width,
+                  arrow_type.length,
+                  arrow_type.width,
                   linewidth, &color_fg, &color_bg);
     }
-    renderer_ops->end_render(DIA_RENDERER (renderer));
-    g_object_unref(renderer);
+    dia_renderer_end_render (DIA_RENDERER (renderer));
+    g_object_unref (renderer);
 
     ctx = gdk_cairo_create (win);
     cairo_set_source_surface (ctx, surface, x, y);
diff --git a/lib/diacellrendererproperty.h b/lib/diacellrendererproperty.h
index 9cd42b52..4e73045e 100644
--- a/lib/diacellrendererproperty.h
+++ b/lib/diacellrendererproperty.h
@@ -28,6 +28,7 @@
 
 #include <gtk/gtk.h>
 #include "diatypes.h"
+#include "diarenderer.h"
 
 #define DIA_TYPE_CELL_RENDERER_PROPERTY            (dia_cell_renderer_property_get_type ())
 #define DIA_CELL_RENDERER_PROPERTY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
DIA_TYPE_CELL_RENDERER_PROPERTY, DiaCellRendererProperty))
@@ -42,7 +43,7 @@ typedef struct _DiaCellRendererPropertyClass DiaCellRendererPropertyClass;
 struct _DiaCellRendererProperty
 {
   GtkCellRenderer   parent_instance;
-  
+
   /*< private >*/
   DiaRenderer      *renderer;
 };
diff --git a/lib/diagramdata.c b/lib/diagramdata.c
index 05fcef47..5c9f2a31 100644
--- a/lib/diagramdata.c
+++ b/lib/diagramdata.c
@@ -812,8 +812,8 @@ data_render (DiagramData    *data,
   Layer *layer;
   guint i, active_layer;
 
-  if (DIA_IS_INTERACTIVE_RENDERER (renderer)) {
-    (DIA_RENDERER_GET_CLASS (renderer)->begin_render) (renderer, update);
+  if (!DIA_IS_INTERACTIVE_RENDERER (renderer)) {
+    dia_renderer_begin_render (renderer, update);
   }
 
   for (i = 0; i < data->layers->len; i++) {
@@ -823,13 +823,13 @@ data_render (DiagramData    *data,
       if (obj_renderer) {
         layer_render (layer, renderer, update, obj_renderer, gdata, active_layer);
       } else {
-        (DIA_RENDERER_GET_CLASS (renderer)->draw_layer) (renderer, layer, active_layer, update);
+        dia_renderer_draw_layer (renderer, layer, active_layer, update);
       }
     }
   }
 
-  if (DIA_IS_INTERACTIVE_RENDERER (renderer)) {
-    (DIA_RENDERER_GET_CLASS (renderer)->end_render) (renderer);
+  if (!DIA_IS_INTERACTIVE_RENDERER (renderer)) {
+    dia_renderer_end_render (renderer);
   }
 }
 
diff --git a/lib/diagramdata.h b/lib/diagramdata.h
index 9ca9cc56..c254f837 100644
--- a/lib/diagramdata.h
+++ b/lib/diagramdata.h
@@ -26,6 +26,7 @@
 #include "color.h"
 #include "geometry.h"
 #include "paper.h"
+#include "diarenderer.h"
 
 G_BEGIN_DECLS
 
@@ -102,8 +103,8 @@ typedef struct _DiagramDataClass {
 
 } DiagramDataClass;
 
-/*! 
- * \brief A diagram consists of layers holding objects 
+/*!
+ * \brief A diagram consists of layers holding objects
  *
  * \ingroup DiagramStructure
  * \todo : make this a GObject as well
diff --git a/lib/diaimportrenderer.c b/lib/diaimportrenderer.c
index 09ac6a37..d57613ee 100644
--- a/lib/diaimportrenderer.c
+++ b/lib/diaimportrenderer.c
@@ -406,11 +406,13 @@ fill_arc (DiaRenderer *renderer, Point *center,
   _apply_style (self, object, color, NULL, 0.0);
   _push_object (self, object);
 #else
-  GArray *path = g_array_new (FALSE, FALSE, sizeof(BezPoint));
+  GArray *path = g_array_new (FALSE, FALSE, sizeof (BezPoint));
   path_build_arc (path, center, width, height, angle1, angle2, TRUE);
-  DIA_RENDERER_GET_CLASS(renderer)->draw_beziergon (renderer,
-                                                   &g_array_index (path, BezPoint, 0),
-                                                   path->len, color, NULL);
+  dia_renderer_draw_beziergon (renderer,
+                               &g_array_index (path, BezPoint, 0),
+                               path->len,
+                               color,
+                               NULL);
   g_array_free (path, TRUE);
 #endif
 }
@@ -439,16 +441,22 @@ draw_ellipse (DiaRenderer *renderer, Point *center,
  */
 static void
 draw_string (DiaRenderer *renderer,
-             const gchar *text, Point *pos, Alignment alignment,
-             Color *color)
+             const gchar *text,
+             Point       *pos,
+             Alignment    alignment,
+             Color       *color)
 {
   DiaImportRenderer *self = DIA_IMPORT_RENDERER (renderer);
   DiaObject *object = create_standard_text (pos->x, pos->y);
   GPtrArray *props = g_ptr_array_new ();
+  DiaFont *font;
+  double font_height;
+
+  font = dia_renderer_get_font (renderer, &font_height);
 
-  prop_list_add_font (props, "text_font", renderer->font);
+  prop_list_add_font (props, "text_font", font);
   prop_list_add_text_colour (props, color);
-  prop_list_add_fontsize (props, PROP_STDNAME_TEXT_HEIGHT, renderer->font_height);
+  prop_list_add_fontsize (props, PROP_STDNAME_TEXT_HEIGHT, font_height);
   prop_list_add_enum (props, "text_alignment", alignment);
   prop_list_add_text (props, "text", text); /* must be last! */
 
diff --git a/lib/diainteractiverenderer.h b/lib/diainteractiverenderer.h
index de3af04d..3df5bb81 100644
--- a/lib/diainteractiverenderer.h
+++ b/lib/diainteractiverenderer.h
@@ -25,11 +25,10 @@
 #include "dia-enums.h"
 
 #include "diagramdata.h"
+#include "diarenderer.h"
 
 G_BEGIN_DECLS
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (DiaRenderer, g_object_unref)
-
 #define DIA_TYPE_INTERACTIVE_RENDERER dia_interactive_renderer_get_type ()
 G_DECLARE_INTERFACE (DiaInteractiveRenderer, dia_interactive_renderer, DIA, INTERACTIVE_RENDERER, 
DiaRenderer)
 
diff --git a/lib/diapathrenderer.c b/lib/diapathrenderer.c
index 1200f36d..3cc9b936 100644
--- a/lib/diapathrenderer.c
+++ b/lib/diapathrenderer.c
@@ -644,17 +644,25 @@ draw_text (DiaRenderer *self,
  * \memberof _DiaPathRenderer
  */
 static void
-draw_string(DiaRenderer *self,
-           const char *text,
-           Point *pos, Alignment alignment,
-           Color *color)
+draw_string (DiaRenderer *self,
+             const char  *text,
+             Point       *pos,
+             Alignment    alignment,
+             Color       *color)
 {
   if (text && strlen(text)) {
     Text *text_obj;
+    DiaFont *font;
+    double font_height;
+
+    font = dia_renderer_get_font (self, &font_height);
     /* it could have been so easy without the context switch */
     text_obj = new_text (text,
-                        self->font, self->font_height,
-                        pos, color, alignment);
+                         font,
+                         font_height,
+                         pos,
+                         color,
+                         alignment);
     draw_text (self, text_obj);
     text_destroy (text_obj);
   }
diff --git a/lib/diarenderer.c b/lib/diarenderer.c
index 292a72c8..61d2ad8d 100644
--- a/lib/diarenderer.c
+++ b/lib/diarenderer.c
@@ -43,14 +43,35 @@ static inline int isnan_d  (double      x) { return x != x; }
 static inline int isnan_ld (long double x) { return x != x; }
 #endif
 
+typedef struct _DiaRendererPrivate DiaRendererPrivate;
+struct _DiaRendererPrivate
+{
+  DiaFont *font;
+  double   font_height; /* IMO It should be possible use the font's size to keep
+                         * this info, but currently _not_ : multi-line text is
+                         * growing on every line when zoomed: BUG in font.c  --hb
+                         */
+  BezierApprox *bezier;
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE (DiaRenderer, dia_renderer, G_TYPE_OBJECT)
+
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+static GParamSpec *pspecs[LAST_PROP] = { NULL, };
+
+
 struct _BezierApprox {
   Point *points;
   int numpoints;
   int currpoint;
 };
 
-static void dia_renderer_class_init (DiaRendererClass *klass);
-
 static void begin_render (DiaRenderer *, const Rectangle *update);
 static void end_render (DiaRenderer *);
 
@@ -59,7 +80,6 @@ static void set_linecaps (DiaRenderer *renderer, LineCaps mode);
 static void set_linejoin (DiaRenderer *renderer, LineJoin mode);
 static void set_linestyle (DiaRenderer *renderer, LineStyle mode, real length);
 static void set_fillstyle (DiaRenderer *renderer, FillStyle mode);
-static void set_font (DiaRenderer *renderer, DiaFont *font, real height);
 
 static void draw_line (DiaRenderer *renderer,
                        Point *start, Point *end,
@@ -167,36 +187,52 @@ static gboolean is_capable_to (DiaRenderer *renderer, RenderCapability cap);
 
 static void set_pattern (DiaRenderer *renderer, DiaPattern *pat);
 
-static gpointer parent_class = NULL;
-
-GType
-dia_renderer_get_type (void)
-{
-  static GType object_type = 0;
-
-  if (!object_type)
-    {
-      static const GTypeInfo object_info =
-      {
-        sizeof (DiaRendererClass),
-        (GBaseInitFunc) NULL,
-        (GBaseFinalizeFunc) NULL,
-        (GClassInitFunc) dia_renderer_class_init,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (DiaRenderer),
-        0,              /* n_preallocs */
-       NULL            /* init */
-      };
-
-      object_type = g_type_register_static (G_TYPE_OBJECT,
-                                            "DiaRenderer",
-                                            &object_info, 0);
-    }
+static void
+dia_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  DiaRenderer *self = DIA_RENDERER (object);
+  DiaRendererPrivate *priv = dia_renderer_get_instance_private (self);
 
-  return object_type;
+  switch (property_id) {
+    case PROP_FONT:
+      g_clear_object (&priv->font);
+      priv->font = g_value_dup_object (value);
+      break;
+    case PROP_FONT_HEIGHT:
+      priv->font_height = g_value_get_double (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
 }
 
+static void
+dia_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  DiaRenderer *self = DIA_RENDERER (object);
+  DiaRendererPrivate *priv = dia_renderer_get_instance_private (self);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, priv->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, priv->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+
 /*!
  * \brief Render all the visible object in the layer
  *
@@ -246,13 +282,13 @@ draw_layer (DiaRenderer *renderer,
  */
 static void
 draw_object (DiaRenderer *renderer,
-            DiaObject   *object,
-            DiaMatrix   *matrix)
+             DiaObject   *object,
+             DiaMatrix   *matrix)
 {
   if (matrix) {
 #if 1
     DiaRenderer *tr = dia_transform_renderer_new (renderer);
-    DIA_RENDERER_GET_CLASS(tr)->draw_object (tr, object, matrix);
+    dia_renderer_draw_object (tr, object, matrix);
     g_object_unref (tr);
     return;
 #else
@@ -270,32 +306,31 @@ draw_object (DiaRenderer *renderer,
     pt[3].x = matrix->xx * bb->left + matrix->xy * bb->bottom + matrix->x0;
     pt[3].y = matrix->yx * bb->left + matrix->yy * bb->bottom + matrix->y0;
 
-    DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer, 0.0);
-    DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_DOTTED, 1.0);
-    DIA_RENDERER_GET_CLASS(renderer)->draw_polygon(renderer, pt, 4, NULL, &red);
-    DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &pt[0], &pt[2], &red);
-    DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &pt[1], &pt[3], &red);
+    dia_renderer_set_linewidth(renderer, 0.0);
+    dia_renderer_set_linestyle(renderer, LINESTYLE_DOTTED, 1.0);
+    dia_renderer_draw_polygon(renderer, pt, 4, NULL, &red);
+    dia_renderer_draw_line(renderer, &pt[0], &pt[2], &red);
+    dia_renderer_draw_line(renderer, &pt[1], &pt[3], &red);
 #endif
   }
   dia_object_draw (object, renderer);
 }
 
 static void
-renderer_finalize (GObject *object)
+dia_renderer_finalize (GObject *object)
 {
   DiaRenderer *renderer = DIA_RENDERER (object);
+  DiaRendererPrivate *priv = dia_renderer_get_instance_private (renderer);
 
-  if (renderer->font)
-    dia_font_unref (renderer->font);
+  g_clear_object (&priv->font);
 
-  if (renderer->bezier)
-    {
-      if (renderer->bezier->points)
-        g_free (renderer->bezier->points);
-      g_free (renderer->bezier);
-    }
+  if (priv->bezier) {
+    if (priv->bezier->points)
+      g_free (priv->bezier->points);
+    g_free (priv->bezier);
+  }
 
-  G_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (dia_renderer_parent_class)->finalize (object);
 }
 
 static void
@@ -304,9 +339,9 @@ dia_renderer_class_init (DiaRendererClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   DiaRendererClass *renderer_class = DIA_RENDERER_CLASS (klass);
 
-  parent_class = g_type_class_peek_parent (klass);
-
-  object_class->finalize = renderer_finalize;
+  object_class->set_property= dia_renderer_set_property;
+  object_class->get_property= dia_renderer_get_property;
+  object_class->finalize = dia_renderer_finalize;
 
   renderer_class->draw_layer = draw_layer;
   renderer_class->draw_object = draw_object;
@@ -320,7 +355,6 @@ dia_renderer_class_init (DiaRendererClass *klass)
   renderer_class->set_linejoin   = set_linejoin;
   renderer_class->set_linestyle  = set_linestyle;
   renderer_class->set_fillstyle  = set_fillstyle;
-  renderer_class->set_font       = set_font;
 
   renderer_class->draw_line    = draw_line;
   renderer_class->draw_rect    = draw_rect;
@@ -352,6 +386,33 @@ dia_renderer_class_init (DiaRendererClass *klass)
   /* other */
   renderer_class->is_capable_to = is_capable_to;
   renderer_class->set_pattern = set_pattern;
+
+  /**
+   * DiaRenderer:font:
+   *
+   * Since: 0.98
+   */
+  pspecs[PROP_FONT] =
+    g_param_spec_object ("font", "Font", "The active font",
+                         DIA_TYPE_FONT,
+                         G_PARAM_READWRITE);
+
+
+  /**
+   * DiaRenderer:font-height:
+   *
+   * Since: 0.98
+   */
+  pspecs[PROP_FONT_HEIGHT] =
+    g_param_spec_double ("font-height",
+                         "Font height",
+                         "Height of the font",
+                         0.0,
+                         G_MAXDOUBLE,
+                         0.0,
+                         G_PARAM_READWRITE);
+
+  g_object_class_install_properties (object_class, LAST_PROP, pspecs);
 }
 
 /*!
@@ -469,22 +530,25 @@ draw_line (DiaRenderer *renderer, Point *start, Point *end, Color *color)
  */
 static void
 draw_polygon (DiaRenderer *renderer,
-              Point *points, int num_points,
-              Color *fill, Color *stroke)
+              Point       *points,
+              int          num_points,
+              Color       *fill,
+              Color       *stroke)
 {
-  DiaRendererClass *klass = DIA_RENDERER_GET_CLASS (renderer);
   int i;
   Color *color = fill ? fill : stroke;
 
   g_return_if_fail (num_points > 1);
   g_return_if_fail (color != NULL);
 
-  for (i = 0; i < num_points - 1; i++)
-    klass->draw_line (renderer, &points[i+0], &points[i+1], color);
+  for (i = 0; i < num_points - 1; i++) {
+    dia_renderer_draw_line (renderer, &points[i+0], &points[i+1], color);
+  }
   /* close it in any case */
   if (   (points[0].x != points[num_points-1].x)
-      || (points[0].y != points[num_points-1].y))
-    klass->draw_line (renderer, &points[num_points-1], &points[0], color);
+      || (points[0].y != points[num_points-1].y)) {
+    dia_renderer_draw_line (renderer, &points[num_points-1], &points[0], color);
+  }
 }
 
 /*!
@@ -537,16 +601,7 @@ draw_ellipse (DiaRenderer *renderer, Point *center,
  *
  * \memberof _DiaRenderer \pure
  */
-static void
-set_font (DiaRenderer *renderer, DiaFont *font, real height)
-{
-  /* if it's the same font we must ref it first */
-  dia_font_ref (font);
-  if (renderer->font)
-    dia_font_unref (renderer->font);
-  renderer->font = font;
-  renderer->font_height = height;
-}
+
 
 /*!
  * \brief Draw a string
@@ -597,36 +652,42 @@ draw_text (DiaRenderer *renderer,
   for (i=0;i<text->numlines;i++) {
     TextLine *text_line = text->lines[i];
 
-    DIA_RENDERER_GET_CLASS(renderer)->draw_text_line(renderer,
-                                                    text_line,
-                                                    &pos,
-                                                    text->alignment,
-                                                    &text->color);
+    dia_renderer_draw_text_line (renderer,
+                                 text_line,
+                                 &pos,
+                                 text->alignment,
+                                 &text->color);
     pos.y += text->height;
   }
 }
 
-/*!
- * \brief Default implementation to draw rotated text
+/**
+ * draw_rotated_text:
+ * @renderer: the #DiaRenderer
+ * @text: the #Text
+ * @center: where to draw @text
+ * @angle: how much to rotate @text about @center
+ *
+ * Default implementation to draw rotated text
  *
- * The default implementation converts the given _Text object to a
+ * The default implementation converts the given #Text object to a
  * path and passes it to draw_beziergon() if the renderer support
  * rendering wih holes. If not a fallback implementation is used.
  *
  * A Renderer with a good own concept of rotated text should
  * overwrite it.
- *
- * \memberof _DiaRenderer
  */
 static void
-draw_rotated_text (DiaRenderer *renderer, Text *text,
-                  Point *center, real angle)
+draw_rotated_text (DiaRenderer *renderer,
+                   Text        *text,
+                   Point       *center,
+                   real         angle)
 {
   if (angle == 0.0) {
     /* maybe the fallback should also consider center? */
     draw_text (renderer, text);
   } else {
-    GArray *path = g_array_new (FALSE, FALSE, sizeof(BezPoint));
+    GArray *path = g_array_new (FALSE, FALSE, sizeof (BezPoint));
     if (!text_is_empty (text) && text_to_path (text, path)) {
       /* Scaling and transformation here */
       Rectangle bz_bb, tx_bb;
@@ -644,41 +705,46 @@ draw_rotated_text (DiaRenderer *renderer, Text *text,
       sy = (tx_bb.bottom - tx_bb.top) / (bz_bb.bottom - bz_bb.top);
 
       /* move center to origin */
-      if (ALIGN_LEFT == text->alignment)
-       t.x0 = -bz_bb.left;
-      else if (ALIGN_RIGHT == text->alignment)
-       t.x0 = - bz_bb.right;
-      else
-       t.x0 = -(bz_bb.left + bz_bb.right) / 2.0;
+      if (ALIGN_LEFT == text->alignment) {
+        t.x0 = -bz_bb.left;
+      } else if (ALIGN_RIGHT == text->alignment) {
+        t.x0 = - bz_bb.right;
+      } else {
+        t.x0 = -(bz_bb.left + bz_bb.right) / 2.0;
+      }
       t.x0 -= dx / sx;
       t.y0 = - bz_bb.top - (text_get_ascent (text) - dy) / sy;
       dia_matrix_set_angle_and_scales (&m, G_PI * angle / 180.0, sx, sx);
       dia_matrix_multiply (&m, &t, &m);
       /* move back center from origin */
-      if (ALIGN_LEFT == text->alignment)
-       t.x0 = tx_bb.left;
-      else if (ALIGN_RIGHT == text->alignment)
-       t.x0 = tx_bb.right;
-      else
-       t.x0 = (tx_bb.left + tx_bb.right) / 2.0;
+      if (ALIGN_LEFT == text->alignment) {
+        t.x0 = tx_bb.left;
+      } else if (ALIGN_RIGHT == text->alignment) {
+        t.x0 = tx_bb.right;
+      } else {
+        t.x0 = (tx_bb.left + tx_bb.right) / 2.0;
+      }
       t.x0 += dx;
       t.y0 = tx_bb.top + (text_get_ascent (text) - dy);
       dia_matrix_multiply (&m, &m, &t);
 
       for (i = 0; i < path->len; ++i) {
-       BezPoint *bp = &g_array_index (path, BezPoint, i);
-       transform_bezpoint (bp, &m);
+        BezPoint *bp = &g_array_index (path, BezPoint, i);
+        transform_bezpoint (bp, &m);
       }
 
-      if (DIA_RENDERER_GET_CLASS (renderer)->is_capable_to(renderer, RENDER_HOLES))
-       DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon(renderer,
-                                                         &g_array_index (path, BezPoint, 0),
-                                                         path->len,
-                                                         &text->color, NULL);
-      else
-       bezier_render_fill (renderer,
-                           &g_array_index (path, BezPoint, 0), path->len,
-                           &text->color);
+      if (dia_renderer_is_capable_of (renderer, RENDER_HOLES)) {
+        dia_renderer_draw_beziergon (renderer,
+                                      &g_array_index (path, BezPoint, 0),
+                                      path->len,
+                                      &text->color,
+                                      NULL);
+      } else {
+        dia_renderer_bezier_fill (renderer,
+                                  &g_array_index (path, BezPoint, 0),
+                                  path->len,
+                                  &text->color);
+      }
     } else {
       Color magenta = { 1.0, 0.0, 1.0, 1.0 };
       Point pt = center ? *center : text->position;
@@ -697,12 +763,16 @@ draw_rotated_text (DiaRenderer *renderer, Text *text,
       dia_matrix_set_angle_and_scales (&m, G_PI * angle / 180.0, 1.0, 1.0);
       dia_matrix_multiply (&m, &t, &m);
 
-      for (i = 0; i < 4; ++i)
-       transform_point (&poly[i], &m);
+      for (i = 0; i < 4; ++i) {
+        transform_point (&poly[i], &m);
+      }
 
-      DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, 0.0);
-      DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4,
-                                                      NULL, &magenta);
+      dia_renderer_set_linewidth (renderer, 0.0);
+      dia_renderer_draw_polygon (renderer,
+                                 poly,
+                                 4,
+                                 NULL,
+                                 &magenta);
     }
     g_array_free (path, TRUE);
   }
@@ -710,39 +780,49 @@ draw_rotated_text (DiaRenderer *renderer, Text *text,
 
 static void
 draw_rotated_image (DiaRenderer *renderer,
-                   Point *point,
-                   real width, real height,
-                   real angle,
-                   DiaImage *image)
+                    Point       *point,
+                    real         width,
+                    real         height,
+                    real         angle,
+                    DiaImage    *image)
 {
   if (angle == 0.0) {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_image (renderer, point, width, height, image);
+    dia_renderer_draw_image (renderer, point, width, height, image);
   } else {
     /* XXX: implement fallback */
-    DIA_RENDERER_GET_CLASS (renderer)->draw_image (renderer, point, width, height, image);
+    dia_renderer_draw_image (renderer, point, width, height, image);
   }
 }
 
-/*!
- * \brief Default implementation of draw_text_line
+/**
+ * draw_text_line:
+ * @renderer: the #DiaRenderer
+ * @text_line: the #TextLine to draw
+ * @pos: where to draw @text_line
+ * @alignment: text #Alignment
+ * @color: text #Color
  *
- * The default implementation of draw_text_line() just calls set_font() and
- * draw_string().
+ * Default implementation of draw_text_line
  *
- * \memberof _DiaRenderer
+ * The default implementation of dia_renderer_draw_text_line() just calls
+ * dia_renderer_set_font() and dia_renderer_draw_string().
  */
 static void
 draw_text_line (DiaRenderer *renderer,
-               TextLine *text_line, Point *pos, Alignment alignment, Color *color)
+                TextLine    *text_line,
+                Point       *pos,
+                Alignment    alignment,
+                Color       *color)
 {
-  DIA_RENDERER_GET_CLASS(renderer)->set_font(renderer,
-                                            text_line_get_font(text_line),
-                                            text_line_get_height(text_line));
-
-  DIA_RENDERER_GET_CLASS(renderer)->draw_string(renderer,
-                                               text_line_get_string(text_line),
-                                               pos, alignment,
-                                               color);
+  dia_renderer_set_font (renderer,
+                         text_line_get_font (text_line),
+                         text_line_get_height (text_line));
+
+  dia_renderer_draw_string (renderer,
+                            text_line_get_string (text_line),
+                            pos,
+                            alignment,
+                            color);
 }
 
 /*
@@ -926,15 +1006,17 @@ approximate_bezier (BezierApprox *bezier,
  */
 static void
 draw_bezier (DiaRenderer *renderer,
-             BezPoint *points, int numpoints,
-             Color *color)
+             BezPoint    *points,
+             int          numpoints,
+             Color       *color)
 {
+  DiaRendererPrivate *priv = dia_renderer_get_instance_private (renderer);
   BezierApprox *bezier;
 
-  if (renderer->bezier)
-    bezier = renderer->bezier;
+  if (priv->bezier)
+    bezier = priv->bezier;
   else
-    renderer->bezier = bezier = g_new0 (BezierApprox, 1);
+    priv->bezier = bezier = g_new0 (BezierApprox, 1);
 
   if (bezier->points == NULL) {
     bezier->numpoints = 30;
@@ -944,10 +1026,10 @@ draw_bezier (DiaRenderer *renderer,
   bezier->currpoint = 0;
   approximate_bezier (bezier, points, numpoints);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polyline (renderer,
-                                                    bezier->points,
-                                                    bezier->currpoint,
-                                                    color);
+  dia_renderer_draw_polyline (renderer,
+                              bezier->points,
+                              bezier->currpoint,
+                              color);
 }
 
 /*!
@@ -961,17 +1043,20 @@ draw_bezier (DiaRenderer *renderer,
  */
 static void
 draw_beziergon (DiaRenderer *renderer,
-                BezPoint *points, int numpoints,
-                Color *fill, Color *stroke)
+                BezPoint    *points,
+                int          numpoints,
+                Color       *fill,
+                Color       *stroke)
 {
+  DiaRendererPrivate *priv = dia_renderer_get_instance_private (renderer);
   BezierApprox *bezier;
 
   g_return_if_fail (fill != NULL || stroke != NULL);
 
-  if (renderer->bezier)
-    bezier = renderer->bezier;
+  if (priv->bezier)
+    bezier = priv->bezier;
   else
-    renderer->bezier = bezier = g_new0 (BezierApprox, 1);
+    priv->bezier = bezier = g_new0 (BezierApprox, 1);
 
   if (bezier->points == NULL) {
     bezier->numpoints = 30;
@@ -982,11 +1067,13 @@ draw_beziergon (DiaRenderer *renderer,
   approximate_bezier (bezier, points, numpoints);
 
   if (fill || stroke)
-    DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer,
-                                                     bezier->points,
-                                                     bezier->currpoint,
-                                                     fill, stroke);
+    dia_renderer_draw_polygon (renderer,
+                               bezier->points,
+                               bezier->currpoint,
+                               fill,
+                               stroke);
 }
+
 /*!
  * \brief Stroke and/or fill a rectangle
  *
@@ -1002,7 +1089,7 @@ draw_rect (DiaRenderer *renderer,
            Point *ul_corner, Point *lr_corner,
            Color *fill, Color *stroke)
 {
-  if (DIA_RENDERER_GET_CLASS(renderer)->draw_polygon == &draw_polygon) {
+  if (DIA_RENDERER_GET_CLASS (renderer)->draw_polygon == &draw_polygon) {
     g_warning ("%s::draw_rect and draw_polygon not implemented!",
                G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (renderer)));
   } else {
@@ -1015,7 +1102,7 @@ draw_rect (DiaRenderer *renderer,
     corner[3].x = ul_corner->x;
     corner[3].y = lr_corner->y;
     /* delegate transformation and drawing */
-    DIA_RENDERER_GET_CLASS(renderer)->draw_polygon (renderer, corner, 4, fill, stroke);
+    dia_renderer_draw_polygon (renderer, corner, 4, fill, stroke);
   }
 }
 
@@ -1029,14 +1116,15 @@ draw_rect (DiaRenderer *renderer,
  */
 static void
 draw_polyline (DiaRenderer *renderer,
-               Point *points, int num_points,
-               Color *color)
+               Point       *points,
+               int          num_points,
+               Color       *color)
 {
-  DiaRendererClass *klass = DIA_RENDERER_GET_CLASS (renderer);
   int i;
 
-  for (i = 0; i < num_points - 1; i++)
-    klass->draw_line (renderer, &points[i+0], &points[i+1], color);
+  for (i = 0; i < num_points - 1; i++) {
+    dia_renderer_draw_line (renderer, &points[i+0], &points[i+1], color);
+  }
 }
 
 
@@ -1072,17 +1160,18 @@ calculate_min_radius( Point *p1, Point *p2, Point *p3 )
  */
 static void
 draw_rounded_polyline (DiaRenderer *renderer,
-                        Point *points, int num_points,
-                        Color *color, real radius)
+                       Point       *points,
+                       int          num_points,
+                       Color       *color,
+                       real         radius)
 {
-  DiaRendererClass *klass = DIA_RENDERER_GET_CLASS (renderer);
   int i = 0;
   Point p1,p2,p3,p4 ;
   Point *p;
   p = points;
 
   if (radius < 0.00001) {
-    klass->draw_polyline(renderer, points, num_points, color);
+    dia_renderer_draw_polyline (renderer, points, num_points, color);
     return;
   }
 
@@ -1091,7 +1180,7 @@ draw_rounded_polyline (DiaRenderer *renderer,
     i = 0;
     p1.x = p[i].x; p1.y = p[i].y;
     p2.x = p[i+1].x; p2.y = p[i+1].y;
-    klass->draw_line(renderer,&p1,&p2,color);
+    dia_renderer_draw_line (renderer, &p1, &p2, color);
     return;
   }
 
@@ -1112,15 +1201,20 @@ draw_rounded_polyline (DiaRenderer *renderer,
     min_radius = MIN(radius, calculate_min_radius(&p1,&p2,&p4));
     arc_it = fillet(&p1,&p2,&p3,&p4, min_radius, &c, &start_angle, &stop_angle);
     /* start with the line drawing to allow joining in backend */
-    klass->draw_line(renderer, &p1, &p2, color);
-    if (arc_it)
-      klass->draw_arc(renderer, &c, min_radius*2, min_radius*2,
-                     start_angle,
-                     stop_angle, color);
+    dia_renderer_draw_line (renderer, &p1, &p2, color);
+    if (arc_it) {
+      dia_renderer_draw_arc (renderer,
+                             &c,
+                             min_radius*2,
+                             min_radius*2,
+                             start_angle,
+                             stop_angle,
+                             color);
+    }
     p1.x = p3.x; p1.y = p3.y;
     p2.x = p4.x; p2.y = p4.y;
   }
-  klass->draw_line(renderer, &p3, &p4, color);
+  dia_renderer_draw_line (renderer, &p3, &p4, color);
 }
 
 /*!
@@ -1134,16 +1228,18 @@ draw_rounded_polyline (DiaRenderer *renderer,
  */
 static void
 draw_rounded_rect (DiaRenderer *renderer,
-                   Point *ul_corner, Point *lr_corner,
-                   Color *fill, Color *stroke, real radius)
+                   Point       *ul_corner,
+                   Point       *lr_corner,
+                   Color       *fill,
+                   Color       *stroke,
+                   real         radius)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   /* clip radius per axis to use the full API;) */
   real rw = MIN(radius, (lr_corner->x-ul_corner->x)/2);
   real rh = MIN(radius, (lr_corner->y-ul_corner->y)/2);
 
   if (rw < 0.00001 || rh < 0.00001) {
-    renderer_ops->draw_rect(renderer, ul_corner, lr_corner, fill, stroke);
+    dia_renderer_draw_rect (renderer, ul_corner, lr_corner, fill, stroke);
   } else {
     real tlx = ul_corner->x; /* top-left x */
     real tly = ul_corner->y; /* top-left y */
@@ -1176,18 +1272,23 @@ draw_rounded_rect (DiaRenderer *renderer,
      */
     /* a filled cross w/ overlap : might not be desirable with alpha */
     if (fill) {
-      if (pts[3].x > pts[7].x)
-        renderer_ops->draw_rect (renderer, &pts[7], &pts[3], fill, NULL);
-      if (pts[4].y > pts[0].y)
-        renderer_ops->draw_rect (renderer, &pts[0], &pts[4], fill, NULL);
+      if (pts[3].x > pts[7].x) {
+        dia_renderer_draw_rect (renderer, &pts[7], &pts[3], fill, NULL);
+      }
+      if (pts[4].y > pts[0].y) {
+        dia_renderer_draw_rect (renderer, &pts[0], &pts[4], fill, NULL);
+      }
     }
     for (i = 0; i < 4; ++i) {
-      if (fill)
-       renderer_ops->fill_arc (renderer, &cts[i], 2*rw, 2*rh, (i+1)*90.0, (i+2)*90.0, fill);
-      if (stroke)
-       renderer_ops->draw_arc (renderer, &cts[i], 2*rw, 2*rh, (i+1)*90.0, (i+2)*90.0, stroke);
-      if (stroke)
-        renderer_ops->draw_line (renderer, &pts[i*2], &pts[i*2+1], stroke);
+      if (fill) {
+        dia_renderer_fill_arc (renderer, &cts[i], 2*rw, 2*rh, (i+1)*90.0, (i+2)*90.0, fill);
+      }
+      if (stroke) {
+        dia_renderer_draw_arc (renderer, &cts[i], 2*rw, 2*rh, (i+1)*90.0, (i+2)*90.0, stroke);
+      }
+      if (stroke) {
+        dia_renderer_draw_line (renderer, &pts[i*2], &pts[i*2+1], stroke);
+      }
     }
   }
 }
@@ -1243,7 +1344,7 @@ draw_line_with_arrows(DiaRenderer *renderer,
     point_sub(endpoint, &move_line);
   }
 
-  DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, startpoint, endpoint, color);
+  dia_renderer_draw_line (renderer, startpoint, endpoint, color);
 
   /* Actual arrow drawing down here so line styles aren't disturbed */
   if (start_arrow != NULL && start_arrow->type != ARROW_NONE)
@@ -1319,10 +1420,14 @@ draw_polyline_with_arrows(DiaRenderer *renderer,
     point_sub(&points[lastline-1], &move_line);
   }
   /* Don't draw degenerate line segments at end of line */
-  if (lastline-firstline > 1) /* probably hiding a bug above, but don't try to draw a negative
-                              * number of points at all, fixes bug #148139 */
-    DIA_RENDERER_GET_CLASS(renderer)->draw_polyline(renderer, &points[firstline],
-                                                    lastline-firstline, color);
+  if (lastline-firstline > 1) {
+    /* probably hiding a bug above, but don't try to draw a negative
+     * number of points at all, fixes bug #148139 */
+    dia_renderer_draw_polyline (renderer,
+                                &points[firstline],
+                                lastline-firstline,
+                                color);
+  }
   if (start_arrow != NULL && start_arrow->type != ARROW_NONE)
     arrow_draw(renderer, start_arrow->type,
               &start_arrow_head, &points[firstline+1],
@@ -1397,11 +1502,12 @@ draw_rounded_polyline_with_arrows(DiaRenderer *renderer,
     point_sub(&points[lastline-1], &move_line);
   }
   /* Don't draw degenerate line segments at end of line */
-  if (lastline-firstline > 1) /* only if there is something */
-    DIA_RENDERER_GET_CLASS(renderer)->draw_rounded_polyline(renderer,
-                                                            &points[firstline],
-                                                            lastline-firstline,
-                                                            color, radius);
+  if (lastline-firstline > 1) { /* only if there is something */
+    dia_renderer_draw_rounded_polyline (renderer,
+                                        &points[firstline],
+                                        lastline-firstline,
+                                        color, radius);
+  }
   if (start_arrow != NULL && start_arrow->type != ARROW_NONE)
     arrow_draw(renderer, start_arrow->type,
               &start_arrow_head, &points[firstline+1],
@@ -1683,8 +1789,13 @@ draw_arc_with_arrows (DiaRenderer *renderer,
       angle1 -= 360.0;
     else if (righthand && angle2 > angle1)
       angle2 -= 360.0;
-    DIA_RENDERER_GET_CLASS(renderer)->draw_arc(renderer, &center, width, width,
-                                              angle1, angle2, color);
+    dia_renderer_draw_arc (renderer,
+                           &center,
+                           width,
+                           width,
+                           angle1,
+                           angle2,
+                           color);
   }
   if (start_arrow != NULL && start_arrow->type != ARROW_NONE)
     arrow_draw(renderer, start_arrow->type,
@@ -1742,7 +1853,7 @@ draw_bezier_with_arrows(DiaRenderer *renderer,
     point_sub(&end_arrow_head, &move_arrow);
     point_sub(&points[num_points-1].p3, &move_line);
   }
-  DIA_RENDERER_GET_CLASS(renderer)->draw_bezier(renderer, points, num_points, color);
+  dia_renderer_draw_bezier (renderer, points, num_points, color);
   if (start_arrow != NULL && start_arrow->type != ARROW_NONE)
     arrow_draw(renderer, start_arrow->type,
               &start_arrow_head, &points[1].p1,
@@ -1778,19 +1889,22 @@ draw_bezier_with_arrows(DiaRenderer *renderer,
  */
 static real
 get_text_width (DiaRenderer *renderer,
-                const gchar *text, int length)
+                const gchar *text,
+                int          length)
 {
   real ret = 0;
+  DiaFont *font;
+  double font_height;
+
+  font = dia_renderer_get_font (renderer, &font_height);
 
-  if (renderer->font) {
+  if (font) {
     char *str = g_strndup (text, length);
 
-    ret = dia_font_string_width (str,
-                                 renderer->font,
-                                 renderer->font_height);
+    ret = dia_font_string_width (str, font, font_height);
     g_free (str);
   } else {
-    g_warning ("%s::get_text_width not implemented (and renderer->font==NULL)!",
+    g_warning ("%s::get_text_width not implemented (and font == NULL)!",
                G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (renderer)));
   }
 
@@ -1834,16 +1948,32 @@ set_pattern (DiaRenderer *renderer, DiaPattern *pat)
              G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (renderer)));
 }
 
-/*!
- * \brief Helper function to fill bezier with multiple BEZ_MOVE_TO
+static void
+dia_renderer_init (DiaRenderer *self)
+{
+
+}
+
+/**
+ * dia_renderer_bezier_fill
+ * @self: the #DiaRenderer
+ * @pts: the #BezPoint s of the bezier
+ * @total: the length of @pts
+ * @color: colour to fill with
+ *
+ * Helper function to fill bezier with multiple %BEZ_MOVE_TO
  * A slightly improved version to split a bezier with multiple move-to into
- * a form which can be used with _DiaRenderer not supporting RENDER_HOLES.
+ * a form which can be used with #DiaRenderer not supporting %RENDER_HOLES.
  * With reasonable placement of the second movement it works well for single
  * holes at least. There are artifacts for more complex path to render.
- * \relates _DiaRenderer
+ *
+ * Since: 0.98
  */
 void
-bezier_render_fill (DiaRenderer *renderer, BezPoint *pts, int total, Color *color)
+dia_renderer_bezier_fill (DiaRenderer *self,
+                          BezPoint    *pts,
+                          int          total,
+                          Color       *color)
 {
   int i;
   gboolean needs_split = FALSE;
@@ -1855,50 +1985,54 @@ bezier_render_fill (DiaRenderer *renderer, BezPoint *pts, int total, Color *colo
     }
   }
   if (!needs_split) {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer, pts, total, color, NULL);
+    dia_renderer_draw_beziergon (self, pts, total, color, NULL);
   } else {
     GArray *points = g_array_new (FALSE, FALSE, sizeof(BezPoint));
     Point close_to;
     gboolean needs_close = FALSE;
     /* start with move-to */
-    g_array_append_val(points, pts[0]);
+    g_array_append_val (points, pts[0]);
     for (i = 1; i < total; ++i) {
       if (BEZ_MOVE_TO == pts[i].type) {
-       /* check whether the start point of the second outline is within the first outline. */
-       real dist = distance_bez_shape_point (&g_array_index (points, BezPoint, 0), points->len, 0, 
&pts[i].p1);
-       if (dist > 0) { /* outside, just create a new one? */
-         /* flush what we have */
-         if (needs_close) {
-           BezPoint bp;
-           bp.type = BEZ_LINE_TO;
-           bp.p1 = close_to;
-           g_array_append_val(points, bp);
-         }
-         DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer,
-                                                            &g_array_index(points, BezPoint, 0), points->len,
-                                                            color, NULL);
-         g_array_set_size (points, 0);
-         g_array_append_val(points, pts[i]); /* new needs move-to */
-         needs_close = FALSE;
-       } else {
-         BezPoint bp = pts[i];
-         bp.type = BEZ_LINE_TO;
-         /* just turn the move- to a line-to */
-         g_array_append_val(points, bp);
-         /* and remember the point we lined from */
-         close_to = (pts[i-1].type == BEZ_CURVE_TO ? pts[i-1].p3 : pts[i-1].p1);
-         needs_close = TRUE;
-       }
+        /* check whether the start point of the second outline is within the first outline. */
+        real dist = distance_bez_shape_point (&g_array_index (points, BezPoint, 0), points->len, 0, 
&pts[i].p1);
+        if (dist > 0) { /* outside, just create a new one? */
+          /* flush what we have */
+          if (needs_close) {
+            BezPoint bp;
+            bp.type = BEZ_LINE_TO;
+            bp.p1 = close_to;
+            g_array_append_val(points, bp);
+          }
+          dia_renderer_draw_beziergon (self,
+                                       &g_array_index (points, BezPoint, 0),
+                                       points->len,
+                                       color,
+                                       NULL);
+          g_array_set_size (points, 0);
+          g_array_append_val (points, pts[i]); /* new needs move-to */
+          needs_close = FALSE;
+        } else {
+          BezPoint bp = pts[i];
+          bp.type = BEZ_LINE_TO;
+          /* just turn the move- to a line-to */
+          g_array_append_val (points, bp);
+          /* and remember the point we lined from */
+          close_to = (pts[i-1].type == BEZ_CURVE_TO ? pts[i-1].p3 : pts[i-1].p1);
+          needs_close = TRUE;
+        }
       } else {
-        g_array_append_val(points, pts[i]);
+        g_array_append_val (points, pts[i]);
       }
     }
     if (points->len > 1) {
       /* actually most renderers need at least three points, but having only one
        * point is an artifact coming from the algorithm above: "new needs move-to" */
-      DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer,
-                                                        &g_array_index(points, BezPoint, 0), points->len,
-                                                        color, NULL);
+      dia_renderer_draw_beziergon (self,
+                                   &g_array_index (points, BezPoint, 0),
+                                   points->len,
+                                   color,
+                                   NULL);
     }
     g_array_free (points, TRUE);
   }
@@ -1921,46 +2055,595 @@ bezier_render_fill_old (DiaRenderer *renderer, BezPoint *pts, int total, Color *
        * If so it need to be subtracted - currently blanked. */
       real dist = distance_bez_shape_point (&pts[s1],  n1 > 0 ? n1 : i - s1, 0, &pts[i].p1);
       if (s2 > s1) { /* blanking the previous one */
-       n = i - s2 - 1;
-       DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer, &pts[s2], n, &color_white, NULL);
+        n = i - s2 - 1;
+        dia_renderer_draw_beziergon (renderer, &pts[s2], n, &color_white, NULL);
       } else { /* fill the outer shape */
-       n1 = n = i - s1;
-       DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer, &pts[s1], n, color, NULL);
+        n1 = n = i - s1;
+        dia_renderer_draw_beziergon (renderer, &pts[s1], n, color, NULL);
       }
       if (dist > 0) { /* remember as new outer outline */
-       s1 = i;
-       n1 = 0;
-       s2 = 0;
+        s1 = i;
+        n1 = 0;
+        s2 = 0;
       } else {
-       s2 = i;
+        s2 = i;
       }
     }
   }
   /* the last one is not drawn yet, i is pointing to the last element */
   if (s2 > s1) { /* blanking the previous one */
-    if (i - s2 - 1 > 1) /* depending on the above we may be ready */
-      DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer, &pts[s2], i - s2, &color_white, NULL);
+    if (i - s2 - 1 > 1) { /* depending on the above we may be ready */
+      dia_renderer_draw_beziergon (renderer, &pts[s2], i - s2, &color_white, NULL);
+    }
   } else {
-    if (i - s1 - 1 > 1)
-      DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon (renderer, &pts[s1], i - s1, color, NULL);
+    if (i - s1 - 1 > 1) {
+      dia_renderer_draw_beziergon (renderer, &pts[s1], i - s1, color, NULL);
+    }
   }
 }
 
-/*!
- * \brief Helper function to stroke a bezier with multiple BEZ_MOVE_TO
- * \relates _DiaRenderer
+/**
+ * dia_renderer_bezier_stroke:
+ * @self: the #DiaRenderer
+ * @pts: the #BezPoint s to draw
+ * @total: length of @pts
+ * @color: colour of the stroke
+ *
+ * Helper function to stroke a bezier with multiple %BEZ_MOVE_TO
+ *
+ * Since: 0.98
  */
 void
-bezier_render_stroke (DiaRenderer *renderer, BezPoint *pts, int total, Color *color)
+dia_renderer_bezier_stroke (DiaRenderer *self,
+                            BezPoint    *pts,
+                            int          total,
+                            Color       *color)
 {
   int i, n = 0;
   for (i = 1; i < total; ++i) {
     if (BEZ_MOVE_TO == pts[i].type) {
-      DIA_RENDERER_GET_CLASS (renderer)->draw_bezier (renderer, &pts[n], i - n, color);
+      dia_renderer_draw_bezier (self, &pts[n], i - n, color);
       n = i;
     }
   }
   /* the last one, if there is one */
-  if (i - n > 1)
-    DIA_RENDERER_GET_CLASS (renderer)->draw_bezier (renderer, &pts[n], i - n, color);
+  if (i - n > 1) {
+    dia_renderer_draw_bezier (self, &pts[n], i - n, color);
+  }
+}
+
+
+void
+dia_renderer_draw_layer (DiaRenderer      *self,
+                         Layer            *layer,
+                         gboolean          active,
+                         Rectangle        *update)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_layer (self, layer, active, update);
+}
+
+
+void
+dia_renderer_draw_object (DiaRenderer      *self,
+                          DiaObject        *object,
+                          DiaMatrix        *matrix)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_object (self, object, matrix);
+}
+
+
+real
+dia_renderer_get_text_width (DiaRenderer      *self,
+                             const gchar      *text,
+                             int               length)
+{
+  g_return_val_if_fail (DIA_IS_RENDERER (self), 0);
+
+  return DIA_RENDERER_GET_CLASS (self)->get_text_width (self, text, length);
+}
+
+
+void
+dia_renderer_begin_render (DiaRenderer      *self,
+                           const Rectangle  *update)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->begin_render (self, update);
+}
+
+
+void
+dia_renderer_end_render (DiaRenderer      *self)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->end_render (self);
+}
+
+
+void
+dia_renderer_set_linewidth (DiaRenderer      *self,
+                            real              linewidth)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->set_linewidth (self, linewidth);
+}
+
+
+void
+dia_renderer_set_linecaps (DiaRenderer      *self,
+                           LineCaps          mode)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->set_linecaps (self, mode);
+}
+
+
+void
+dia_renderer_set_linejoin (DiaRenderer      *self,
+                           LineJoin          mode)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->set_linejoin (self, mode);
+}
+
+
+void
+dia_renderer_set_linestyle (DiaRenderer      *self,
+                            LineStyle         mode,
+                            real              length)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->set_linestyle (self, mode, length);
+}
+
+
+void
+dia_renderer_set_fillstyle (DiaRenderer      *self,
+                            FillStyle         mode)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->set_fillstyle (self, mode);
+}
+
+
+void
+dia_renderer_set_font (DiaRenderer      *self,
+                       DiaFont          *font,
+                       real              height)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  g_object_set (self,
+                "font", font,
+                "font-height", height,
+                NULL);
+}
+
+DiaFont *
+dia_renderer_get_font (DiaRenderer      *self,
+                       double           *height)
+{
+  DiaFont *font;
+  double font_height;
+
+  g_object_get (self,
+                "font", &font,
+                "font-height", &font_height,
+                NULL);
+
+  if (height) {
+    *height = font_height;
+  }
+
+  return font;
+}
+
+void
+dia_renderer_draw_line (DiaRenderer      *self,
+                        Point            *start,
+                        Point            *end,
+                        Color            *color)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_line (self, start, end, color);
+}
+
+
+void
+dia_renderer_draw_polygon (DiaRenderer      *self,
+                           Point            *points,
+                           int               num_points,
+                           Color            *fill,
+                           Color            *stroke)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_polygon (self,
+                                               points,
+                                               num_points,
+                                               fill,
+                                               stroke);
+}
+
+
+void
+dia_renderer_draw_arc (DiaRenderer      *self,
+                       Point            *center,
+                       real              width,
+                       real              height,
+                       real              angle1,
+                       real              angle2,
+                       Color            *color)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_arc (self,
+                                           center,
+                                           width,
+                                           height,
+                                           angle1,
+                                           angle2,
+                                           color);
+}
+
+
+void
+dia_renderer_fill_arc (DiaRenderer      *self,
+                       Point            *center,
+                       real              width,
+                       real              height,
+                       real              angle1,
+                       real              angle2,
+                       Color            *color)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->fill_arc (self,
+                                           center,
+                                           width,
+                                           height,
+                                           angle1,
+                                           angle2,
+                                           color);
+}
+
+
+void
+dia_renderer_draw_ellipse (DiaRenderer      *self,
+                           Point            *center,
+                           real              width,
+                           real              height,
+                           Color            *fill,
+                           Color            *stroke)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_ellipse (self,
+                                               center,
+                                               width,
+                                               height,
+                                               fill,
+                                               stroke);
+}
+
+
+void
+dia_renderer_draw_string (DiaRenderer      *self,
+                          const gchar      *text,
+                          Point            *pos,
+                          Alignment         alignment,
+                          Color            *color)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_string (self, text, pos, alignment, color);
+}
+
+
+void
+dia_renderer_draw_image (DiaRenderer      *self,
+                         Point            *point,
+                         real              width,
+                         real              height,
+                         DiaImage         *image)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_image (self, point, width, height, image);
+}
+
+
+void
+dia_renderer_draw_bezier (DiaRenderer      *self,
+                          BezPoint         *points,
+                          int               numpoints,
+                          Color            *color)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_bezier (self, points, numpoints, color);
+}
+
+
+void
+dia_renderer_draw_beziergon (DiaRenderer      *self,
+                             BezPoint         *points,
+                             int               numpoints,
+                             Color            *fill,
+                             Color            *stroke)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_beziergon (self,
+                                                 points,
+                                                 numpoints,
+                                                 fill,
+                                                 stroke);
+}
+
+
+void
+dia_renderer_draw_polyline (DiaRenderer      *self,
+                            Point            *points,
+                            int               num_points,
+                            Color            *color)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_polyline (self,
+                                                points,
+                                                num_points,
+                                                color);
+}
+
+
+void
+dia_renderer_draw_text (DiaRenderer      *self,
+                        Text             *text)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_text (self, text);
+}
+
+
+void
+dia_renderer_draw_text_line (DiaRenderer      *self,
+                             TextLine         *text_line,
+                             Point            *pos,
+                             Alignment         alignment,
+                             Color            *color)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_text_line (self,
+                                                 text_line,
+                                                 pos,
+                                                 alignment,
+                                                 color);
+}
+
+
+void
+dia_renderer_draw_rect (DiaRenderer      *self,
+                        Point            *ul_corner,
+                        Point            *lr_corner,
+                        Color            *fill,
+                        Color            *stroke)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_rect (self,
+                                            ul_corner,
+                                            lr_corner,
+                                            fill,
+                                            stroke);
+}
+
+
+void
+dia_renderer_draw_rounded_rect (DiaRenderer      *self,
+                                Point            *ul_corner,
+                                Point            *lr_corner,
+                                Color            *fill,
+                                Color            *stroke,
+                                real              radius)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_rounded_rect (self,
+                                                    ul_corner,
+                                                    lr_corner,
+                                                    fill,
+                                                    stroke,
+                                                    radius);
+}
+
+
+void
+dia_renderer_draw_rounded_polyline (DiaRenderer      *self,
+                                    Point            *points,
+                                    int               num_points,
+                                    Color            *color,
+                                    real              radius)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_rounded_polyline (self,
+                                                        points,
+                                                        num_points,
+                                                        color,
+                                                        radius);
+}
+
+
+void
+dia_renderer_draw_line_with_arrows (DiaRenderer      *self,
+                                    Point            *start,
+                                    Point            *end,
+                                    real              line_width,
+                                    Color            *line_color,
+                                    Arrow            *start_arrow,
+                                    Arrow            *end_arrow)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_line_with_arrows (self,
+                                                        start,
+                                                        end,
+                                                        line_width,
+                                                        line_color,
+                                                        start_arrow,
+                                                        end_arrow);
+}
+
+
+void
+dia_renderer_draw_arc_with_arrows (DiaRenderer      *self,
+                                   Point            *start,
+                                   Point            *end,
+                                   Point            *midpoint,
+                                   real              line_width,
+                                   Color            *color,
+                                   Arrow            *start_arrow,
+                                   Arrow            *end_arrow)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_arc_with_arrows (self,
+                                                       start,
+                                                       end,
+                                                       midpoint,
+                                                       line_width,
+                                                       color,
+                                                       start_arrow,
+                                                       end_arrow);
+}
+
+
+void
+dia_renderer_draw_polyline_with_arrows (DiaRenderer      *self,
+                                        Point            *points,
+                                        int               num_points,
+                                        real              line_width,
+                                        Color            *color,
+                                        Arrow            *start_arrow,
+                                        Arrow            *end_arrow)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_polyline_with_arrows (self,
+                                                            points,
+                                                            num_points,
+                                                            line_width,
+                                                            color,
+                                                            start_arrow,
+                                                            end_arrow);
+}
+
+
+void
+dia_renderer_draw_rounded_polyline_with_arrows (DiaRenderer      *self,
+                                                Point            *points,
+                                                int               num_points,
+                                                real              line_width,
+                                                Color            *color,
+                                                Arrow            *start_arrow,
+                                                Arrow            *end_arrow,
+                                                real              radius)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_rounded_polyline_with_arrows (self,
+                                                                    points,
+                                                                    num_points,
+                                                                    line_width,
+                                                                    color,
+                                                                    start_arrow,
+                                                                    end_arrow,
+                                                                    radius);
+}
+
+
+void
+dia_renderer_draw_bezier_with_arrows (DiaRenderer      *self,
+                                      BezPoint         *points,
+                                      int               num_points,
+                                      real              line_width,
+                                      Color            *color,
+                                      Arrow            *start_arrow,
+                                      Arrow            *end_arrow)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_bezier_with_arrows (self,
+                                                          points,
+                                                          num_points,
+                                                          line_width,
+                                                          color,
+                                                          start_arrow,
+                                                          end_arrow);
+}
+
+
+gboolean
+dia_renderer_is_capable_of (DiaRenderer      *self,
+                            RenderCapability  cap)
+{
+  g_return_val_if_fail (DIA_IS_RENDERER (self), FALSE);
+
+  return DIA_RENDERER_GET_CLASS (self)->is_capable_to (self, cap);
+}
+
+
+void
+dia_renderer_set_pattern (DiaRenderer      *self,
+                          DiaPattern       *pat)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->set_pattern (self, pat);
+}
+
+
+void
+dia_renderer_draw_rotated_text (DiaRenderer      *self,
+                                Text             *text,
+                                Point            *center,
+                                real              angle)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_rotated_text (self, text, center, angle);
+}
+
+
+void
+dia_renderer_draw_rotated_image (DiaRenderer      *self,
+                                 Point            *point,
+                                 real              width,
+                                 real              height,
+                                 real              angle,
+                                 DiaImage         *image)
+{
+  g_return_if_fail (DIA_IS_RENDERER (self));
+
+  DIA_RENDERER_GET_CLASS (self)->draw_rotated_image (self,
+                                                     point,
+                                                     width,
+                                                     height,
+                                                     angle,
+                                                     image);
 }
diff --git a/lib/diarenderer.h b/lib/diarenderer.h
index 80085687..d9be8235 100644
--- a/lib/diarenderer.h
+++ b/lib/diarenderer.h
@@ -20,13 +20,15 @@
 #ifndef DIA_RENDERER_H
 #define DIA_RENDERER_H
 
-#include "diatypes.h"
 #include <glib-object.h>
 
 #include "dia-enums.h"
 #include "geometry.h"
 #include "font.h" /* not strictly needed by this header, but needed in almost any plug-in/ */
 
+/* HACK: Work around circular deps */
+typedef struct _DiaRenderer DiaRenderer;
+
 #include "diagramdata.h"
 
 G_BEGIN_DECLS
@@ -38,233 +40,411 @@ typedef enum {
   RENDER_PATTERN = (1<<3)
 } RenderCapability;
 
-/*! GObject boiler plate, create runtime information */
-#define DIA_TYPE_RENDERER           (dia_renderer_get_type ())
-/*! GObject boiler plate, a safe type cast */
-#define DIA_RENDERER(obj)           (G_TYPE_CHECK_INSTANCE_CAST ((obj), DIA_TYPE_RENDERER, DiaRenderer))
-/*! GObject boiler plate, in C++ this would be the vtable */
-#define DIA_RENDERER_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST ((klass), DIA_TYPE_RENDERER, DiaRendererClass))
-/*! GObject boiler plate, type check */
-#define DIA_IS_RENDERER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DIA_TYPE_RENDERER))
-/*! GObject boiler plate, get from object to class (vtable) */
-#define DIA_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DIA_TYPE_RENDERER, DiaRendererClass))
+#define DIA_TYPE_RENDERER dia_renderer_get_type ()
+G_DECLARE_DERIVABLE_TYPE (DiaRenderer, dia_renderer, DIA, RENDERER, GObject)
 
-GType dia_renderer_get_type (void) G_GNUC_CONST;
 
 /**
- * DiaRenderer:
- * @font: the current #DiaFont
- * @font_height: the height of @font
- * @bezier: ???
- *
- * The member variables part of _DiaRenderer
+ * DiaRendererClass:
+ * @draw_layer: Render all the visible object in the layer1
+ * @draw_object: Calls the objects draw function, which calls the renderer
+ *    again Affine transformation is mostly done on the renderer side
+ *    for matrix != NULL
+ * @get_text_width: Returns the EXACT width of text in cm, using the current
+ *    font. There has been some confusion as to the definition of this.
+ *    It used to say the width was in pixels, but actual width returned
+ *    was cm.  You shouldn't know about pixels anyway.
+ * @begin_render: Called before rendering begins. Can be used to do various
+ *    pre-rendering setup.
+ * @end_render: Called after all rendering is done. Used to do various
+ *    clean-ups.
+ * @set_linewidth: Set the current line width if linewidth==0, the line will
+ *    be an 'hairline'
+ * @set_linecaps: Set the current linecap (the way lines are ended)
+ * @set_linejoin: Set the current linejoin (the way two lines are
+ *    joined together)
+ * @set_linestyle: Set the current line style and the dash length, when the
+ *    style is not SOLID. A dot will be 10% of length
+ * @set_fillstyle: Set the fill style
+ * @draw_line: Draw a line from start to end, using color and the current
+ *    line style
+ * @draw_polygon: the polygon is filled using the current fill type and
+ *    stroked with the current line style
+ * @draw_arc: Draw an arc, given its center, the bounding box (widget, height)
+ *    the start angle and the end angle. It's counter-clockwise
+ *    if angle2 > angle1
+ * @fill_arc: Same a DrawArcFunc except the arc is filled (a pie-chart)
+ * @draw_ellipse: Draw an ellipse, given its center and the bounding box
+ * @draw_string: Print a string at pos, using the current font
+ * @draw_image: Draw an image, given its bounding box
+ * @draw_bezier: Draw a bezier curve, given it's control points.
+ * @draw_beziergon: Fill and/or stroke a  closed bezier
+ * @draw_polyline: Draw a line joining multiple points, using color and the
+ *    current line style
+ * @draw_text: Print a #Text. It holds its own information.
+ * @draw_text_line: Print a #TextLine. It holds its own font/size information.
+ * @draw_rect: Draw a rectangle, given its upper-left and lower-right corners
+ * @draw_rounded_rect: Draw a rounded rectangle, given its upper-left and
+ *    lower-right corners
+ * @draw_rounded_polyline: Draw a line joining multiple points, using color
+ *    and the current line style with rounded corners between segments
+ * @draw_line_with_arrows: Highest level function doing specific
+ *    arrow positioning
+ * @draw_arc_with_arrows: Highest level function doing specific
+ *    arrow positioning
+ * @draw_polyline_with_arrows: Highest level function doing specific
+ *    arrow positioning
+ * @draw_rounded_polyline_with_arrows:
+ * @draw_bezier_with_arrows:
+ * @is_capable_to: allows to adapt #DiaObject implementations to certain
+ *    renderer capabilities
+ * @set_pattern: fill with a pattern, currently only gradient
+ * @draw_rotated_text: draw text rotated around center with given
+ *    angle in degrees
+ * @draw_rotated_image: draw image rotated around center with given angle
+ *    in degrees
  *
- * The Dia renderers are already realized with the GObject type system.
- * Most of the renderers are only used for export, but there are also
- * some renderers capable of interaction (i.e. display). These are
- * extended versions providing also the #DiaInteractiveRenderer
- */
-struct _DiaRenderer
-{
-  GObject parent_instance; /*!< inheritance in object oriented C */
-
-  /*< private >*/
-  DiaFont *font;
-  real font_height; /* IMO It should be possible use the font's size to keep
-                     * this info, but currently _not_ : multi-line text is
-                     * growing on every line when zoomed: BUG in font.c  --hb
-                     */
-  BezierApprox *bezier;
-};
-
-/*!
- * \brief Base class for all of Dia's render facilities
+ * Base class for all of Dia's render facilities
  *
- * Renderers work in close cooperation with DiaObject. They provide the way to
+ * Renderers work in close cooperation with #DiaObject. They provide the way to
  * make all the object drawing independent of concrete drawing back-ends
  */
 struct _DiaRendererClass
 {
-  GObjectClass parent_class; /*!< the base class */
-
-  /*! \brief Render all the visible object in the layer */
-  void (*draw_layer) (DiaRenderer*, Layer *, gboolean, Rectangle *);
-  /*! Calls the objects draw function, which calls the renderer again
-   *  Affine transformation is mostly done on the renderer side for matrix!=NULL */
-  void (*draw_object) (DiaRenderer*, DiaObject*, DiaMatrix*);
-  /*! Returns the EXACT width of text in cm, using the current font.
-     There has been some confusion as to the definition of this.
-     It used to say the width was in pixels, but actual width returned
-     was cm.  You shouldn't know about pixels anyway.
-   */
-  real (*get_text_width) (DiaRenderer *renderer,
-                          const gchar *text, int length);
+  GObjectClass parent_class;
 
+  void     (*draw_layer)                        (DiaRenderer      *renderer,
+                                                 Layer            *layer,
+                                                 gboolean          active,
+                                                 Rectangle        *update);
+  void     (*draw_object)                       (DiaRenderer      *renderer,
+                                                 DiaObject        *object,
+                                                 DiaMatrix        *matrix);
+  real (*get_text_width)                        (DiaRenderer      *renderer,
+                                                 const gchar      *text,
+                                                 int               length);
 
   /*
    * Function which MUST be implemented by any DiaRenderer
    */
-  /*! Called before rendering begins.
-     Can be used to do various pre-rendering setup. */
-  void (*begin_render) (DiaRenderer *, const Rectangle *update);
-  /*! Called after all rendering is done.
-     Used to do various clean-ups.*/
-  void (*end_render) (DiaRenderer *);
+  void     (*begin_render)                      (DiaRenderer      *renderer,
+                                                 const Rectangle  *update);
+  void     (*end_render)                        (DiaRenderer      *renderer);
 
-  /*! Set the current line width
-     if linewidth==0, the line will be an 'hairline' */
-  void (*set_linewidth) (DiaRenderer *renderer, real linewidth);
-  /*! Set the current linecap (the way lines are ended) */
-  void (*set_linecaps) (DiaRenderer *renderer, LineCaps mode);
-  /*! Set the current linejoin (the way two lines are joined together) */
-  void (*set_linejoin) (DiaRenderer *renderer, LineJoin mode);
-  /*! Set the current line style and the dash length, when the style is
-   * not SOLID. A dot will be 10% of length */
-  void (*set_linestyle) (DiaRenderer *renderer, LineStyle mode, real length);
-  /*! Set the fill style */
-  void (*set_fillstyle) (DiaRenderer *renderer, FillStyle mode);
-  /*! Set the current font */
-  void (*set_font) (DiaRenderer *renderer, DiaFont *font, real height);
+  void     (*set_linewidth)                     (DiaRenderer      *renderer,
+                                                 real              linewidth);
+  void     (*set_linecaps)                      (DiaRenderer      *renderer,
+                                                 LineCaps          mode);
+  void     (*set_linejoin)                      (DiaRenderer      *renderer,
+                                                 LineJoin          mode);
+  void     (*set_linestyle)                     (DiaRenderer      *renderer,
+                                                 LineStyle         mode,
+                                                 real              length);
+  void     (*set_fillstyle)                     (DiaRenderer      *renderer,
+                                                 FillStyle         mode);
 
-  /*! Draw a line from start to end, using color and the current line style */
-  void (*draw_line) (DiaRenderer *renderer,
-                     Point *start, Point *end,
-                     Color *color);
-  /*! the polygon is filled using the current fill type and stroked with the current line style */
-  void (*draw_polygon) (DiaRenderer *renderer,
-                        Point *points, int num_points,
-                        Color *fill, Color *stroke);
-  /*! Draw an arc, given its center, the bounding box (widget, height),
-     the start angle and the end angle. It's counter-clockwise if angle2>angle1 */
-  void (*draw_arc) (DiaRenderer *renderer,
-                    Point *center,
-                    real width, real height,
-                    real angle1, real angle2,
-                    Color *color);
-  /*! Same a DrawArcFunc except the arc is filled (a pie-chart) */
-  void (*fill_arc) (DiaRenderer *renderer,
-                    Point *center,
-                    real width, real height,
-                    real angle1, real angle2,
-                    Color *color);
-  /*! Draw an ellipse, given its center and the bounding box */
-  void (*draw_ellipse) (DiaRenderer *renderer,
-                        Point *center,
-                        real width, real height,
-                        Color *fill, Color *stroke);
-  /*! Print a string at pos, using the current font */
-  void (*draw_string) (DiaRenderer *renderer,
-                       const gchar *text,
-                       Point *pos,
-                       Alignment alignment,
-                       Color *color);
-  /*! Draw an image, given its bounding box */
-  void (*draw_image) (DiaRenderer *renderer,
-                      Point *point,
-                      real width, real height,
-                      DiaImage *image);
+  void     (*draw_line)                         (DiaRenderer      *renderer,
+                                                 Point            *start,
+                                                 Point            *end,
+                                                 Color            *color);
+  void     (*draw_polygon)                      (DiaRenderer      *renderer,
+                                                 Point            *points,
+                                                 int               num_points,
+                                                 Color            *fill,
+                                                 Color            *stroke);
+  void     (*draw_arc)                          (DiaRenderer      *renderer,
+                                                 Point            *center,
+                                                 real              width,
+                                                 real              height,
+                                                 real              angle1,
+                                                 real              angle2,
+                                                 Color            *color);
+  void     (*fill_arc)                          (DiaRenderer      *renderer,
+                                                 Point            *center,
+                                                 real              width,
+                                                 real              height,
+                                                 real              angle1,
+                                                 real              angle2,
+                                                 Color            *color);
+  void     (*draw_ellipse)                      (DiaRenderer      *renderer,
+                                                 Point            *center,
+                                                 real              width,
+                                                 real              height,
+                                                 Color            *fill,
+                                                 Color            *stroke);
+  void     (*draw_string)                       (DiaRenderer      *renderer,
+                                                 const gchar      *text,
+                                                 Point            *pos,
+                                                 Alignment         alignment,
+                                                 Color            *color);
+  void     (*draw_image)                        (DiaRenderer      *renderer,
+                                                 Point            *point,
+                                                 real              width,
+                                                 real              height,
+                                                 DiaImage         *image);
 
   /*
    * Functions which SHOULD be implemented by specific renderer, but
    * have a default implementation based on the above functions
    */
-  /*! Draw a bezier curve, given it's control points. */
-  void (*draw_bezier) (DiaRenderer *renderer,
-                       BezPoint *points,
-                       int numpoints,
-                       Color *color);
-  /*! Fill and/or stroke a  closed bezier */
-  void (*draw_beziergon) (DiaRenderer *renderer,
-                       BezPoint *points,
-                       int numpoints,
-                       Color *fill,
-                       Color *stroke);
-  /*! Draw a line joining multiple points, using color and the current
-     line style */
-  void (*draw_polyline) (DiaRenderer *renderer,
-                         Point *points, int num_points,
-                         Color *color);
-  /*! Print a Text.  It holds its own information. */
-  void (*draw_text) (DiaRenderer *renderer,
-                     Text *text);
-  /*! Print a TextLine.  It holds its own font/size information. */
-  void (*draw_text_line) (DiaRenderer *renderer,
-                         TextLine *text_line, Point *pos, Alignment alignment, Color *color);
-  /*! Draw a rectangle, given its upper-left and lower-right corners */
-  void (*draw_rect) (DiaRenderer *renderer,
-                     Point *ul_corner, Point *lr_corner,
-                     Color *fill, Color *stroke);
+  void     (*draw_bezier)                       (DiaRenderer      *renderer,
+                                                 BezPoint         *points,
+                                                 int               numpoints,
+                                                 Color            *color);
+  void     (*draw_beziergon)                    (DiaRenderer      *renderer,
+                                                 BezPoint         *points,
+                                                 int               numpoints,
+                                                 Color            *fill,
+                                                 Color            *stroke);
+  void     (*draw_polyline)                     (DiaRenderer      *renderer,
+                                                 Point            *points,
+                                                 int               num_points,
+                                                 Color            *color);
+  void     (*draw_text)                         (DiaRenderer      *renderer,
+                                                 Text             *text);
+  void     (*draw_text_line)                    (DiaRenderer      *renderer,
+                                                 TextLine         *text_line,
+                                                 Point            *pos,
+                                                 Alignment         alignment,
+                                                 Color            *color);
+  void     (*draw_rect)                         (DiaRenderer      *renderer,
+                                                 Point            *ul_corner,
+                                                 Point            *lr_corner,
+                                                 Color            *fill,
+                                                 Color            *stroke);
 
   /*
    * Highest level functions, probably only to be implemented by
    * special 'high level' renderers
    */
-  /*! Draw a rounded rectangle, given its upper-left and lower-right corners */
-  void (*draw_rounded_rect) (DiaRenderer *renderer,
-                             Point *ul_corner, Point *lr_corner,
-                             Color *fill, Color *stroke, real radius);
-  /*! Draw a line joining multiple points, using color and the current
-     line style with rounded corners between segments */
-  void (*draw_rounded_polyline) (DiaRenderer *renderer,
-                         Point *points, int num_points,
-                         Color *color, real radius );
-
-  /*! Highest level function doing specific arrow positioning */
-  void (*draw_line_with_arrows)  (DiaRenderer *renderer,
-                                  Point *start, Point *end,
-                                  real line_width,
-                                  Color *line_color,
-                                  Arrow *start_arrow,
-                                  Arrow *end_arrow);
-  /*! Highest level function doing specific arrow positioning */
-  void (*draw_arc_with_arrows)  (DiaRenderer *renderer,
-                                 Point *start, Point *end,
-                                 Point *midpoint,
-                                 real line_width,
-                                 Color *color,
-                                 Arrow *start_arrow,
-                                 Arrow *end_arrow);
-  /*! Highest level function doing specific arrow positioning */
-  void (*draw_polyline_with_arrows) (DiaRenderer *renderer,
-                                     Point *points, int num_points,
-                                     real line_width,
-                                     Color *color,
-                                     Arrow *start_arrow,
-                                     Arrow *end_arrow);
-  void (*draw_rounded_polyline_with_arrows) (DiaRenderer *renderer,
-                                     Point *points, int num_points,
-                                     real line_width,
-                                     Color *color,
-                                     Arrow *start_arrow,
-                                     Arrow *end_arrow,
-                                     real radius);
-
-  void (*draw_bezier_with_arrows) (DiaRenderer *renderer,
-                                   BezPoint *points,
-                                   int num_points,
-                                   real line_width,
-                                   Color *color,
-                                   Arrow *start_arrow,
-                                   Arrow *end_arrow);
-  /*! allows to adapt DiaObject implementations to certain renderer capabilities */
-  gboolean (*is_capable_to) (DiaRenderer *renderer,
-                            RenderCapability cap);
-  /*! fill with a pattern, currently only gradient */
-  void (*set_pattern) (DiaRenderer *renderer, DiaPattern *pat);
-  /*! draw text rotated around center with given angle in degrees */
-  void (*draw_rotated_text) (DiaRenderer *renderer, Text *text,
-                            Point *center, real angle);
-  /*! draw image rotated around center with given angle in degrees */
-  void (*draw_rotated_image) (DiaRenderer *renderer,
-                             Point *point,
-                             real width, real height,
-                             real angle,
-                             DiaImage *image);
+  void     (*draw_rounded_rect)                 (DiaRenderer      *renderer,
+                                                 Point            *ul_corner,
+                                                 Point            *lr_corner,
+                                                 Color            *fill,
+                                                 Color            *stroke,
+                                                 real              radius);
+  void     (*draw_rounded_polyline)             (DiaRenderer      *renderer,
+                                                 Point            *points,
+                                                 int               num_points,
+                                                 Color            *color,
+                                                 real              radius );
+  void     (*draw_line_with_arrows)             (DiaRenderer      *renderer,
+                                                 Point            *start,
+                                                 Point            *end,
+                                                 real              line_width,
+                                                 Color            *line_color,
+                                                 Arrow            *start_arrow,
+                                                 Arrow            *end_arrow);
+  void     (*draw_arc_with_arrows)              (DiaRenderer      *renderer,
+                                                 Point            *start,
+                                                 Point            *end,
+                                                 Point            *midpoint,
+                                                 real              line_width,
+                                                 Color            *color,
+                                                 Arrow            *start_arrow,
+                                                 Arrow            *end_arrow);
+  void     (*draw_polyline_with_arrows)         (DiaRenderer      *renderer,
+                                                 Point            *points,
+                                                 int               num_points,
+                                                 real              line_width,
+                                                 Color            *color,
+                                                 Arrow            *start_arrow,
+                                                 Arrow            *end_arrow);
+  void     (*draw_rounded_polyline_with_arrows) (DiaRenderer      *renderer,
+                                                 Point            *points,
+                                                 int               num_points,
+                                                 real              line_width,
+                                                 Color            *color,
+                                                 Arrow            *start_arrow,
+                                                 Arrow            *end_arrow,
+                                                 real              radius);
+  void     (*draw_bezier_with_arrows)           (DiaRenderer      *renderer,
+                                                 BezPoint         *points,
+                                                 int               num_points,
+                                                 real              line_width,
+                                                 Color            *color,
+                                                 Arrow            *start_arrow,
+                                                 Arrow            *end_arrow);
+  gboolean (*is_capable_to)                     (DiaRenderer      *renderer,
+                                                 RenderCapability  cap);
+  void     (*set_pattern)                       (DiaRenderer      *renderer,
+                                                 DiaPattern       *pat);
+  void     (*draw_rotated_text)                 (DiaRenderer      *renderer,
+                                                 Text             *text,
+                                                 Point            *center,
+                                                 real              angle);
+  void     (*draw_rotated_image)                (DiaRenderer      *renderer,
+                                                 Point            *point,
+                                                 real              width,
+                                                 real              height,
+                                                 real              angle,
+                                                 DiaImage         *image);
 };
 
-/* Some standalone render helper functiions */
-void bezier_render_fill   (DiaRenderer *renderer, BezPoint *pts, int total, Color *color);
-void bezier_render_stroke (DiaRenderer *renderer, BezPoint *pts, int total, Color *color);
+void     dia_renderer_draw_layer                        (DiaRenderer      *self,
+                                                         Layer            *layer,
+                                                         gboolean          active,
+                                                         Rectangle        *update);
+void     dia_renderer_draw_object                       (DiaRenderer      *self,
+                                                         DiaObject        *object,
+                                                         DiaMatrix        *matrix);
+real     dia_renderer_get_text_width                    (DiaRenderer      *self,
+                                                         const gchar      *text,
+                                                         int               length);
+void     dia_renderer_begin_render                      (DiaRenderer      *self,
+                                                         const Rectangle  *update);
+void     dia_renderer_end_render                        (DiaRenderer      *self);
+void     dia_renderer_set_linewidth                     (DiaRenderer      *self,
+                                                         real              linewidth);
+void     dia_renderer_set_linecaps                      (DiaRenderer      *self,
+                                                         LineCaps          mode);
+void     dia_renderer_set_linejoin                      (DiaRenderer      *self,
+                                                         LineJoin          mode);
+void     dia_renderer_set_linestyle                     (DiaRenderer      *self,
+                                                         LineStyle         mode,
+                                                         real              length);
+void     dia_renderer_set_fillstyle                     (DiaRenderer      *self,
+                                                         FillStyle         mode);
+void     dia_renderer_set_font                          (DiaRenderer      *self,
+                                                         DiaFont          *font,
+                                                         double            height);
+DiaFont *dia_renderer_get_font                          (DiaRenderer      *self,
+                                                         double           *height);
+void     dia_renderer_draw_line                         (DiaRenderer      *self,
+                                                         Point            *start,
+                                                         Point            *end,
+                                                         Color            *color);
+void     dia_renderer_draw_polygon                      (DiaRenderer      *self,
+                                                         Point            *points,
+                                                         int               num_points,
+                                                         Color            *fill,
+                                                         Color            *stroke);
+void     dia_renderer_draw_arc                          (DiaRenderer      *self,
+                                                         Point            *center,
+                                                         real              width,
+                                                         real              height,
+                                                         real              angle1,
+                                                         real              angle2,
+                                                         Color            *color);
+void     dia_renderer_fill_arc                          (DiaRenderer      *self,
+                                                         Point            *center,
+                                                         real              width,
+                                                         real              height,
+                                                         real              angle1,
+                                                         real              angle2,
+                                                         Color            *color);
+void     dia_renderer_draw_ellipse                      (DiaRenderer      *self,
+                                                         Point            *center,
+                                                         real              width,
+                                                         real              height,
+                                                         Color            *fill,
+                                                         Color            *stroke);
+void     dia_renderer_draw_string                       (DiaRenderer      *self,
+                                                         const gchar      *text,
+                                                         Point            *pos,
+                                                         Alignment         alignment,
+                                                         Color            *color);
+void     dia_renderer_draw_image                        (DiaRenderer      *self,
+                                                         Point            *point,
+                                                         real              width,
+                                                         real              height,
+                                                         DiaImage         *image);
+void     dia_renderer_draw_bezier                       (DiaRenderer      *self,
+                                                         BezPoint         *points,
+                                                         int               numpoints,
+                                                         Color            *color);
+void     dia_renderer_draw_beziergon                    (DiaRenderer      *self,
+                                                         BezPoint         *points,
+                                                         int               numpoints,
+                                                         Color            *fill,
+                                                         Color            *stroke);
+void     dia_renderer_draw_polyline                     (DiaRenderer      *self,
+                                                         Point            *points,
+                                                         int               num_points,
+                                                         Color            *color);
+void     dia_renderer_draw_text                         (DiaRenderer      *self,
+                                                         Text             *text);
+void     dia_renderer_draw_text_line                    (DiaRenderer      *self,
+                                                         TextLine         *text_line,
+                                                         Point            *pos,
+                                                         Alignment         alignment,
+                                                         Color            *color);
+void     dia_renderer_draw_rect                         (DiaRenderer      *self,
+                                                         Point            *ul_corner,
+                                                         Point            *lr_corner,
+                                                         Color            *fill,
+                                                         Color            *stroke);
+void     dia_renderer_draw_rounded_rect                 (DiaRenderer      *self,
+                                                         Point            *ul_corner,
+                                                         Point            *lr_corner,
+                                                         Color            *fill,
+                                                         Color            *stroke,
+                                                         real              radius);
+void     dia_renderer_draw_rounded_polyline             (DiaRenderer      *self,
+                                                         Point            *points,
+                                                         int               num_points,
+                                                         Color            *color,
+                                                         real              radius);
+void     dia_renderer_draw_line_with_arrows             (DiaRenderer      *self,
+                                                         Point            *start,
+                                                         Point            *end,
+                                                         real              line_width,
+                                                         Color            *line_color,
+                                                         Arrow            *start_arrow,
+                                                         Arrow            *end_arrow);
+void     dia_renderer_draw_arc_with_arrows              (DiaRenderer      *self,
+                                                         Point            *start,
+                                                         Point            *end,
+                                                         Point            *midpoint,
+                                                         real              line_width,
+                                                         Color            *color,
+                                                         Arrow            *start_arrow,
+                                                         Arrow            *end_arrow);
+void     dia_renderer_draw_polyline_with_arrows         (DiaRenderer      *self,
+                                                         Point            *points,
+                                                         int               num_points,
+                                                         real              line_width,
+                                                         Color            *color,
+                                                         Arrow            *start_arrow,
+                                                         Arrow            *end_arrow);
+void     dia_renderer_draw_rounded_polyline_with_arrows (DiaRenderer      *self,
+                                                         Point            *points,
+                                                         int               num_points,
+                                                         real              line_width,
+                                                         Color            *color,
+                                                         Arrow            *start_arrow,
+                                                         Arrow            *end_arrow,
+                                                         real              radius);
+void     dia_renderer_draw_bezier_with_arrows           (DiaRenderer      *self,
+                                                         BezPoint         *points,
+                                                         int               num_points,
+                                                         real              line_width,
+                                                         Color            *color,
+                                                         Arrow            *start_arrow,
+                                                         Arrow            *end_arrow);
+gboolean dia_renderer_is_capable_of                     (DiaRenderer      *self,
+                                                         RenderCapability  cap);
+void     dia_renderer_set_pattern                       (DiaRenderer      *self,
+                                                         DiaPattern       *pat);
+void     dia_renderer_draw_rotated_text                 (DiaRenderer      *self,
+                                                         Text             *text,
+                                                         Point            *center,
+                                                         real              angle);
+void     dia_renderer_draw_rotated_image                (DiaRenderer      *self,
+                                                         Point            *point,
+                                                         real              width,
+                                                         real              height,
+                                                         real              angle,
+                                                         DiaImage         *image);
+
+void     dia_renderer_bezier_fill                       (DiaRenderer      *self,
+                                                         BezPoint         *pts,
+                                                         int               total,
+                                                         Color            *color);
+void     dia_renderer_bezier_stroke                     (DiaRenderer      *self,
+                                                         BezPoint         *pts,
+                                                         int               total,
+                                                         Color            *color);
 
 /*! \brief query DIA_RENDER_BOUNDING_BOXES */
 int render_bounding_boxes (void);
diff --git a/lib/diasvgrenderer.c b/lib/diasvgrenderer.c
index e5c6e076..516ea5e9 100644
--- a/lib/diasvgrenderer.c
+++ b/lib/diasvgrenderer.c
@@ -411,7 +411,7 @@ get_draw_style(DiaSvgRenderer *renderer,
     } else {
       g_string_printf(str, "fill: #%02x%02x%02x; fill-opacity: %s",
                      (int)(255*fill->red), (int)(255*fill->green),
-                     (int)(255*fill->blue), 
+                     (int)(255*fill->blue),
                      g_ascii_formatd(alpha_buf, sizeof(alpha_buf), "%g", fill->alpha));
     }
   } else {
@@ -420,7 +420,7 @@ get_draw_style(DiaSvgRenderer *renderer,
 
   if (stroke) {
     g_string_append_printf(str, "; stroke-opacity: %s; stroke-width: %s",
-                          g_ascii_formatd (alpha_buf, sizeof(alpha_buf), "%g", stroke->alpha), 
+                          g_ascii_formatd (alpha_buf, sizeof(alpha_buf), "%g", stroke->alpha),
                           dia_svg_dtostr(linewidth_buf, renderer->linewidth) );
     if (strcmp(renderer->linecap, "butt"))
       g_string_append_printf(str, "; stroke-linecap: %s", renderer->linecap);
@@ -430,7 +430,7 @@ get_draw_style(DiaSvgRenderer *renderer,
       g_string_append_printf(str, "; stroke-dasharray: %s", renderer->linestyle);
 
     g_string_append_printf(str, "; stroke: #%02x%02x%02x",
-                          (int)(255*stroke->red), 
+                          (int)(255*stroke->red),
                           (int)(255*stroke->green),
                           (int)(255*stroke->blue));
   } else {
@@ -444,8 +444,8 @@ get_draw_style(DiaSvgRenderer *renderer,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_line(DiaRenderer *self, 
-         Point *start, Point *end, 
+draw_line(DiaRenderer *self,
+         Point *start, Point *end,
          Color *line_colour)
 {
   DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
@@ -471,8 +471,8 @@ draw_line(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_polyline(DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polyline(DiaRenderer *self,
+             Point *points, int num_points,
              Color *line_colour)
 {
   DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
@@ -500,8 +500,8 @@ draw_polyline(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_polygon (DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polygon (DiaRenderer *self,
+             Point *points, int num_points,
              Color *fill, Color *stroke)
 {
   DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
@@ -532,7 +532,7 @@ draw_polygon (DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_rect(DiaRenderer *self, 
+draw_rect(DiaRenderer *self,
          Point *ul_corner, Point *lr_corner,
          Color *fill, Color *stroke)
 {
@@ -559,7 +559,7 @@ draw_rect(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_arc(DiaRenderer *self, 
+draw_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -585,7 +585,7 @@ draw_arc(DiaRenderer *self,
   large_arc = (fabs(angle2 - angle1) >= 180);
 
   node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"path", NULL);
-  
+
   xmlSetProp(node, (const xmlChar *)"style", (xmlChar *) get_draw_style(renderer, NULL, colour));
 
   g_snprintf(buf, sizeof(buf), "M %s,%s A %s,%s 0 %d %d %s,%s",
@@ -602,7 +602,7 @@ draw_arc(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-fill_arc(DiaRenderer *self, 
+fill_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -628,7 +628,7 @@ fill_arc(DiaRenderer *self,
   gchar cy_buf[DTOSTR_BUF_SIZE];
 
   node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"path", NULL);
-  
+
   xmlSetProp(node, (const xmlChar *)"style", (xmlChar *)get_draw_style(renderer, colour, NULL));
 
   g_snprintf(buf, sizeof(buf), "M %s,%s A %s,%s 0 %d %d %s,%s L %s,%s z",
@@ -647,7 +647,7 @@ fill_arc(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_ellipse(DiaRenderer *self, 
+draw_ellipse(DiaRenderer *self,
             Point *center,
             real width, real height,
             Color *fill, Color *stroke)
@@ -671,7 +671,7 @@ draw_ellipse(DiaRenderer *self,
 }
 
 static void
-_bezier(DiaRenderer *self, 
+_bezier(DiaRenderer *self,
        BezPoint *points,
        int numpoints,
        Color *fill,
@@ -706,11 +706,11 @@ _bezier(DiaRenderer *self,
   for (i = 1; i < numpoints; i++)
     switch (points[i].type) {
     case BEZ_MOVE_TO:
-      if (!DIA_RENDERER_GET_CLASS (self)->is_capable_to(self, RENDER_HOLES)) {
+      if (!dia_renderer_is_capable_of (self, RENDER_HOLES)) {
         g_warning("only first BezPoint should be a BEZ_MOVE_TO");
-        g_string_printf(str, "M %s %s",
-                       dia_svg_dtostr(p1x_buf, (gdouble) points[i].p1.x),
-                       dia_svg_dtostr(p1y_buf, (gdouble) points[i].p1.y) );
+        g_string_printf (str, "M %s %s",
+                         dia_svg_dtostr (p1x_buf, (gdouble) points[i].p1.x),
+                         dia_svg_dtostr (p1y_buf, (gdouble) points[i].p1.y) );
       } else {
         g_string_append_printf(str, "M %s %s",
                        dia_svg_dtostr(p1x_buf, (gdouble) points[i].p1.x),
@@ -745,7 +745,7 @@ _bezier(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_bezier(DiaRenderer *self, 
+draw_bezier(DiaRenderer *self,
            BezPoint *points,
            int numpoints,
            Color *stroke)
@@ -758,7 +758,7 @@ draw_bezier(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_beziergon (DiaRenderer *self, 
+draw_beziergon (DiaRenderer *self,
                BezPoint *points,
                int numpoints,
                Color *fill,
@@ -777,14 +777,21 @@ draw_beziergon (DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_string(DiaRenderer *self,
-           const char *text,
-           Point *pos, Alignment alignment,
-           Color *colour)
-{    
-  TextLine *text_line = text_line_new(text, self->font, self->font_height);
-  draw_text_line(self, text_line, pos, alignment, colour);
-  text_line_destroy(text_line);
+draw_string (DiaRenderer *self,
+             const char  *text,
+             Point       *pos,
+             Alignment    alignment,
+             Color       *colour)
+{
+  TextLine *text_line;
+  DiaFont *font;
+  double font_height;
+
+  font = dia_renderer_get_font (self, &font_height);
+  text_line = text_line_new (text, font, font_height);
+
+  draw_text_line (self, text_line, pos, alignment, colour);
+  text_line_destroy (text_line);
 }
 
 /*!
@@ -794,7 +801,7 @@ draw_string(DiaRenderer *self,
 static void
 draw_text_line(DiaRenderer *self, TextLine *text_line,
               Point *pos, Alignment alignment, Color *colour)
-{    
+{
   DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
   xmlNodePtr node;
   real saved_width;
@@ -802,7 +809,7 @@ draw_text_line(DiaRenderer *self, TextLine *text_line,
   DiaFont *font;
   GString *style;
 
-  node = xmlNewTextChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"text", 
+  node = xmlNewTextChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"text",
                         (xmlChar *) text_line_get_string(text_line));
 
   saved_width = renderer->linewidth;
@@ -813,7 +820,7 @@ draw_text_line(DiaRenderer *self, TextLine *text_line,
   style = g_strdup_printf("%s; font-size: %s", get_draw_style(renderer, colour, NULL),
                        dia_svg_dtostr(d_buf, text_line_get_height(text_line)));
 #else
-  /* get_draw_style: the return value of this function must not be saved 
+  /* get_draw_style: the return value of this function must not be saved
    * anywhere. And of course it must not be free'd */
   style = g_string_new (get_draw_style(renderer, colour, NULL));
 #endif
@@ -881,7 +888,7 @@ draw_image(DiaRenderer *self,
   dia_svg_dtostr(d_buf, height);
   xmlSetProp(node, (const xmlChar *)"height", (xmlChar *) d_buf);
 
-  /* if the image file location is relative to the SVG file's store 
+  /* if the image file location is relative to the SVG file's store
    * a relative path - if it does not have a path: inline it */
   if (strcmp (dia_image_filename(image), "(null)") == 0) {
     gchar *prefix = g_strdup_printf ("data:%s;base64,", dia_image_get_mime_type (image));
@@ -905,7 +912,7 @@ draw_image(DiaRenderer *self,
  * \memberof _DiaSvgRenderer
  */
 static void
-draw_rounded_rect (DiaRenderer *self, 
+draw_rounded_rect (DiaRenderer *self,
                   Point *ul_corner, Point *lr_corner,
                   Color *fill, Color *stroke, real rounding)
 {
@@ -936,9 +943,9 @@ static void
 dia_svg_renderer_init (GTypeInstance *self, gpointer g_class)
 {
   DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
-  
+
   renderer->scale = 1.0;
-  
+
 }
 
 static gpointer parent_class = NULL;
@@ -977,7 +984,7 @@ dia_svg_renderer_get_type (void)
                                             "DiaSvgRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
diff --git a/lib/diatransformrenderer.c b/lib/diatransformrenderer.c
index c71c531c..c337999b 100644
--- a/lib/diatransformrenderer.c
+++ b/lib/diatransformrenderer.c
@@ -121,26 +121,32 @@ is_capable_to (DiaRenderer *self, RenderCapability cap)
 {
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
 
-  if (RENDER_AFFINE == cap)
+  if (RENDER_AFFINE == cap) {
     return TRUE; /* reason for existence */
+  }
+
   g_return_val_if_fail (renderer->worker != NULL, FALSE);
-  return DIA_RENDERER_GET_CLASS (renderer->worker)->is_capable_to (renderer->worker, cap);
+
+  return dia_renderer_is_capable_of (renderer->worker, cap);
 }
+
 /*!
  * \brief Transform line-width and pass through
  * \memberof _DiaTransformRenderer
  */
 static void
-set_linewidth(DiaRenderer *self, real linewidth)
+set_linewidth (DiaRenderer *self, real linewidth)
 {  /* 0 == hairline **/
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
   real lw = linewidth;
   DiaMatrix *m = g_queue_peek_tail (renderer->matrices);
   g_return_if_fail (renderer->worker != NULL);
-  if (m)
+  if (m) {
     transform_length (&lw, m);
-  DIA_RENDERER_GET_CLASS (renderer->worker)->set_linewidth (renderer->worker, lw);
+  }
+  dia_renderer_set_linewidth (renderer->worker, lw);
 }
+
 /*!
  * \brief Pass through line caps
  * \memberof _DiaTransformRenderer
@@ -149,9 +155,12 @@ static void
 set_linecaps(DiaRenderer *self, LineCaps mode)
 {
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
+
   g_return_if_fail (renderer->worker != NULL);
-  DIA_RENDERER_GET_CLASS (renderer->worker)->set_linecaps (renderer->worker, mode);
+
+  dia_renderer_set_linecaps (renderer->worker, mode);
 }
+
 /*!
  * \brief Pass through line join
  * \memberof _DiaTransformRenderer
@@ -160,9 +169,12 @@ static void
 set_linejoin(DiaRenderer *self, LineJoin mode)
 {
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
+
   g_return_if_fail (renderer->worker != NULL);
-  DIA_RENDERER_GET_CLASS (renderer->worker)->set_linejoin (renderer->worker, mode);
+
+  dia_renderer_set_linejoin (renderer->worker, mode);
 }
+
 /*!
  * \brief Pass through line style, transform dash length and pass through
  * \memberof _DiaTransformRenderer
@@ -172,11 +184,16 @@ set_linestyle(DiaRenderer *self, LineStyle mode, real dash_length)
 {
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
   DiaMatrix *m = g_queue_peek_tail (renderer->matrices);
+
   g_return_if_fail (renderer->worker != NULL);
-  if (m)
+
+  if (m) {
     transform_length (&dash_length, m);
-  DIA_RENDERER_GET_CLASS (renderer->worker)->set_linestyle (renderer->worker, mode, dash_length);
+  }
+
+  dia_renderer_set_linestyle (renderer->worker, mode, dash_length);
 }
+
 /*!
  * \brief Pass through fill style
  * \memberof _DiaTransformRenderer
@@ -185,17 +202,21 @@ static void
 set_fillstyle(DiaRenderer *self, FillStyle mode)
 {
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
+
   g_return_if_fail (renderer->worker != NULL);
-  DIA_RENDERER_GET_CLASS (renderer->worker)->set_fillstyle (renderer->worker, mode);
+
+  dia_renderer_set_fillstyle (renderer->worker, mode);
 }
+
 /*!
  * \brief Transform line and delegate draw
  * \memberof _DiaTransformRenderer
  */
 static void
-draw_line(DiaRenderer *self,
-         Point *start, Point *end,
-         Color *line_colour)
+draw_line (DiaRenderer *self,
+           Point       *start,
+           Point       *end,
+           Color       *line_colour)
 {
   Point p1 = *start;
   Point p2 = *end;
@@ -203,16 +224,19 @@ draw_line(DiaRenderer *self,
   DiaMatrix *m = g_queue_peek_tail (renderer->matrices);
   g_return_if_fail (renderer->worker != NULL);
   if (m) {
-    transform_point(&p1, m);
-    transform_point(&p2, m);
+    transform_point (&p1, m);
+    transform_point (&p2, m);
   }
-  DIA_RENDERER_GET_CLASS (renderer->worker)->draw_line (renderer->worker, &p1, &p2, line_colour);
+  dia_renderer_draw_line (renderer->worker, &p1, &p2, line_colour);
 }
+
 static void
-_polyline(DiaRenderer *self,
-         Point *points, int num_points,
-         Color *fill, Color *stroke,
-         gboolean closed)
+_polyline (DiaRenderer *self,
+           Point       *points,
+           int          num_points,
+           Color       *fill,
+           Color       *stroke,
+           gboolean     closed)
 {
   Point *a_pts = g_newa (Point, num_points);
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
@@ -221,60 +245,76 @@ _polyline(DiaRenderer *self,
   memcpy (a_pts, points, sizeof(Point)*num_points);
   if (m) {
     int i;
-    for (i = 0; i < num_points; ++i)
+    for (i = 0; i < num_points; ++i) {
       transform_point (&a_pts[i], m);
+    }
+  }
+  if (closed) {
+    dia_renderer_draw_polygon (renderer->worker, a_pts, num_points, fill, stroke);
+  } else {
+    dia_renderer_draw_polyline (renderer->worker, a_pts, num_points, stroke);
   }
-  if (closed)
-    DIA_RENDERER_GET_CLASS (renderer->worker)->draw_polygon (renderer->worker, a_pts, num_points, fill, 
stroke);
-  else
-    DIA_RENDERER_GET_CLASS (renderer->worker)->draw_polyline (renderer->worker, a_pts, num_points, stroke);
 }
+
 /*!
  * \brief Transform polyline and delegate draw
  * \memberof _DiaTransformRenderer
  */
 static void
-draw_polyline(DiaRenderer *self,
-             Point *points, int num_points,
-             Color *stroke)
+draw_polyline (DiaRenderer *self,
+               Point       *points,
+               int          num_points,
+               Color       *stroke)
 {
   _polyline (self, points, num_points, NULL, stroke, FALSE);
 }
+
 /*!
  * \brief Transform polygon and delegate draw
  * \memberof _DiaTransformRenderer
  */
 static void
-draw_polygon(DiaRenderer *self,
-             Point *points, int num_points,
-             Color *fill, Color *stroke)
+draw_polygon (DiaRenderer *self,
+              Point       *points,
+              int          num_points,
+              Color       *fill,
+              Color       *stroke)
 {
   _polyline (self, points, num_points, fill, stroke, TRUE);
 }
+
 /* ToDo: arc and ellipse to be emulated by bezier - in base class? */
 static void
 _bezier (DiaRenderer *self,
-        BezPoint *points, int num_points,
-        Color *fill, Color *stroke,
-        gboolean closed)
+         BezPoint    *points,
+         int          num_points,
+         Color       *fill,
+         Color       *stroke,
+         gboolean     closed)
 {
   BezPoint *a_pts = g_newa (BezPoint, num_points);
   DiaTransformRenderer *renderer = DIA_TRANSFORM_RENDERER (self);
   DiaMatrix *m = g_queue_peek_tail (renderer->matrices);
+
   g_return_if_fail (renderer->worker != NULL);
+
   memcpy (a_pts, points, sizeof(BezPoint)*num_points);
   if (m) {
     int i;
-    for (i = 0; i < num_points; ++i)
+    for (i = 0; i < num_points; ++i) {
       transform_bezpoint (&a_pts[i], m);
+    }
   }
-  if (closed)
-    DIA_RENDERER_GET_CLASS (renderer->worker)->draw_beziergon (renderer->worker, a_pts, num_points, fill, 
stroke);
-  else
-    DIA_RENDERER_GET_CLASS (renderer->worker)->draw_bezier (renderer->worker, a_pts, num_points, stroke);
-  if (!closed)
+  if (closed) {
+    dia_renderer_draw_beziergon (renderer->worker, a_pts, num_points, fill, stroke);
+  } else {
+    dia_renderer_draw_bezier (renderer->worker, a_pts, num_points, stroke);
+  }
+  if (!closed) {
     g_return_if_fail (fill == NULL && "fill for stroke?");
+  }
 }
+
 static void
 _arc (DiaRenderer *self,
       Point *center,
@@ -287,6 +327,7 @@ _arc (DiaRenderer *self,
   _bezier (self, &g_array_index (path, BezPoint, 0), path->len, fill, stroke, fill!=NULL);
   g_array_free (path, TRUE);
 }
+
 /*!
  * \brief Transform arc and delegate draw
  * \memberof _DiaTransformRenderer
@@ -373,8 +414,10 @@ draw_text (DiaRenderer *self,
     transform_point (&pos, m);
     text_set_position (tc, &pos);
     text_set_height (tc, text_get_height (text) * MIN(sx,sy));
-    DIA_RENDERER_GET_CLASS(renderer->worker)->draw_rotated_text (renderer->worker, tc,
-                                                                NULL, 180.0 * angle / G_PI);
+    dia_renderer_draw_rotated_text (renderer->worker,
+                                    tc,
+                                    NULL,
+                                    180.0 * angle / G_PI);
     text_destroy (tc);
   } else {
     for (i=0;i<text->numlines;i++) {
@@ -386,9 +429,11 @@ draw_text (DiaRenderer *self,
         transform_point (&pt, m);
         /* ToDo: font-size and angle */
       }
-      DIA_RENDERER_GET_CLASS(renderer->worker)->draw_text_line(renderer->worker, text_line,
-                                                              &pt, text->alignment,
-                                                              &text->color);
+      dia_renderer_draw_text_line (renderer->worker,
+                                   text_line,
+                                   &pt,
+                                   text->alignment,
+                                   &text->color);
       pos.y += text->height;
     }
   }
@@ -428,16 +473,20 @@ draw_rotated_text (DiaRenderer *self, Text *text, Point *center, real angle)
       transform_point (&pos, m);
       text_set_position (tc, &pos);
       text_set_height (tc, text_get_height (text) * MIN(sx,sy));
-      DIA_RENDERER_GET_CLASS(renderer->worker)->draw_rotated_text (renderer->worker, tc,
-                                                                  NULL, 180.0 * angle2 / G_PI);
+      dia_renderer_draw_rotated_text (renderer->worker,
+                                      tc,
+                                      NULL,
+                                      180.0 * angle2 / G_PI);
       text_destroy (tc);
     } else {
       g_warning ("DiaTransformRenderer::draw_rotated_text() bad matrix.");
     }
   } else {
     /* just pass through */
-    DIA_RENDERER_GET_CLASS(renderer->worker)->draw_rotated_text (renderer->worker, text,
-                                                                center, G_PI * angle / 180.0);
+    dia_renderer_draw_rotated_text (renderer->worker,
+                                    text,
+                                    center,
+                                    G_PI * angle / 180.0);
   }
 }
 
@@ -446,21 +495,31 @@ draw_rotated_text (DiaRenderer *self, Text *text, Point *center, real angle)
  * \memberof _DiaTransformRenderer
  */
 static void
-draw_string(DiaRenderer *self,
-           const char *text,
-           Point *pos, Alignment alignment,
-           Color *color)
+draw_string (DiaRenderer *self,
+             const char  *text,
+             Point       *pos,
+             Alignment    alignment,
+             Color       *color)
 {
-  if (text && strlen(text)) {
+  if (text && strlen (text)) {
     Text *text_obj;
+    DiaFont *font;
+    double font_height;
+
+    font = dia_renderer_get_font (self, &font_height);
+
     /* it could have been so easy without the context switch */
     text_obj = new_text (text,
-                        self->font, self->font_height,
-                        pos, color, alignment);
+                         font,
+                         font_height,
+                         pos,
+                         color,
+                         alignment);
     draw_text (self, text_obj);
     text_destroy (text_obj);
   }
 }
+
 /*!
  * \brief Draw a potentially transformed image
  * \memberof _DiaTransformRenderer
@@ -486,7 +545,7 @@ draw_image(DiaRenderer *self,
     p1.y = pc.y - height/2.0;
   }
   /* FIXME: for now only the position is transformed */
-  DIA_RENDERER_GET_CLASS (renderer->worker)->draw_image (renderer->worker, &p1, width, height, image);
+  dia_renderer_draw_image (renderer->worker, &p1, width, height, image);
 }
 
 /*!
diff --git a/lib/diatypes.h b/lib/diatypes.h
index f4f3d4c0..4ba02de4 100644
--- a/lib/diatypes.h
+++ b/lib/diatypes.h
@@ -71,9 +71,6 @@ typedef struct _DiaContext DiaContext;
 
 /* In diarenderer.h: */
 typedef struct _BezierApprox BezierApprox;
-typedef struct _DiaRenderer DiaRenderer;
-typedef struct _DiaRendererClass DiaRendererClass;
-typedef struct _DiaInteractiveRendererInterface DiaInteractiveRendererInterface;
 
 /* In diacellrendererproperty.h: */
 typedef struct _DiaCellRendererProperty DiaCellRendererProperty;
@@ -151,7 +148,7 @@ typedef struct _PropEventData PropEventData;
 typedef struct _PropDialog PropDialog;
 typedef struct _PropEventHandlerChain PropEventHandlerChain;
 typedef struct _PropWidgetAssoc PropWidgetAssoc;
-typedef struct _PropertyOps PropertyOps; 
+typedef struct _PropertyOps PropertyOps;
 typedef struct _PropNumData PropNumData;
 typedef struct _PropEnumData PropEnumData;
 typedef struct _PropDescCommonArrayExtra PropDescCommonArrayExtra;
diff --git a/lib/group.c b/lib/group.c
index a5097d6c..42517f94 100644
--- a/lib/group.c
+++ b/lib/group.c
@@ -330,7 +330,7 @@ group_move(Group *group, Point *to)
 }
 
 static void
-group_draw(Group *group, DiaRenderer *renderer)
+group_draw (Group *group, DiaRenderer *renderer)
 {
   GList *list;
   DiaObject *obj;
@@ -339,7 +339,7 @@ group_draw(Group *group, DiaRenderer *renderer)
   while (list != NULL) {
     obj = (DiaObject *) list->data;
 
-    DIA_RENDERER_GET_CLASS(renderer)->draw_object(renderer, obj, group->matrix);
+    dia_renderer_draw_object (renderer, obj, group->matrix);
     list = g_list_next(list);
   }
 }
diff --git a/lib/layer.c b/lib/layer.c
index 5f679cce..ab73dbd3 100644
--- a/lib/layer.c
+++ b/lib/layer.c
@@ -34,11 +34,12 @@ static const Rectangle invalid_extents = { -1.0,-1.0,-1.0,-1.0 };
  * \ingroup DiagramStructure
  */
 static void
-normal_render(DiaObject *obj, DiaRenderer *renderer,
-             int active_layer,
-             gpointer data)
+normal_render (DiaObject   *obj,
+               DiaRenderer *renderer,
+               int          active_layer,
+               gpointer     data)
 {
-  DIA_RENDERER_GET_CLASS(renderer)->draw_object(renderer, obj, NULL);
+  dia_renderer_draw_object (renderer, obj, NULL);
 }
 
 
@@ -105,8 +106,8 @@ layer_render (Layer          *layer,
         col.blue = 1.0;
         col.alpha = 1.0;
 
-        DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer,0.01);
-        DIA_RENDERER_GET_CLASS (renderer)->draw_rect (renderer, &p1, &p2, NULL, &col);
+        dia_renderer_set_linewidth (renderer,0.01);
+        dia_renderer_draw_rect (renderer, &p1, &p2, NULL, &col);
       }
       (*obj_renderer) (obj, renderer, active_layer, data);
     }
diff --git a/lib/libdia.def b/lib/libdia.def
index 67683ba7..b6f39432 100644
--- a/lib/libdia.def
+++ b/lib/libdia.def
@@ -31,8 +31,8 @@ EXPORTS
  new_attribute
 
  bezier_draw_control_lines
- bezier_render_stroke
- bezier_render_fill
+ dia_renderer_bezier_stroke
+ dia_renderer_bezier_fill
  beziercommon_set_points
  beziercommon_closest_segment
 
@@ -98,7 +98,7 @@ EXPORTS
 
  connpoint_is_autogap
  connpoint_update
- 
+
  connpointline_add_points
  connpointline_adjust_count
  connpointline_can_add_point
@@ -160,7 +160,7 @@ EXPORTS
  data_get_sorted_selected_remove
  data_highlight_add
  data_highlight_remove
- data_object_get_highlight 
+ data_object_get_highlight
  data_int
  data_layer_count
  data_layer_get_index
@@ -315,10 +315,10 @@ EXPORTS
  dia_object_set_pattern
 
  dia_interactive_renderer_interface_get_type
- 
+
  dialog_make
  dialog_add_spinbutton
- 
+
  dia_line_chooser_new
 
  dia_line_style_selector_get_linestyle
@@ -406,7 +406,7 @@ EXPORTS
  sheet_append_sheet_obj
 
  diagram_data_get_type
- 
+
  dia_unit_spinner_get_type
  dia_unit_spinner_get_value
  dia_unit_spinner_new
@@ -464,12 +464,12 @@ EXPORTS
 
  find_paper
  find_slope_directions
- 
+
  focus_get_object
  focus_get_first_on_object
  focus_previous_on_diagram
  focus_next_on_diagram
- 
+
 
  get_default_paper
  get_paper_bmargin
@@ -493,7 +493,7 @@ EXPORTS
  get_active_focus
  give_focus
 ; give_focus_to_object
- 
+
  int_rectangle_union
 
  intl_score_locale
@@ -526,7 +526,7 @@ EXPORTS
  line_line_intersection
 
  dia_error_quark
- 
+
  message_error
  message_notice
  message_warning
@@ -715,7 +715,7 @@ EXPORTS
  rectangle_union
 
  remove_focus_on_diagram
- remove_focus_object 
+ remove_focus_object
 
  reset_foci_on_diagram
 
@@ -778,12 +778,12 @@ EXPORTS
 
  calculate_object_edge
 
-; exported for libart renderer only 
+; exported for libart renderer only
  dia_font_pop_context
  dia_font_push_context
  dia_transform_coords_double
  text_line_adjust_layout_line
- 
+
  libdia_init
  dia_log_message
 
@@ -808,4 +808,3 @@ EXPORTS
  cairo_export_data
  cairo_print_callback
  dia_cairo_renderer_get_type
- 
\ No newline at end of file
diff --git a/lib/object.h b/lib/object.h
index 6f7991e3..6b2454ce 100644
--- a/lib/object.h
+++ b/lib/object.h
@@ -33,6 +33,7 @@
 #include "dia_xml.h"
 #include "text.h"
 #include "diacontext.h"
+#include "diarenderer.h"
 
 G_BEGIN_DECLS
 
diff --git a/lib/prop_basic.c b/lib/prop_basic.c
index 206b3414..c79c0ec5 100644
--- a/lib/prop_basic.c
+++ b/lib/prop_basic.c
@@ -29,6 +29,7 @@
 
 #include <gtk/gtk.h>
 #define WIDGET GtkWidget
+
 #include "properties.h"
 #include "prop_basic.h"
 #include "propinternals.h"
diff --git a/lib/properties.h b/lib/properties.h
index 8211b011..dd712719 100644
--- a/lib/properties.h
+++ b/lib/properties.h
@@ -30,7 +30,7 @@
 #else
 #define WIDGET void
 #endif
-#endif 
+#endif
 
 
 #ifdef HAVE_STDDEF_H
@@ -40,6 +40,7 @@
 #include <glib.h>
 #include "diatypes.h"
 
+#include "diarenderer.h"
 #include "geometry.h"
 #include "arrows.h"
 #include "color.h"
@@ -69,8 +70,8 @@ struct _PropDialog {
   WIDGET *widget; /* widget of self */
 
   GPtrArray *props; /* of Property * */
-  GArray *prop_widgets; /* of PropWidgetAssoc. This is a "flat" listing of 
-                           properties and widgets (no nesting information is 
+  GArray *prop_widgets; /* of PropWidgetAssoc. This is a "flat" listing of
+                           properties and widgets (no nesting information is
                            kept here) */
   GList *objects; /* a copy of the objects, to be used as scratch. */
   GList *copies;  /* The original objects. */
@@ -84,7 +85,7 @@ struct _PropDialog {
 struct _PropEventData {
   PropDialog *dialog;
   WIDGET *widget;
-  Property *self; 
+  Property *self;
 };
 
 typedef gboolean (*PropEventHandler) (DiaObject *obj, Property *prop);
@@ -117,7 +118,7 @@ typedef void (*PropertyType_Load)(Property *prop, AttributeNode attr, DataNode d
 /*! save a property to XML node */
 typedef void (*PropertyType_Save)(Property *prop, AttributeNode attr, DiaContext *ctx);
 
-/* If a property descriptor can be merged with another 
+/* If a property descriptor can be merged with another
    (DONT_MERGE has already been handled) */
 typedef gboolean (*PropertyType_CanMerge)(const PropDescription *pd1,const PropDescription *pd2);
 typedef void (*PropertyType_GetFromOffset)(const Property *prop,
@@ -213,7 +214,7 @@ typedef const gchar *PropertyType;
 #define PROP_TYPE_FRAME_BEGIN "f_begin" /* FrameProperty */
 #define PROP_TYPE_FRAME_END "f_end"     /* FrameProperty */
 #define PROP_TYPE_LIST "list"  /* ListProperty */
-/* (offset is a GPtrArray of (const gchar *). offset2 is a gint, index of the 
+/* (offset is a GPtrArray of (const gchar *). offset2 is a gint, index of the
    active item, -1 if none active.) */
 
 /* Special types : */
@@ -256,13 +257,13 @@ struct _PropDescription {
    */
   gpointer extra_data;
 
-  /*! 
+  /*!
    * \brief Optional event handler
    *
    * If the property widget can send events when it's somehow interacted with,
-   * control will be passed to object_type-supplied event_handler, and 
+   * control will be passed to object_type-supplied event_handler, and
    * event->dialog->obj_copy will be current with the dialog's values.
-   * When control comes back, event->dialog->obj_copy's properties will be 
+   * When control comes back, event->dialog->obj_copy's properties will be
    * brought back into the dialog.
    */
   PropEventHandler event_handler;
@@ -270,10 +271,10 @@ struct _PropDescription {
   GQuark quark; /* quark for property name -- helps speed up lookups. */
   GQuark type_quark;
 
-  /* only used by dynamically constructed property descriptors (eg. groups) */ 
+  /* only used by dynamically constructed property descriptors (eg. groups) */
   PropEventHandlerChain chain_handler;
 
-  const PropertyOps *ops;      
+  const PropertyOps *ops;
 };
 
 /*!
@@ -331,17 +332,17 @@ struct _PropEnumData {
 typedef gpointer (*NewRecordFunc)(void);
 typedef void (*FreeRecordFunc)(gpointer rec);
 
-struct _PropDescCommonArrayExtra { /* don't use this directly. 
+struct _PropDescCommonArrayExtra { /* don't use this directly.
                                       Use one of below */
   PropDescription *record;
   PropOffset      *offsets; /* the offsets into the structs in the list/array */
-  const gchar     *composite_type; /* can be NULL. */ 
+  const gchar     *composite_type; /* can be NULL. */
 };
 
 struct _PropDescDArrayExtra {
   PropDescCommonArrayExtra common; /* must be first */
-  NewRecordFunc newrec;        
-  FreeRecordFunc freerec; 
+  NewRecordFunc newrec;
+  FreeRecordFunc freerec;
 };
 
 struct  _PropDescSArrayExtra {
@@ -356,7 +357,7 @@ struct  _PropDescSArrayExtra {
  */
 struct _Property {
   /*! Calculated unique key for the name of the property */
-  GQuark name_quark; 
+  GQuark name_quark;
   /*! Calculated unique key for the type of the property */
   GQuark type_quark;
   /*! Description of the property - almost alway constant (exception is Group) */
@@ -367,7 +368,7 @@ struct _Property {
   PropDescToPropPredicate reason;
   /*! property experience, e.g. loaded, \sa PropExperience */
   guint experience;       /* flags PXP_.... */
- 
+
   const PropertyOps *ops;       /* points to common_prop_ops */
   const PropertyOps *real_ops;  /* == descr->ops */
 };
@@ -390,7 +391,7 @@ struct _Property {
 
 void prop_desc_list_calculate_quarks(PropDescription *plist);
 /*! plist must have all quarks calculated in advance */
-const PropDescription *prop_desc_list_find_prop(const PropDescription *plist, 
+const PropDescription *prop_desc_list_find_prop(const PropDescription *plist,
                                                 const gchar *name);
 /*! finds the real handler in case there are several levels of indirection */
 PropEventHandler prop_desc_find_real_handler(const PropDescription *pdesc);
@@ -399,7 +400,7 @@ void prop_desc_free_handler_chain(PropDescription *pdesc);
 /*! free a handler indirection list in a list of descriptors */
 void prop_desc_list_free_handler_chain(PropDescription *pdesc);
 /*! insert an event handler */
-void prop_desc_insert_handler(PropDescription *pdesc, 
+void prop_desc_insert_handler(PropDescription *pdesc,
                               PropEventHandler handler);
 
 /*! operations on lists of property description lists */
@@ -424,11 +425,11 @@ GPtrArray *prop_list_copy_empty(GPtrArray *plist);
 /*! Appends copies of the properties in the second list to the first. */
 void prop_list_add_list (GPtrArray *props, const GPtrArray *ptoadd);
 
-GPtrArray *prop_list_from_descs(const PropDescription *plist, 
+GPtrArray *prop_list_from_descs(const PropDescription *plist,
                                 PropDescToPropPredicate pred);
 
-/* Swallows the property into a single property list. Can be given NULL. 
-   Don't free yourself the property afterwards; prop_list_free() the list 
+/* Swallows the property into a single property list. Can be given NULL.
+   Don't free yourself the property afterwards; prop_list_free() the list
    instead.
    You regain responsibility for the property if you g_ptr_array_destroy() the
    list. */
@@ -463,22 +464,22 @@ void prop_list_add_matrix (GPtrArray *plist, const DiaMatrix *m);
 
 /* Some predicates: */
 gboolean pdtpp_true(const PropDescription *pdesc); /* always true */
-gboolean pdtpp_is_visible(const PropDescription *pdesc); 
-gboolean pdtpp_is_visible_no_standard(const PropDescription *pdesc); 
-gboolean pdtpp_is_not_visible(const PropDescription *pdesc); 
-gboolean pdtpp_do_save(const PropDescription *pdesc); 
+gboolean pdtpp_is_visible(const PropDescription *pdesc);
+gboolean pdtpp_is_visible_no_standard(const PropDescription *pdesc);
+gboolean pdtpp_is_not_visible(const PropDescription *pdesc);
+gboolean pdtpp_do_save(const PropDescription *pdesc);
 gboolean pdtpp_do_save_no_standard(const PropDescription *pdesc);
 gboolean pdtpp_do_load(const PropDescription *pdesc);
-gboolean pdtpp_do_not_save(const PropDescription *pdesc); 
+gboolean pdtpp_do_not_save(const PropDescription *pdesc);
 /* all but DONT_MERGE and NO_DEFAULTS: */
-gboolean pdtpp_defaults(const PropDescription *pdesc); 
+gboolean pdtpp_defaults(const PropDescription *pdesc);
 /* actually used for the "reason" parameter, not as predicates (synonyms for pdtpp_true) */
 gboolean pdtpp_synthetic(const PropDescription *pdesc);
 gboolean pdtpp_from_object(const PropDescription *pdesc);
 
 
 /* Create a new property of the required type, with the required name.
-   A PropDescription might be created on the fly. The property's value is not 
+   A PropDescription might be created on the fly. The property's value is not
    initialised (actually, it's zero). */
 Property *make_new_prop(const char *name, PropertyType type, guint flags);
 
@@ -510,7 +511,7 @@ gboolean objects_comply_with_stdprop(GList *objects);
 
 void object_list_get_props(GList *objects, GPtrArray *props);
 
-/* will do whatever is needed to make the PropDescription * list look good to 
+/* will do whatever is needed to make the PropDescription * list look good to
    the rest of the properties code. Can return NULL. */
 const PropDescription *object_get_prop_descriptions(const DiaObject *obj);
 const PropDescription *object_list_get_prop_descriptions(GList *objects,
@@ -564,24 +565,24 @@ ObjectChange *dia_object_set_pattern (DiaObject *object, DiaPattern *pat);
 /* Set the string property if there is one */
 ObjectChange *dia_object_set_string (DiaObject *object, const char *name, const char *value);
 
-/* ************************************************************* */ 
+/* ************************************************************* */
 
 void stdprops_init(void);
 
-/* ************************************************************* */ 
+/* ************************************************************* */
 
 /* standard properties.  By using these, the intersection of the properties
  * of a number of objects should be greater, making setting properties on
  * groups better. */
 
-/* HB: exporting the following two vars by GIMPVAR==dllexport/dllimport, 
- * does mean the pointers used below have to be calculated 
+/* HB: exporting the following two vars by GIMPVAR==dllexport/dllimport,
+ * does mean the pointers used below have to be calculated
  * at run-time by the loader, because they will exist
  * only once in the process space and dynamic link libraries may be
- * relocated. As a result their address is no longer constant. 
- * Indeed it causes compile time errors with MSVC (initialzer 
+ * relocated. As a result their address is no longer constant.
+ * Indeed it causes compile time errors with MSVC (initialzer
  * not a constant).
- * To fix it they are moved form properties.c and declared as static 
+ * To fix it they are moved form properties.c and declared as static
  * on Win32
  */
 #ifdef G_OS_WIN32
diff --git a/lib/renderer/diacairo-interactive.c b/lib/renderer/diacairo-interactive.c
index 8950ce8c..f1278395 100644
--- a/lib/renderer/diacairo-interactive.c
+++ b/lib/renderer/diacairo-interactive.c
@@ -235,6 +235,10 @@ dia_cairo_interactive_renderer_get_text_width (DiaRenderer *object,
 {
   real result;
   TextLine *text_line;
+  DiaFont *font;
+  double font_height;
+
+  font = dia_renderer_get_font (object, &font_height);
 
   if (length != g_utf8_strlen (text, -1)) {
     char *shorter;
@@ -244,13 +248,14 @@ dia_cairo_interactive_renderer_get_text_width (DiaRenderer *object,
       g_warning ("Text at char %d not valid\n", length);
     }
     shorter = g_strndup (text, ulen);
-    text_line = text_line_new (shorter, object->font, object->font_height);
+    text_line = text_line_new (shorter, font, font_height);
     g_free (shorter);
   } else {
-    text_line = text_line_new (text, object->font, object->font_height);
+    text_line = text_line_new (text, font, font_height);
   }
   result = text_line_get_width (text_line);
   text_line_destroy (text_line);
+
   return result;
 }
 
diff --git a/lib/renderer/diacairo-renderer.c b/lib/renderer/diacairo-renderer.c
index 5c7af2e3..43deeed7 100644
--- a/lib/renderer/diacairo-renderer.c
+++ b/lib/renderer/diacairo-renderer.c
@@ -57,6 +57,14 @@
 
 G_DEFINE_TYPE (DiaCairoRenderer, dia_cairo_renderer, DIA_TYPE_RENDERER)
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 static void ensure_minimum_one_device_unit (DiaCairoRenderer *renderer,
                                             real             *value);
 
@@ -561,15 +569,12 @@ dia_cairo_renderer_set_font (DiaRenderer *self, DiaFont *font, real height)
   pango_layout_set_font_description (renderer->layout, pfd);
   pango_font_description_free (pfd);
 
-  /* for the interactive case we must maintain the font field in the base class */
-  if (DIA_IS_INTERACTIVE_RENDERER (self)) {
-    dia_font_ref (font);
-    if (self->font) {
-      dia_font_unref (self->font);
-    }
-    self->font = font;
-    self->font_height = height;
+  dia_font_ref (font);
+  if (renderer->font) {
+    dia_font_unref (renderer->font);
   }
+  renderer->font = font;
+  renderer->font_height = height;
 }
 
 static void
@@ -1200,6 +1205,52 @@ dia_cairo_renderer_init (DiaCairoRenderer *renderer)
   renderer->scale = 1.0;
 }
 
+static void
+dia_cairo_renderer_set_property (GObject      *object,
+                                 guint         property_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+  DiaCairoRenderer *self = DIA_CAIRO_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      dia_cairo_renderer_set_font (DIA_RENDERER (self),
+                                   g_value_get_object (value),
+                                   self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      dia_cairo_renderer_set_font (DIA_RENDERER (self),
+                                   self->font,
+                                   g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+dia_cairo_renderer_get_property (GObject    *object,
+                                 guint       property_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+  DiaCairoRenderer *self = DIA_CAIRO_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 cairo_renderer_finalize (GObject *object)
 {
@@ -1213,6 +1264,8 @@ cairo_renderer_finalize (GObject *object)
     g_object_unref (renderer->layout);
   }
 
+  g_clear_object (&renderer->font);
+
   G_OBJECT_CLASS (dia_cairo_renderer_parent_class)->finalize (object);
 }
 
@@ -1222,6 +1275,8 @@ dia_cairo_renderer_class_init (DiaCairoRendererClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   DiaRendererClass *renderer_class = DIA_RENDERER_CLASS (klass);
 
+  object_class->set_property = dia_cairo_renderer_set_property;
+  object_class->get_property = dia_cairo_renderer_get_property;
   object_class->finalize = cairo_renderer_finalize;
 
   /* renderer members */
@@ -1235,8 +1290,6 @@ dia_cairo_renderer_class_init (DiaCairoRendererClass *klass)
   renderer_class->set_linestyle  = dia_cairo_renderer_set_linestyle;
   renderer_class->set_fillstyle  = dia_cairo_renderer_set_fillstyle;
 
-  renderer_class->set_font = dia_cairo_renderer_set_font;
-
   renderer_class->draw_line    = dia_cairo_renderer_draw_line;
   renderer_class->draw_polygon = dia_cairo_renderer_draw_polygon;
   renderer_class->draw_arc     = dia_cairo_renderer_draw_arc;
@@ -1261,4 +1314,7 @@ dia_cairo_renderer_class_init (DiaCairoRendererClass *klass)
   /* other */
   renderer_class->is_capable_to = dia_cairo_renderer_is_capable_to;
   renderer_class->set_pattern   = dia_cairo_renderer_set_pattern;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
diff --git a/lib/renderer/diacairo.h b/lib/renderer/diacairo.h
index 1cd37e9b..3cde4608 100644
--- a/lib/renderer/diacairo.h
+++ b/lib/renderer/diacairo.h
@@ -75,6 +75,9 @@ struct _DiaCairoRenderer
   /** caching the font description from set_font */
   PangoLayout *layout;
 
+  DiaFont *font;
+  double font_height;
+
   /*! If set use for fill */
   DiaPattern *pattern;
 };
diff --git a/lib/standard-path.c b/lib/standard-path.c
index 923852d1..5a9f77ca 100644
--- a/lib/standard-path.c
+++ b/lib/standard-path.c
@@ -388,47 +388,62 @@ stdpath_update_data (StdPath *stdpath)
  * \memberof _StdPath
  */
 static void
-stdpath_draw(StdPath *stdpath, DiaRenderer *renderer)
+stdpath_draw (StdPath *stdpath, DiaRenderer *renderer)
 {
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, stdpath->line_width);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, stdpath->line_style, stdpath->dashlength);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin(renderer, stdpath->line_join);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps(renderer, stdpath->line_caps);
+  dia_renderer_set_linewidth (renderer, stdpath->line_width);
+  dia_renderer_set_linestyle (renderer, stdpath->line_style, stdpath->dashlength);
+  dia_renderer_set_linejoin (renderer, stdpath->line_join);
+  dia_renderer_set_linecaps (renderer, stdpath->line_caps);
 
-  if (DIA_RENDERER_GET_CLASS (renderer)->is_capable_to(renderer, RENDER_HOLES)) {
+  if (dia_renderer_is_capable_of (renderer, RENDER_HOLES)) {
     if (stdpath->stroke_or_fill & PDO_FILL) {
       Color fill = stdpath->fill_color;
       if (stdpath->pattern) {
-       dia_pattern_get_fallback_color (stdpath->pattern, &fill);
-       if (DIA_RENDERER_GET_CLASS (renderer)->is_capable_to(renderer, RENDER_PATTERN))
-         DIA_RENDERER_GET_CLASS (renderer)->set_pattern (renderer, stdpath->pattern);
+        dia_pattern_get_fallback_color (stdpath->pattern, &fill);
+        if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+          dia_renderer_set_pattern (renderer, stdpath->pattern);
+        }
+      }
+      if (stdpath->stroke_or_fill & PDO_STROKE) { /* also stroke -> combine */
+        dia_renderer_draw_beziergon (renderer,
+                                     stdpath->points,
+                                     stdpath->num_points,
+                                     &fill,
+                                     &stdpath->line_color);
+      } else {
+        dia_renderer_draw_beziergon (renderer,
+                                     stdpath->points,
+                                     stdpath->num_points,
+                                     &fill,
+                                     NULL);
+      }
+      if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+        dia_renderer_set_pattern (renderer, NULL);
       }
-      if (stdpath->stroke_or_fill & PDO_STROKE) /* also stroke -> combine */
-        DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon(renderer, stdpath->points, stdpath->num_points,
-                                                         &fill, &stdpath->line_color);
-      else
-        DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon(renderer, stdpath->points, stdpath->num_points,
-                                                         &fill, NULL);
-      if (DIA_RENDERER_GET_CLASS (renderer)->is_capable_to(renderer, RENDER_PATTERN))
-       DIA_RENDERER_GET_CLASS (renderer)->set_pattern (renderer, NULL);
     }
-    if (stdpath->stroke_or_fill == PDO_STROKE) /* stroke only */
-      DIA_RENDERER_GET_CLASS (renderer)->draw_bezier(renderer, stdpath->points, stdpath->num_points,
-                                                    &stdpath->line_color);
+    if (stdpath->stroke_or_fill == PDO_STROKE) { /* stroke only */
+      dia_renderer_draw_bezier (renderer,
+                                stdpath->points,
+                                stdpath->num_points,
+                                &stdpath->line_color);
+    }
   } else {
     /* step-wise approach */
     /* if it wouldn't RENDER_HOLES it presumably also wouldn't RENDER_PATTERN ... */
     if (stdpath->stroke_or_fill & PDO_FILL) {
       Color fill = stdpath->fill_color;
-      if (stdpath->pattern)
-       dia_pattern_get_fallback_color (stdpath->pattern, &fill);
-      bezier_render_fill (renderer, stdpath->points, stdpath->num_points, &fill);
+      if (stdpath->pattern) {
+        dia_pattern_get_fallback_color (stdpath->pattern, &fill);
+      }
+      dia_renderer_bezier_fill (renderer, stdpath->points, stdpath->num_points, &fill);
+    }
+    if (stdpath->stroke_or_fill & PDO_STROKE) {
+      dia_renderer_bezier_stroke (renderer, stdpath->points, stdpath->num_points, &stdpath->line_color);
     }
-    if (stdpath->stroke_or_fill & PDO_STROKE)
-      bezier_render_stroke (renderer, stdpath->points, stdpath->num_points, &stdpath->line_color);
   }
-  if (stdpath->show_control_lines)
+  if (stdpath->show_control_lines) {
     bezier_draw_control_lines (stdpath->num_points, stdpath->points, renderer);
+  }
 }
 
 static ObjectChange *_path_object_invert_change_create (DiaObject *obj);
diff --git a/lib/text.c b/lib/text.c
index 75f365ba..e455cd1c 100644
--- a/lib/text.c
+++ b/lib/text.c
@@ -555,9 +555,9 @@ text_distance_from(Text *text, Point *point)
 }
 
 void
-text_draw(Text *text, DiaRenderer *renderer)
+text_draw (Text *text, DiaRenderer *renderer)
 {
-  DIA_RENDERER_GET_CLASS (renderer)->draw_text (renderer, text);
+  dia_renderer_draw_text (renderer, text);
 
   if (DIA_IS_INTERACTIVE_RENDERER (renderer) && (text->focus.has_focus)) {
     real curs_x, curs_y;
@@ -567,27 +567,25 @@ text_draw(Text *text, DiaRenderer *renderer)
     real height = text->ascent+text->descent;
     curs_y = text->position.y - text->ascent + text->cursor_row*text->height;
 
-    DIA_RENDERER_GET_CLASS (renderer)->set_font (renderer, text->font, text->height);
+    dia_renderer_set_font (renderer, text->font, text->height);
 
-    str_width_first =
-      DIA_RENDERER_GET_CLASS (renderer)->get_text_width (renderer,
-                                                         text_get_line (text, text->cursor_row),
-                                                         text->cursor_pos);
-    str_width_whole =
-      DIA_RENDERER_GET_CLASS (renderer)->get_text_width (renderer,
-                                                         text_get_line (text, text->cursor_row),
-                                                         text_get_line_strlen (text, text->cursor_row));
+    str_width_first = dia_renderer_get_text_width (renderer,
+                                                   text_get_line (text, text->cursor_row),
+                                                   text->cursor_pos);
+    str_width_whole = dia_renderer_get_text_width (renderer,
+                                                   text_get_line (text, text->cursor_row),
+                                                   text_get_line_strlen (text, text->cursor_row));
     curs_x = text->position.x + str_width_first;
 
     switch (text->alignment) {
-    case ALIGN_LEFT:
-      break;
-    case ALIGN_CENTER:
-      curs_x -= str_width_whole / 2.0;
-      break;
-    case ALIGN_RIGHT:
-      curs_x -= str_width_whole;
-      break;
+      case ALIGN_LEFT:
+        break;
+      case ALIGN_CENTER:
+        curs_x -= str_width_whole / 2.0;
+        break;
+      case ALIGN_RIGHT:
+        curs_x -= str_width_whole;
+        break;
     }
 
     p1.x = curs_x;
@@ -595,9 +593,9 @@ text_draw(Text *text, DiaRenderer *renderer)
     p2.x = curs_x;
     p2.y = curs_y + height;
 
-    DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-    DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer, height/CURSOR_HEIGHT_RATIO);
-    DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &p1, &p2, &color_black);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linewidth (renderer, height/CURSOR_HEIGHT_RATIO);
+    dia_renderer_draw_line (renderer, &p1, &p2, &color_black);
   }
 }
 
@@ -697,41 +695,39 @@ text_set_cursor (Text        *text,
     }
 
 
-    DIA_RENDERER_GET_CLASS (renderer)->set_font (renderer, text->font, text->height);
-    str_width_whole =
-      DIA_RENDERER_GET_CLASS (renderer)->get_text_width (renderer,
-                                                         text_get_line (text, row),
-                                                         text_get_line_strlen (text, row));
+    dia_renderer_set_font (renderer, text->font, text->height);
+    str_width_whole = dia_renderer_get_text_width (renderer,
+                                                   text_get_line (text, row),
+                                                   text_get_line_strlen (text, row));
     start_x = text->position.x;
     switch (text->alignment) {
-    case ALIGN_LEFT:
-      break;
-    case ALIGN_CENTER:
-      start_x -= str_width_whole / 2.0;
-      break;
-    case ALIGN_RIGHT:
-      start_x -= str_width_whole;
-      break;
+      case ALIGN_LEFT:
+        break;
+      case ALIGN_CENTER:
+        start_x -= str_width_whole / 2.0;
+        break;
+      case ALIGN_RIGHT:
+        start_x -= str_width_whole;
+        break;
     }
 
     /* Do an ugly linear search for the cursor index:
        TODO: Change to binary search */
     {
       real min_dist = G_MAXDOUBLE;
-      for (i=0;i<=text_get_line_strlen(text, row);i++) {
-       real dist;
-       str_width_first =
-         DIA_RENDERER_GET_CLASS(renderer)->get_text_width(renderer, text_get_line(text, row), i);
-       dist = fabs(clicked_point->x - (start_x + str_width_first));
-       if (dist < min_dist) {
-         min_dist = dist;
-         text->cursor_pos = i;
-       } else {
-         return;
-       }
+      for (i = 0; i <= text_get_line_strlen (text, row); i++) {
+        real dist;
+        str_width_first = dia_renderer_get_text_width (renderer, text_get_line (text, row), i);
+        dist = fabs (clicked_point->x - (start_x + str_width_first));
+        if (dist < min_dist) {
+          min_dist = dist;
+          text->cursor_pos = i;
+        } else {
+          return;
+        }
       }
     }
-    text->cursor_pos = text_get_line_strlen(text, row);
+    text->cursor_pos = text_get_line_strlen (text, row);
   } else {
     /* No clicked point, leave cursor where it is */
   }
diff --git a/lib/text.h b/lib/text.h
index e8bf8178..9eb71037 100644
--- a/lib/text.h
+++ b/lib/text.h
@@ -29,6 +29,7 @@ typedef enum {
 #include "textattr.h"
 #include "focus.h"
 #include "dia_xml.h" /* for AttributeNode */
+#include "diarenderer.h"
 
 /*!
  * \brief Multiline text representation
@@ -42,7 +43,7 @@ typedef enum {
  */
 struct _Text {
   /* don't change these values directly, use the text_set* functions */
-  
+
   /* Text data: */
   int numlines;
   TextLine **lines;
@@ -58,7 +59,7 @@ struct _Text {
   int cursor_pos;
   int cursor_row;
   Focus focus;
-  
+
   /* Computed values:  */
   real ascent; /* **average** ascent */
   real descent; /* **average** descent */
@@ -100,7 +101,7 @@ real text_get_max_width(Text *text);
 real text_get_ascent(Text *text);
 real text_get_descent(Text *text);
 
-/** Exposing this is a hack, but currently GTK still captures the key 
+/** Exposing this is a hack, but currently GTK still captures the key
  * events of insensitive clods^H^H^H^H^Hmenu items. LC 21/10 2007*/
 gboolean text_delete_key_handler(Focus *focus, ObjectChange **change);
 void data_add_text(AttributeNode attr, Text *text, DiaContext *ctx);
diff --git a/objects/AADL/aadlbus.c b/objects/AADL/aadlbus.c
index 2b6ead64..28d32f8c 100644
--- a/objects/AADL/aadlbus.c
+++ b/objects/AADL/aadlbus.c
@@ -26,9 +26,9 @@
  **               AADL BUS             **
  ***********************************************/
 
-static void aadlbus_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlbus_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point points[10];
@@ -74,17 +74,22 @@ static void aadlbus_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   points[9].y = y + h;
 
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-  renderer_ops->draw_polygon(renderer, points, 10, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             10,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 }
 
-static void aadlbus_draw(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlbus_draw (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  aadlbus_draw_borders(aadlbox, renderer);
-  aadlbox_draw(aadlbox, renderer);
+  aadlbus_draw_borders (aadlbox, renderer);
+  aadlbox_draw (aadlbox, renderer);
 }
 
 static void
diff --git a/objects/AADL/aadldata.c b/objects/AADL/aadldata.c
index b0744941..fe03f5ea 100644
--- a/objects/AADL/aadldata.c
+++ b/objects/AADL/aadldata.c
@@ -28,9 +28,8 @@
 
 
 static void
-aadldata_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+aadldata_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point points[2];
@@ -45,21 +44,25 @@ aadldata_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   points[0].x = x;     points[0].y = y;
   points[1].x = x + w; points[1].y = y + h;
 
-  renderer_ops->draw_rect(renderer, points, points + 1, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_rect (renderer,
+                          points,
+                          points + 1,
+                          &aadlbox->fill_color,
+                          &aadlbox->line_color);
 }
 
-static void 
-aadldata_draw(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadldata_draw (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  aadldata_draw_borders(aadlbox, renderer);
-  aadlbox_draw(aadlbox, renderer);
+  aadldata_draw_borders (aadlbox, renderer);
+  aadlbox_draw (aadlbox, renderer);
 }
 
 void
@@ -176,7 +179,7 @@ static DiaObject *aadldata_create(Point *startpoint, void *user_data, Handle **h
 
   obj->type = &aadldata_type;
   obj->ops  = &aadldata_ops;
-      
+
   return obj;
 }
 
@@ -185,10 +188,10 @@ static DiaObject *aadldata_load(ObjectNode obj_node, int version, DiaContext *ct
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadldata_create(&startpoint,&aadldata_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
-  
+
   return obj;
 }
 
diff --git a/objects/AADL/aadldevice.c b/objects/AADL/aadldevice.c
index a84cd9bc..b63e0c46 100644
--- a/objects/AADL/aadldevice.c
+++ b/objects/AADL/aadldevice.c
@@ -27,9 +27,9 @@
 
 #define AADL_DEVICE_DEPTH 0.5
 
-static void aadldevice_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadldevice_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point points[4];
@@ -44,14 +44,18 @@ static void aadldevice_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   points[0].x = x;     points[0].y = y;
   points[1].x = x + w; points[1].y = y + h;
 
-  renderer_ops->draw_rect(renderer, points, points + 1, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_rect (renderer,
+                          points,
+                          points + 1,
+                          &aadlbox->fill_color,
+                          &aadlbox->line_color);
 
   points[1].x = x - AADL_DEVICE_DEPTH;
   points[1].y = y - AADL_DEVICE_DEPTH;
@@ -61,7 +65,11 @@ static void aadldevice_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
 
   points[3].x = x + w, points[3].y = y;
 
-  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 
   points[0].x = points[3].x, points[0].y = points[3].y;
   points[1].x = points[0].x + AADL_DEVICE_DEPTH;
@@ -72,7 +80,11 @@ static void aadldevice_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
 
   points[3].x = points[0].x, points[3].y = points[0].y + h;
 
-  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 
   points[0].x = x + w;
   points[0].y = y + h;
@@ -86,7 +98,11 @@ static void aadldevice_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   points[3].x = x;
   points[3].y = y + h;
 
-  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 
   points[0].x = x;
   points[0].y = y;
@@ -94,8 +110,11 @@ static void aadldevice_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   points[1].x = x - AADL_DEVICE_DEPTH;
   points[1].y = y - AADL_DEVICE_DEPTH;
 
-  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->fill_color, &aadlbox->line_color);
-
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 }
 
 static Aadlbox_specific aadldevice_specific =
@@ -107,10 +126,11 @@ static Aadlbox_specific aadldevice_specific =
 
 
 
-static void aadldevice_draw(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadldevice_draw (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  aadldevice_draw_borders(aadlbox, renderer);
-  aadlbox_draw(aadlbox, renderer);
+  aadldevice_draw_borders (aadlbox, renderer);
+  aadlbox_draw (aadlbox, renderer);
 }
 
 ObjectTypeOps aadldevice_type_ops;
@@ -156,7 +176,7 @@ static DiaObject *aadldevice_create(Point *startpoint, void *user_data, Handle *
 
   obj->type = &aadldevice_type;
   obj->ops  = &aadldevice_ops;
-      
+
   return obj;
 }
 
@@ -166,7 +186,7 @@ aadldevice_load(ObjectNode obj_node, int version, DiaContext *ctx)
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadldevice_create(&startpoint,&aadldevice_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
   return obj;
diff --git a/objects/AADL/aadlmemory.c b/objects/AADL/aadlmemory.c
index c7cde607..6e5ad681 100644
--- a/objects/AADL/aadlmemory.c
+++ b/objects/AADL/aadlmemory.c
@@ -25,9 +25,9 @@
  **               AADL MEMORY             **
  ***********************************************/
 
-static void aadlmemory_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlmemory_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   BezPoint bez[5];
@@ -70,11 +70,15 @@ static void aadlmemory_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
 
   point_copy(&bez[4].p1, &bez[0].p1);
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-  renderer_ops->draw_beziergon(renderer, bez, 5, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_beziergon (renderer,
+                               bez,
+                               5,
+                               &aadlbox->fill_color,
+                               &aadlbox->line_color);
 
   bez[1].p1.x = x;
   bez[1].p1.y = y + 2*h*AADL_MEMORY_FACTOR;
@@ -83,7 +87,7 @@ static void aadlmemory_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   bez[1].p3.x = x + w;
   bez[1].p3.y = y + h*AADL_MEMORY_FACTOR;
 
-  renderer_ops->draw_bezier(renderer, bez, 3, &aadlbox->line_color);
+  dia_renderer_draw_bezier (renderer, bez, 3, &aadlbox->line_color);
 
 }
 
@@ -96,10 +100,11 @@ static Aadlbox_specific aadlmemory_specific =
 
 
 
-static void aadlmemory_draw(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlmemory_draw (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  aadlmemory_draw_borders(aadlbox, renderer);
-  aadlbox_draw(aadlbox, renderer);
+  aadlmemory_draw_borders (aadlbox, renderer);
+  aadlbox_draw (aadlbox, renderer);
 }
 
 ObjectTypeOps aadlmemory_type_ops;
@@ -145,7 +150,7 @@ static DiaObject *aadlmemory_create(Point *startpoint, void *user_data, Handle *
 
   obj->type = &aadlmemory_type;
   obj->ops  = &aadlmemory_ops;
-      
+
   return obj;
 }
 
@@ -155,7 +160,7 @@ aadlmemory_load(ObjectNode obj_node, int version, DiaContext *ctx)
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadlmemory_create(&startpoint,&aadlmemory_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
   return obj;
diff --git a/objects/AADL/aadlpackage.c b/objects/AADL/aadlpackage.c
index cbdda127..ff01116e 100644
--- a/objects/AADL/aadlpackage.c
+++ b/objects/AADL/aadlpackage.c
@@ -22,8 +22,8 @@
 #include "aadl.h"
 #include "pixmaps/aadlpackage.xpm"
 
-/* To have a really useful package element, we should make it a class of its 
-   own, not inherited from aadlbox, with 2 special handles -- that could be 
+/* To have a really useful package element, we should make it a class of its
+   own, not inherited from aadlbox, with 2 special handles -- that could be
    moved -- to draw the public/private separation */
 
 /***********************************************
@@ -31,9 +31,9 @@
  ***********************************************/
 
 
-static void aadlpackage_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlpackage_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point points[9];
@@ -48,9 +48,9 @@ static void aadlpackage_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   points[0].x = x;                 points[0].y = y;
   points[1].x = x + 0.03 * w ;     points[1].y = y;
@@ -62,7 +62,11 @@ static void aadlpackage_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   points[7].x = x + w;             points[7].y = y + h;
   points[8].x = x ;                points[8].y = y + h;
 
-  renderer_ops->draw_polygon(renderer, points, 9, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             9,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 }
 
 
@@ -124,7 +128,7 @@ static DiaObject *aadlpackage_create(Point *startpoint, void *user_data, Handle
 
   obj->type = &aadlpackage_type;
   obj->ops  = &aadlpackage_ops;
-      
+
   return obj;
 }
 
@@ -134,10 +138,10 @@ aadlpackage_load(ObjectNode obj_node, int version, DiaContext *ctx)
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadlpackage_create(&startpoint,&aadlpackage_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
-  
+
   return obj;
 }
 
diff --git a/objects/AADL/aadlport.c b/objects/AADL/aadlport.c
index 6510a8ef..46af35d2 100644
--- a/objects/AADL/aadlport.c
+++ b/objects/AADL/aadlport.c
@@ -19,7 +19,7 @@
 */
 
 
-/* AADL plugin for DIA 
+/* AADL plugin for DIA
  * Author: Pierre Duquesne
  *
  * This program is free software; you can redistribute it and/or modify
@@ -73,168 +73,165 @@ rotate_around_origin (Point *p, real angle)   /* FIXME: no namespace */
 
 
 #define draw_in_data_port()                                       \
-    p[0].x =  AADL_PORT_WIDTH_A;                                 \
-    p[0].y =  -AADL_PORT_HEIGHT/2;                               \
-                                                                 \
-    p[1].x =  -AADL_PORT_WIDTH_B;                                \
-    p[1].y =  0;                                                 \
-                                                                 \
-    p[2].x =  AADL_PORT_WIDTH_A;                                 \
-    p[2].y =  AADL_PORT_HEIGHT/2;                                \
-                                                                 \
-    rotate_around_origin(p, port->angle);                        \
-    rotate_around_origin(p+1, port->angle);                      \
-    rotate_around_origin(p+2, port->angle);                      \
-                                                                 \
-    point_add(p, &port->handle->pos);                            \
-    point_add(p+1, &port->handle->pos);                                  \
-    point_add(p+2, &port->handle->pos);                                  \
-                                                                 \
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);          \
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);        \
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);  \
-                                                                 \
-    renderer_ops->draw_polygon(renderer, p,  3, &color_black, &color_black);
-
-#define draw_in_event_port()                                         \
-    p[0].x =  AADL_PORT_WIDTH_A;                                    \
-    p[0].y =  -AADL_PORT_HEIGHT/2 - AADL_EVENT_DELTA_HEIGHT;        \
-                                                                    \
-    p[1].x =  - AADL_PORT_WIDTH_B - AADL_EVENT_DELTA_WIDTH;         \
-    p[1].y =  0;                                                    \
-                                                                    \
-    p[2].x =  AADL_PORT_WIDTH_A;                                    \
-    p[2].y =  AADL_PORT_HEIGHT/2 + AADL_EVENT_DELTA_HEIGHT;         \
-                                                                    \
-    rotate_around_origin(p, port->angle);                           \
-    rotate_around_origin(p+1, port->angle);                         \
-    rotate_around_origin(p+2, port->angle);                         \
-                                                                    \
-    point_add(p, &port->handle->pos);                               \
-    point_add(p+1, &port->handle->pos);                                     \
-    point_add(p+2, &port->handle->pos);                                     \
-                                                                    \
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);             \
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);           \
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);     \
-                                                                     \
-    renderer_ops->draw_polyline(renderer, p,  3, &color_black);
-
-#define draw_out_data_port()                                        \
-    p[0].x =  -AADL_PORT_WIDTH_A;                                   \
-    p[0].y =  -AADL_PORT_HEIGHT/2;                                 \
-                                                                   \
-    p[1].x =  AADL_PORT_WIDTH_B;                                   \
-    p[1].y =  0;                                                   \
-                                                                   \
-    p[2].x =  -AADL_PORT_WIDTH_A;                                  \
-    p[2].y =  AADL_PORT_HEIGHT/2;                                  \
-                                                                   \
-    rotate_around_origin(p, port->angle);                          \
-    rotate_around_origin(p+1, port->angle);                        \
-    rotate_around_origin(p+2, port->angle);                        \
-                                                                   \
-    point_add(p, &port->handle->pos);                              \
-    point_add(p+1, &port->handle->pos);                                    \
-    point_add(p+2, &port->handle->pos);                                    \
-                                                                   \
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);            \
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);          \
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);    \
-                                                                   \
-    renderer_ops->draw_polygon(renderer, p,  3, &color_black, &color_black);
-
-#define draw_out_event_port()                                       \
-    p[0].x =  - AADL_PORT_WIDTH_A;                                  \
-    p[0].y =  - AADL_PORT_HEIGHT/2 - AADL_EVENT_DELTA_HEIGHT;      \
-                                                                   \
-    p[1].x =  AADL_PORT_WIDTH_B + AADL_EVENT_DELTA_WIDTH;          \
-    p[1].y =  0;                                                   \
-                                                                   \
-    p[2].x =  - AADL_PORT_WIDTH_A;                                 \
-    p[2].y =  AADL_PORT_HEIGHT/2 + AADL_EVENT_DELTA_HEIGHT;        \
-                                                                   \
-    rotate_around_origin(p, port->angle);                          \
-    rotate_around_origin(p+1, port->angle);                        \
-    rotate_around_origin(p+2, port->angle);                        \
-                                                                   \
-    point_add(p, &port->handle->pos);                              \
-    point_add(p+1, &port->handle->pos);                                    \
-    point_add(p+2, &port->handle->pos);                                    \
-                                                                   \
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);            \
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);          \
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);    \
-                                                                   \
-    renderer_ops->draw_polyline(renderer, p,  3, &color_black);
-
-#define draw_in_out_data_port()                                     \
-    p[0].x =  0;                                                   \
-    p[0].y =  -AADL_PORT_HEIGHT/2;                                 \
-                                                                   \
-    p[1].x =  AADL_PORT_WIDTH_B;                                   \
-    p[1].y =  0;                                                   \
-                                                                   \
-    p[2].x =  0;                                                   \
-    p[2].y =  AADL_PORT_HEIGHT/2;                                  \
-                                                                   \
-    p[3].x =  -AADL_PORT_WIDTH_B;                                  \
-    p[3].y =  0;                                                   \
-                                                                   \
-    rotate_around_origin(p, port->angle);                          \
-    rotate_around_origin(p+1, port->angle);                        \
-    rotate_around_origin(p+2, port->angle);                        \
-    rotate_around_origin(p+3, port->angle);                        \
-                                                                   \
-    point_add(p, &port->handle->pos);                              \
-    point_add(p+1, &port->handle->pos);                                    \
-    point_add(p+2, &port->handle->pos);                                    \
-    point_add(p+3, &port->handle->pos);                                    \
-                                                                   \
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);            \
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);          \
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);    \
-                                                                   \
-    renderer_ops->draw_polygon(renderer, p,  4, &color_black, &color_black);
-
-
-    
-#define draw_in_out_event_port()                                   \
-    p[0].x =  0;                                                  \
-    p[0].y =  -AADL_PORT_HEIGHT/2 - AADL_EVENT_DELTA_HEIGHT;      \
-                                                                  \
-    p[1].x =  AADL_PORT_WIDTH_B + AADL_EVENT_DELTA_WIDTH;         \
-    p[1].y =  0;                                                  \
-                                                                  \
-    p[2].x =  0;                                                  \
-    p[2].y =  AADL_PORT_HEIGHT/2 + AADL_EVENT_DELTA_HEIGHT;       \
-                                                                  \
-    p[3].x =  -AADL_PORT_WIDTH_B - AADL_EVENT_DELTA_WIDTH;        \
-    p[3].y =  0;                                                  \
-                                                                  \
-    rotate_around_origin(p, port->angle);                         \
-    rotate_around_origin(p+1, port->angle);                       \
-    rotate_around_origin(p+2, port->angle);                       \
-    rotate_around_origin(p+3, port->angle);                       \
-                                                                  \
-    point_add(p, &port->handle->pos);                             \
-    point_add(p+1, &port->handle->pos);                                   \
-    point_add(p+2, &port->handle->pos);                                   \
-    point_add(p+3, &port->handle->pos);                                   \
-                                                                  \
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);           \
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);         \
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);   \
-                                                                  \
-    renderer_ops->draw_polygon(renderer, p,  4, NULL, &color_black); 
+    p[0].x =  AADL_PORT_WIDTH_A;                                  \
+    p[0].y =  -AADL_PORT_HEIGHT/2;                                \
+                                                                  \
+    p[1].x =  -AADL_PORT_WIDTH_B;                                 \
+    p[1].y =  0;                                                  \
+                                                                  \
+    p[2].x =  AADL_PORT_WIDTH_A;                                  \
+    p[2].y =  AADL_PORT_HEIGHT/2;                                 \
+                                                                  \
+    rotate_around_origin(p, port->angle);                         \
+    rotate_around_origin(p+1, port->angle);                       \
+    rotate_around_origin(p+2, port->angle);                       \
+                                                                  \
+    point_add(p, &port->handle->pos);                             \
+    point_add(p+1, &port->handle->pos);                           \
+    point_add(p+2, &port->handle->pos);                           \
+                                                                  \
+    dia_renderer_set_linewidth(renderer, AADL_PORT_LINEWIDTH);    \
+    dia_renderer_set_linejoin(renderer, LINEJOIN_MITER);          \
+    dia_renderer_set_linestyle(renderer, LINESTYLE_SOLID, 0.0);   \
+                                                                  \
+    dia_renderer_draw_polygon(renderer, p,  3, &color_black, &color_black);
+
+#define draw_in_event_port()                                      \
+    p[0].x =  AADL_PORT_WIDTH_A;                                  \
+    p[0].y =  -AADL_PORT_HEIGHT/2 - AADL_EVENT_DELTA_HEIGHT;      \
+                                                                  \
+    p[1].x =  - AADL_PORT_WIDTH_B - AADL_EVENT_DELTA_WIDTH;       \
+    p[1].y =  0;                                                  \
+                                                                  \
+    p[2].x =  AADL_PORT_WIDTH_A;                                  \
+    p[2].y =  AADL_PORT_HEIGHT/2 + AADL_EVENT_DELTA_HEIGHT;       \
+                                                                  \
+    rotate_around_origin(p, port->angle);                         \
+    rotate_around_origin(p+1, port->angle);                       \
+    rotate_around_origin(p+2, port->angle);                       \
+                                                                  \
+    point_add(p, &port->handle->pos);                             \
+    point_add(p+1, &port->handle->pos);                           \
+    point_add(p+2, &port->handle->pos);                           \
+                                                                  \
+    dia_renderer_set_linewidth(renderer, AADL_PORT_LINEWIDTH);    \
+    dia_renderer_set_linejoin(renderer, LINEJOIN_MITER);          \
+    dia_renderer_set_linestyle(renderer, LINESTYLE_SOLID, 0.0);   \
+                                                                  \
+    dia_renderer_draw_polyline(renderer, p,  3, &color_black);
+
+#define draw_out_data_port()                                      \
+    p[0].x =  -AADL_PORT_WIDTH_A;                                 \
+    p[0].y =  -AADL_PORT_HEIGHT/2;                                \
+                                                                  \
+    p[1].x =  AADL_PORT_WIDTH_B;                                  \
+    p[1].y =  0;                                                  \
+                                                                  \
+    p[2].x =  -AADL_PORT_WIDTH_A;                                 \
+    p[2].y =  AADL_PORT_HEIGHT/2;                                 \
+                                                                  \
+    rotate_around_origin(p, port->angle);                         \
+    rotate_around_origin(p+1, port->angle);                       \
+    rotate_around_origin(p+2, port->angle);                       \
+                                                                  \
+    point_add(p, &port->handle->pos);                             \
+    point_add(p+1, &port->handle->pos);                           \
+    point_add(p+2, &port->handle->pos);                           \
+                                                                  \
+    dia_renderer_set_linewidth(renderer, AADL_PORT_LINEWIDTH);    \
+    dia_renderer_set_linejoin(renderer, LINEJOIN_MITER);          \
+    dia_renderer_set_linestyle(renderer, LINESTYLE_SOLID, 0.0);   \
+                                                                  \
+    dia_renderer_draw_polygon(renderer, p,  3, &color_black, &color_black);
+
+#define draw_out_event_port()                                     \
+    p[0].x =  - AADL_PORT_WIDTH_A;                                \
+    p[0].y =  - AADL_PORT_HEIGHT/2 - AADL_EVENT_DELTA_HEIGHT;     \
+                                                                  \
+    p[1].x =  AADL_PORT_WIDTH_B + AADL_EVENT_DELTA_WIDTH;         \
+    p[1].y =  0;                                                  \
+                                                                  \
+    p[2].x =  - AADL_PORT_WIDTH_A;                                \
+    p[2].y =  AADL_PORT_HEIGHT/2 + AADL_EVENT_DELTA_HEIGHT;       \
+                                                                  \
+    rotate_around_origin(p, port->angle);                         \
+    rotate_around_origin(p+1, port->angle);                       \
+    rotate_around_origin(p+2, port->angle);                       \
+                                                                  \
+    point_add(p, &port->handle->pos);                             \
+    point_add(p+1, &port->handle->pos);                           \
+    point_add(p+2, &port->handle->pos);                           \
+                                                                  \
+    dia_renderer_set_linewidth(renderer, AADL_PORT_LINEWIDTH);    \
+    dia_renderer_set_linejoin(renderer, LINEJOIN_MITER);          \
+    dia_renderer_set_linestyle(renderer, LINESTYLE_SOLID, 0.0);   \
+                                                                  \
+    dia_renderer_draw_polyline(renderer, p,  3, &color_black);
+
+#define draw_in_out_data_port()                                   \
+    p[0].x =  0;                                                  \
+    p[0].y =  -AADL_PORT_HEIGHT/2;                                \
+                                                                  \
+    p[1].x =  AADL_PORT_WIDTH_B;                                  \
+    p[1].y =  0;                                                  \
+                                                                  \
+    p[2].x =  0;                                                  \
+    p[2].y =  AADL_PORT_HEIGHT/2;                                 \
+                                                                  \
+    p[3].x =  -AADL_PORT_WIDTH_B;                                 \
+    p[3].y =  0;                                                  \
+                                                                  \
+    rotate_around_origin(p, port->angle);                         \
+    rotate_around_origin(p+1, port->angle);                       \
+    rotate_around_origin(p+2, port->angle);                       \
+    rotate_around_origin(p+3, port->angle);                       \
+                                                                  \
+    point_add(p, &port->handle->pos);                             \
+    point_add(p+1, &port->handle->pos);                           \
+    point_add(p+2, &port->handle->pos);                           \
+    point_add(p+3, &port->handle->pos);                           \
+                                                                  \
+    dia_renderer_set_linewidth(renderer, AADL_PORT_LINEWIDTH);    \
+    dia_renderer_set_linejoin(renderer, LINEJOIN_MITER);          \
+    dia_renderer_set_linestyle(renderer, LINESTYLE_SOLID, 0.0);   \
+                                                                  \
+    dia_renderer_draw_polygon(renderer, p,  4, &color_black, &color_black);
+
+#define draw_in_out_event_port()                                  \
+    p[0].x =  0;                                                  \
+    p[0].y =  -AADL_PORT_HEIGHT/2 - AADL_EVENT_DELTA_HEIGHT;      \
+                                                                  \
+    p[1].x =  AADL_PORT_WIDTH_B + AADL_EVENT_DELTA_WIDTH;         \
+    p[1].y =  0;                                                  \
+                                                                  \
+    p[2].x =  0;                                                  \
+    p[2].y =  AADL_PORT_HEIGHT/2 + AADL_EVENT_DELTA_HEIGHT;       \
+                                                                  \
+    p[3].x =  -AADL_PORT_WIDTH_B - AADL_EVENT_DELTA_WIDTH;        \
+    p[3].y =  0;                                                  \
+                                                                  \
+    rotate_around_origin(p, port->angle);                         \
+    rotate_around_origin(p+1, port->angle);                       \
+    rotate_around_origin(p+2, port->angle);                       \
+    rotate_around_origin(p+3, port->angle);                       \
+                                                                  \
+    point_add(p, &port->handle->pos);                             \
+    point_add(p+1, &port->handle->pos);                           \
+    point_add(p+2, &port->handle->pos);                           \
+    point_add(p+3, &port->handle->pos);                           \
+                                                                  \
+    dia_renderer_set_linewidth(renderer, AADL_PORT_LINEWIDTH);    \
+    dia_renderer_set_linejoin(renderer, LINEJOIN_MITER);          \
+    dia_renderer_set_linestyle(renderer, LINESTYLE_SOLID, 0.0);   \
+                                                                  \
+    dia_renderer_draw_polygon(renderer, p,  4, NULL, &color_black);
 
 
 /* FIXME: should i make methods from this function ? */
 
 void
-aadlbox_draw_port(Aadlport *port, DiaRenderer *renderer)
+aadlbox_draw_port (Aadlport *port, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point p[5];
 
   assert(port!=NULL);
@@ -270,11 +267,11 @@ aadlbox_draw_port(Aadlport *port, DiaRenderer *renderer)
     point_add(p+3, &port->handle->pos);
     point_add(p+4, &port->handle->pos);
 
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linewidth (renderer, AADL_PORT_LINEWIDTH);
+    dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-    renderer_ops->draw_polygon(renderer, p,  5, &color_white, &color_black);
+    dia_renderer_draw_polygon (renderer, p,  5, &color_white, &color_black);
 
     break;
 
@@ -306,11 +303,11 @@ aadlbox_draw_port(Aadlport *port, DiaRenderer *renderer)
     point_add(p+3, &port->handle->pos);
     point_add(p+4, &port->handle->pos);
 
-    renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linewidth (renderer, AADL_PORT_LINEWIDTH);
+    dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-    renderer_ops->draw_polygon(renderer, p,  5, &color_white, &color_black);
+    dia_renderer_draw_polygon (renderer, p,  5, &color_white, &color_black);
 
     break;
 
@@ -347,40 +344,41 @@ aadlbox_draw_port(Aadlport *port, DiaRenderer *renderer)
   case  IN_OUT_EVENT_PORT:
     draw_in_out_event_port();
     break;
-    
+
   case  IN_OUT_EVENT_DATA_PORT:
     draw_in_out_data_port();
     draw_in_out_event_port();
     break;
 
 #define AADL_PORT_GROUP_SIZE 0.1
-    
+
   case PORT_GROUP:    /* quick n dirty - should use macros*/
     {
       BezPoint b[5];
       int i;
-      
+
       p[0].x = 0;  p[0].y = 0;
-    
+
       rotate_around_origin(p, port->angle);
       point_add(p, &port->handle->pos);
 
-      renderer_ops->set_linewidth(renderer, AADL_PORT_LINEWIDTH);
-      renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-      renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-      
-      renderer_ops->draw_ellipse(renderer, p,
-                                6 * AADL_PORT_GROUP_SIZE,
-                                6 * AADL_PORT_GROUP_SIZE,
-                                &color_black, &color_black);
+      dia_renderer_set_linewidth (renderer, AADL_PORT_LINEWIDTH);
+      dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+      dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+
+      dia_renderer_draw_ellipse (renderer,
+                                 p,
+                                 6 * AADL_PORT_GROUP_SIZE,
+                                 6 * AADL_PORT_GROUP_SIZE,
+                                 &color_black, &color_black);
+
 
-      
       b[0].type = BEZ_MOVE_TO;
       b[1].type = BEZ_CURVE_TO;
       b[2].type = BEZ_LINE_TO;
       b[3].type = BEZ_CURVE_TO;
       b[4].type = BEZ_LINE_TO;
-      
+
       b[0].p1.x = -2         * AADL_PORT_GROUP_SIZE;
       b[0].p1.y = -6         * AADL_PORT_GROUP_SIZE;
 
@@ -403,25 +401,24 @@ aadlbox_draw_port(Aadlport *port, DiaRenderer *renderer)
 
       b[4].p1.x = -2         * AADL_PORT_GROUP_SIZE;
       b[4].p1.y = -6         * AADL_PORT_GROUP_SIZE;
-    
+
       for (i=0; i<5; i++) {
-       rotate_around_origin(&b[i].p1, port->angle);
-       point_add(&b[i].p1, &port->handle->pos);
-       
-       if (b[i].type == BEZ_CURVE_TO) {
-         rotate_around_origin(&b[i].p2, port->angle);
-         rotate_around_origin(&b[i].p3, port->angle);
-       
-         point_add(&b[i].p2, &port->handle->pos);
-         point_add(&b[i].p3, &port->handle->pos);
-       }
+        rotate_around_origin (&b[i].p1, port->angle);
+        point_add (&b[i].p1, &port->handle->pos);
+
+        if (b[i].type == BEZ_CURVE_TO) {
+          rotate_around_origin (&b[i].p2, port->angle);
+          rotate_around_origin (&b[i].p3, port->angle);
+
+          point_add (&b[i].p2, &port->handle->pos);
+          point_add (&b[i].p3, &port->handle->pos);
+        }
       }
-      
-      renderer_ops->draw_beziergon(renderer, b, 5, &color_black, &color_black);
-      
+
+      dia_renderer_draw_beziergon (renderer, b, 5, &color_black, &color_black);
     }
     break;
-    
+
   default:
     break;
 
@@ -496,16 +493,16 @@ void aadlbox_update_port(Aadlbox *aadlbox, Aadlport *port)
     port->out.pos.x=  AADL_PORT_WIDTH_B + AADL_EVENT_DELTA_HEIGHT;
     port->out.pos.y=0;
     break;
-    
+
   case PORT_GROUP:  /* quick n dirty */
-    port->in.pos.x = -9*AADL_PORT_GROUP_SIZE; port->in.pos.y=0; 
+    port->in.pos.x = -9*AADL_PORT_GROUP_SIZE; port->in.pos.y=0;
     port->out.pos.x = 3*AADL_PORT_GROUP_SIZE; port->out.pos.y=0;
     break;
 
   default:
     break;
 
-    
+
   }
 
   rotate_around_origin(&port->in.pos, port->angle);
diff --git a/objects/AADL/aadlprocess.c b/objects/AADL/aadlprocess.c
index 9cced779..069a29d5 100644
--- a/objects/AADL/aadlprocess.c
+++ b/objects/AADL/aadlprocess.c
@@ -27,10 +27,11 @@
  ***********************************************/
 
 
-void aadlbox_draw_inclined_box(Aadlbox *aadlbox, DiaRenderer *renderer,
-                                     LineStyle linestyle)
+void
+aadlbox_draw_inclined_box (Aadlbox     *aadlbox,
+                           DiaRenderer *renderer,
+                           LineStyle    linestyle)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point points[4];
@@ -53,11 +54,15 @@ void aadlbox_draw_inclined_box(Aadlbox *aadlbox, DiaRenderer *renderer,
   points[2].x = x + w - w * AADLBOX_INCLINE_FACTOR;
   points[3].y = points[2].y = y + h;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, linestyle, AADLBOX_DASH_LENGTH);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, linestyle, AADLBOX_DASH_LENGTH);
 
-  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 }
 
 
@@ -79,11 +84,11 @@ aadlbox_inclined_project_point_on_nearest_border(Aadlbox *aadlbox,Point *p,
         + /000000000000/   +                |0000000000|      +
         +/000000000000/    +                |0000000000|      +
         A------------ ++++++                 +----------++++++++
-  */       
+  */
 
   Rectangle rectangle;
   real w, h, delta_y, delta_x;
-  
+
   w = aadlbox->element.width;
   h = aadlbox->element.height;
 
@@ -94,14 +99,14 @@ aadlbox_inclined_project_point_on_nearest_border(Aadlbox *aadlbox,Point *p,
 
   delta_y = h - (p->y - aadlbox->element.corner.y);
   delta_x = delta_y * (w * AADLBOX_INCLINE_FACTOR) / h;
-  
+
   p->x -= delta_x;
-  
+
   aadlbox_project_point_on_rectangle(&rectangle, p, angle);
-  
+
   delta_y = h - (p->y - aadlbox->element.corner.y);
   delta_x = delta_y * (w * AADLBOX_INCLINE_FACTOR) / h;
-      
+
   p->x += delta_x;
 }
 
@@ -163,7 +168,7 @@ static DiaObject *aadlprocess_create(Point *startpoint, void *user_data, Handle
 
   obj->type = &aadlprocess_type;
   obj->ops  = &aadlprocess_ops;
-      
+
   return obj;
 }
 
@@ -173,7 +178,7 @@ aadlprocess_load(ObjectNode obj_node, int version,DiaContext *ctx)
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadlprocess_create(&startpoint,&aadlprocess_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
   return obj;
diff --git a/objects/AADL/aadlprocessor.c b/objects/AADL/aadlprocessor.c
index 231e79c6..4eef01a6 100644
--- a/objects/AADL/aadlprocessor.c
+++ b/objects/AADL/aadlprocessor.c
@@ -27,9 +27,9 @@
 
 #define AADL_PROCESSOR_DEPTH 0.5
 
-static void aadlprocessor_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlprocessor_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point points[4];
@@ -44,14 +44,18 @@ static void aadlprocessor_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   points[0].x = x;     points[0].y = y;
   points[1].x = x + w; points[1].y = y + h;
 
-  renderer_ops->draw_rect(renderer, points, points + 1, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_rect (renderer,
+                          points,
+                          points + 1,
+                          &aadlbox->fill_color,
+                          &aadlbox->line_color);
 
   points[1].x = x + AADL_PROCESSOR_DEPTH;
   points[1].y = y - AADL_PROCESSOR_DEPTH;
@@ -61,7 +65,11 @@ static void aadlprocessor_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
 
   points[3].x = x + w, points[3].y = y;
 
-  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 
   points[0].x = points[3].x, points[0].y = points[3].y;
   points[1].x = points[0].x + AADL_PROCESSOR_DEPTH;
@@ -72,7 +80,11 @@ static void aadlprocessor_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
 
   points[3].x = points[0].x, points[3].y = points[0].y + h;
 
-  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 }
 
 static Aadlbox_specific aadlprocessor_specific =
@@ -83,10 +95,11 @@ static Aadlbox_specific aadlprocessor_specific =
 };
 
 
-static void aadlprocessor_draw(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlprocessor_draw (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  aadlprocessor_draw_borders(aadlbox, renderer);
-  aadlbox_draw(aadlbox, renderer);
+  aadlprocessor_draw_borders (aadlbox, renderer);
+  aadlbox_draw (aadlbox, renderer);
 }
 
 ObjectTypeOps aadlprocessor_type_ops;
@@ -132,7 +145,7 @@ static DiaObject *aadlprocessor_create(Point *startpoint, void *user_data, Handl
 
   obj->type = &aadlprocessor_type;
   obj->ops  = &aadlprocessor_ops;
-      
+
   return obj;
 }
 
@@ -142,7 +155,7 @@ aadlprocessor_load(ObjectNode obj_node, int version, DiaContext *ctx)
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadlprocessor_create(&startpoint,&aadlprocessor_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
   return obj;
diff --git a/objects/AADL/aadlsubprogram.c b/objects/AADL/aadlsubprogram.c
index d2615fab..2a5a6f51 100644
--- a/objects/AADL/aadlsubprogram.c
+++ b/objects/AADL/aadlsubprogram.c
@@ -26,9 +26,9 @@
  **               AADL SUBPROGRAM             **
  ***********************************************/
 
-static void aadlsubprogram_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlsubprogram_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point center;
@@ -46,12 +46,16 @@ static void aadlsubprogram_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
   center.x = x + 0.5*w;
   center.y = y + 0.5*h;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-  renderer_ops->draw_ellipse(renderer, &center, w, h,
-                            &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_ellipse (renderer,
+                             &center,
+                             w,
+                             h,
+                             &aadlbox->fill_color,
+                             &aadlbox->line_color);
 }
 
 #define heavyside(n) (n>0?1:0)
@@ -97,10 +101,11 @@ static Aadlbox_specific aadlsubprogram_specific =
 };
 
 
-static void aadlsubprogram_draw(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlsubprogram_draw (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  aadlsubprogram_draw_borders(aadlbox, renderer);
-  aadlbox_draw(aadlbox, renderer);
+  aadlsubprogram_draw_borders (aadlbox, renderer);
+  aadlbox_draw (aadlbox, renderer);
 }
 
 ObjectTypeOps aadlsubprogram_type_ops;
@@ -146,7 +151,7 @@ static DiaObject *aadlsubprogram_create(Point *startpoint, void *user_data, Hand
 
   obj->type = &aadlsubprogram_type;
   obj->ops  = &aadlsubprogram_ops;
-      
+
   return obj;
 }
 
@@ -156,7 +161,7 @@ aadlsubprogram_load(ObjectNode obj_node, int version, DiaContext *ctx)
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadlsubprogram_create(&startpoint,&aadlsubprogram_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
   return obj;
diff --git a/objects/AADL/aadlsystem.c b/objects/AADL/aadlsystem.c
index 2b34a921..c3838bf5 100644
--- a/objects/AADL/aadlsystem.c
+++ b/objects/AADL/aadlsystem.c
@@ -26,10 +26,11 @@
  **                 AADL SYSTEM               **
  ***********************************************/
 
-void aadlbox_draw_rounded_box (Aadlbox *aadlbox, DiaRenderer *renderer,
-                              LineStyle linestyle)
+void
+aadlbox_draw_rounded_box (Aadlbox     *aadlbox,
+                          DiaRenderer *renderer,
+                          LineStyle    linestyle)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   BezPoint bez[9];
@@ -85,18 +86,23 @@ void aadlbox_draw_rounded_box (Aadlbox *aadlbox, DiaRenderer *renderer,
   bez[8].p1.y = bez[8].p2.y = bez[8].p3.y = y;
   bez[8].p3.x = x + w * AADL_ROUNDEDBOX_CORNER_SIZE_FACTOR;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, linestyle, AADLBOX_DASH_LENGTH);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, AADLBOX_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, linestyle, AADLBOX_DASH_LENGTH);
 
-  renderer_ops->draw_beziergon(renderer, bez, 9, &aadlbox->fill_color, &aadlbox->line_color);
+  dia_renderer_draw_beziergon (renderer,
+                               bez,
+                               9,
+                               &aadlbox->fill_color,
+                               &aadlbox->line_color);
 }
 
 
 
-static void aadlsystem_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
+static void
+aadlsystem_draw_borders (Aadlbox *aadlbox, DiaRenderer *renderer)
 {
-  aadlbox_draw_rounded_box(aadlbox, renderer, LINESTYLE_SOLID);
+  aadlbox_draw_rounded_box (aadlbox, renderer, LINESTYLE_SOLID);
 }
 
 static Aadlbox_specific aadlsystem_specific =
@@ -156,7 +162,7 @@ static DiaObject *aadlsystem_create(Point *startpoint, void *user_data, Handle *
 
   obj->type = &aadlsystem_type;
   obj->ops  = &aadlsystem_ops;
-      
+
   return obj;
 }
 
@@ -166,7 +172,7 @@ aadlsystem_load(ObjectNode obj_node, int version, DiaContext *ctx)
   DiaObject *obj;
   Point startpoint = {0.0,0.0};
   Handle *handle1,*handle2;
-  
+
   obj = aadlsystem_create(&startpoint,&aadlsystem_specific, &handle1,&handle2);
   aadlbox_load(obj_node, version, ctx, (Aadlbox *) obj);
   return obj;
diff --git a/objects/Database/compound.c b/objects/Database/compound.c
index 19571bf6..46d6fd43 100644
--- a/objects/Database/compound.c
+++ b/objects/Database/compound.c
@@ -526,23 +526,20 @@ compound_destroy (Compound * comp)
 static void
 compound_draw (Compound * comp, DiaRenderer * renderer)
 {
-  DiaRendererClass * renderer_ops;
   gint num_handles;
   Point * mount_point_pos;
   gint i;
 
-  renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   num_handles = comp->object.num_handles;
   mount_point_pos = &comp->mount_point.pos;
 
-  renderer_ops->set_linewidth (renderer, comp->line_width);
+  dia_renderer_set_linewidth (renderer, comp->line_width);
 
-  for (i = 1; i < num_handles; i++)
-    {
-      renderer_ops->draw_line (renderer,
-                               mount_point_pos,
-                               &comp->handles[i].pos,
-                               &comp->line_color);
+  for (i = 1; i < num_handles; i++) {
+    dia_renderer_draw_line (renderer,
+                            mount_point_pos,
+                            &comp->handles[i].pos,
+                            &comp->line_color);
 #if DEBUG_DRAW_BOUNDING_BOX
  {
    Point ul, br;
@@ -551,10 +548,10 @@ compound_draw (Compound * comp, DiaRenderer * renderer)
    br.x = comp->object.bounding_box.right;
    br.y = comp->object.bounding_box.bottom;
 
-   renderer_ops->draw_rect (renderer, &ul, &br, &comp->line_color);
+   dia_renderer_draw_rect (renderer, &ul, &br, &comp->line_color);
  }
 #endif
-    }
+  }
 
 #if DEBUG_DRAW_MP_DIRECTION
  {
@@ -570,7 +567,7 @@ compound_draw (Compound * comp, DiaRenderer * renderer)
    if (dirs & DIR_EAST)
      p.x += 1.0;
 
-   renderer_ops->draw_line (renderer, &comp->mount_point.pos, &p, &red);
+   dia_renderer_draw_line (renderer, &comp->mount_point.pos, &p, &red);
  }
 #endif
 
diff --git a/objects/Database/reference.c b/objects/Database/reference.c
index 8bb2dc6f..0913442e 100644
--- a/objects/Database/reference.c
+++ b/objects/Database/reference.c
@@ -214,7 +214,6 @@ reference_load (ObjectNode obj_node, int version,DiaContext *ctx)
 static void
 reference_draw (TableReference *ref, DiaRenderer *renderer)
 {
-  DiaRendererClass * renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn * orth = &ref->orth;
   Point * points;
   gint num_points;
@@ -222,33 +221,36 @@ reference_draw (TableReference *ref, DiaRenderer *renderer)
   points = &orth->points[0];
   num_points = orth->numpoints;
 
-  renderer_ops->set_linewidth (renderer, ref->line_width);
-  renderer_ops->set_linestyle (renderer, ref->line_style, ref->dashlength);
-  renderer_ops->set_linejoin (renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps (renderer, LINECAPS_BUTT);
-
-  renderer_ops->draw_rounded_polyline_with_arrows
-    (renderer, points, num_points, ref->line_width,
-     &ref->line_color, NULL, &ref->end_arrow, ref->corner_radius);
-
-  renderer_ops->set_font (renderer, ref->normal_font, ref->normal_font_height);
-
-  if (IS_NOT_EMPTY(ref->start_point_desc))
-    {
-      renderer_ops->draw_string (renderer,
-                                 ref->start_point_desc,
-                                 &ref->sp_desc_pos,
-                                 ref->sp_desc_text_align,
-                                 &ref->text_color);
-    }
-  if (IS_NOT_EMPTY(ref->end_point_desc))
-    {
-      renderer_ops->draw_string (renderer,
-                                 ref->end_point_desc,
-                                 &ref->ep_desc_pos,
-                                 ref->ep_desc_text_align,
-                                 &ref->text_color);
-    }
+  dia_renderer_set_linewidth (renderer, ref->line_width);
+  dia_renderer_set_linestyle (renderer, ref->line_style, ref->dashlength);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+
+  dia_renderer_draw_rounded_polyline_with_arrows (renderer,
+                                                  points,
+                                                  num_points,
+                                                  ref->line_width,
+                                                  &ref->line_color,
+                                                  NULL,
+                                                  &ref->end_arrow,
+                                                  ref->corner_radius);
+
+  dia_renderer_set_font (renderer, ref->normal_font, ref->normal_font_height);
+
+  if (IS_NOT_EMPTY (ref->start_point_desc)) {
+    dia_renderer_draw_string (renderer,
+                              ref->start_point_desc,
+                              &ref->sp_desc_pos,
+                              ref->sp_desc_text_align,
+                              &ref->text_color);
+  }
+  if (IS_NOT_EMPTY (ref->end_point_desc)) {
+    dia_renderer_draw_string (renderer,
+                              ref->end_point_desc,
+                              &ref->ep_desc_pos,
+                              ref->ep_desc_text_align,
+                              &ref->text_color);
+  }
 }
 
 static real
diff --git a/objects/Database/table.c b/objects/Database/table.c
index 8c0197b9..3daf8c2c 100644
--- a/objects/Database/table.c
+++ b/objects/Database/table.c
@@ -521,13 +521,12 @@ table_destroy (Table * table)
 static void
 table_draw (Table *table, DiaRenderer *renderer)
 {
-  DiaRendererClass * renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   real y = 0.0;
   Element * elem;
 
-  renderer_ops->set_linewidth (renderer, table->border_width);
-  renderer_ops->set_fillstyle (renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, table->border_width);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   elem = &table->element;
 
@@ -536,9 +535,8 @@ table_draw (Table *table, DiaRenderer *renderer)
 }
 
 static real
-table_draw_namebox (Table * table, DiaRenderer * renderer, Element * elem)
+table_draw_namebox (Table *table, DiaRenderer *renderer, Element *elem)
 {
-  DiaRendererClass * renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point startP;
   Point endP;
 
@@ -550,28 +548,32 @@ table_draw_namebox (Table * table, DiaRenderer * renderer, Element * elem)
   endP.y = startP.y + table->namebox_height;
 
   /* first draw the outer box and fill for the class name object */
-  renderer_ops->draw_rect (renderer, &startP, &endP, &table->fill_color, &table->line_color);
-
-  if (IS_NOT_EMPTY(table->name))
-    {
-      startP.x += elem->width / 2.0;
-      startP.y += table->name_font_height;
-      renderer_ops->set_font (renderer,
-                              table->name_font,
-                              table->name_font_height);
-      renderer_ops->draw_string (renderer,
-                                 table->name,
-                                 &startP,
-                                 ALIGN_CENTER,
-                                 &table->text_color);
-    }
+  dia_renderer_draw_rect (renderer, &startP, &endP, &table->fill_color, &table->line_color);
+
+  if (IS_NOT_EMPTY (table->name)) {
+    startP.x += elem->width / 2.0;
+    startP.y += table->name_font_height;
+    dia_renderer_set_font (renderer,
+                           table->name_font,
+                           table->name_font_height);
+    dia_renderer_draw_string (renderer,
+                              table->name,
+                              &startP,
+                              ALIGN_CENTER,
+                              &table->text_color);
+  }
 
-  if (table->visible_comment && IS_NOT_EMPTY(table->comment))
-    {
-      draw_comments (renderer, table->comment_font, table->comment_font_height,
-                     &table->text_color, table->comment, table->tagging_comment,
-                     TABLE_COMMENT_MAXWIDTH, &startP, ALIGN_CENTER);
-    }
+  if (table->visible_comment && IS_NOT_EMPTY (table->comment)) {
+    draw_comments (renderer,
+                   table->comment_font,
+                   table->comment_font_height,
+                   &table->text_color,
+                   table->comment,
+                   table->tagging_comment,
+                   TABLE_COMMENT_MAXWIDTH,
+                   &startP,
+                   ALIGN_CENTER);
+  }
 
   return endP.y;
 }
@@ -601,15 +603,15 @@ table_draw_namebox (Table * table, DiaRenderer * renderer, Element * elem)
  * @see   uml_create_documentation
  */
 static void
-draw_comments(DiaRenderer *renderer,
-              DiaFont     *font,
-              real         font_height,
-              Color       *text_color,
-              gchar       *comment,
-              gboolean     comment_tagging,
-              gint         Comment_line_length,
-              Point       *p,
-              gint         alignment)
+draw_comments (DiaRenderer *renderer,
+               DiaFont     *font,
+               real         font_height,
+               Color       *text_color,
+               gchar       *comment,
+               gboolean     comment_tagging,
+               gint         Comment_line_length,
+               Point       *p,
+               gint         alignment)
 {
   gint      NumberOfLines = 0;
   gint      Index;
@@ -617,32 +619,31 @@ draw_comments(DiaRenderer *renderer,
   gchar     *NewLineP= NULL;
   gchar     *RenderP;
 
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-
   CommentString =
-    create_documentation_tag(comment, comment_tagging, Comment_line_length, &NumberOfLines);
+    create_documentation_tag (comment, comment_tagging, Comment_line_length, &NumberOfLines);
   RenderP = CommentString;
-  renderer_ops->set_font(renderer, font, font_height);
-  for ( Index=0; Index < NumberOfLines; Index++)
-  {
+  dia_renderer_set_font (renderer, font, font_height);
+  for ( Index=0; Index < NumberOfLines; Index++) {
     p->y += font_height;                    /* Advance to the next line */
-    NewLineP = strchr(RenderP, '\n');
-    if ( NewLineP != NULL)
-    {
+    NewLineP = strchr (RenderP, '\n');
+    if ( NewLineP != NULL) {
       *NewLineP++ = '\0';
     }
-    renderer_ops->draw_string(renderer, RenderP, p, alignment, text_color);
+    dia_renderer_draw_string (renderer, RenderP, p, alignment, text_color);
     RenderP = NewLineP;
     if ( NewLineP == NULL){
-        break;
+      break;
     }
   }
-  g_free(CommentString);
+  g_free (CommentString);
 }
 
 static void
-fill_diamond (DiaRenderer *renderer, real half_height, real width,
-              Point * lower_midpoint, Color * color)
+fill_diamond (DiaRenderer *renderer,
+              real         half_height,
+              real         width,
+              Point       *lower_midpoint,
+              Color       *color)
 {
   Point poly[4];
 
@@ -655,17 +656,18 @@ fill_diamond (DiaRenderer *renderer, real half_height, real width,
   poly[3].x = poly[1].x;
   poly[3].y = lower_midpoint->y - half_height;
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_fillstyle (renderer, FILLSTYLE_SOLID);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4, color, NULL);
+  dia_renderer_draw_polygon (renderer, poly, 4, color, NULL);
 }
 
 static real
-table_draw_attributesbox (Table * table, DiaRenderer * renderer,
-                          Element * elem, real Yoffset)
+table_draw_attributesbox (Table         *table,
+                          DiaRenderer   *renderer,
+                          Element       *elem,
+                          real           Yoffset)
 {
-  DiaRendererClass * renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point startP, startTypeP;
   Point endP;
   Point indicP;
@@ -683,7 +685,7 @@ table_draw_attributesbox (Table * table, DiaRenderer * renderer,
   endP.x = startP.x + elem->width;
   endP.y = startP.y + table->attributesbox_height;
 
-  renderer_ops->draw_rect (renderer, &startP, &endP, fill_color, line_color);
+  dia_renderer_draw_rect (renderer, &startP, &endP, fill_color, line_color);
 
   startP.x += TABLE_ATTR_NAME_OFFSET;
   startP.x += (table->border_width/2.0 + 0.1);
@@ -691,98 +693,88 @@ table_draw_attributesbox (Table * table, DiaRenderer * renderer,
   list = table->attributes;
   /* adjust size of symbols with font height */
   scale = table->normal_font_height/TABLE_NORMAL_FONT_HEIGHT;
-  while (list != NULL)
-    {
-      TableAttribute * attr = (TableAttribute *) list->data;
-
-      if (attr->primary_key)
-        {
-          attr_font = table->primary_key_font;
-          attr_font_height = table->primary_key_font_height;
-        }
-      else
-        {
-          attr_font = table->normal_font;
-          attr_font_height = table->normal_font_height;
-        }
-
-      startP.y += attr_font_height;
-      renderer_ops->set_font (renderer,
-                              attr_font,
-                              attr_font_height);
-
-      renderer_ops->set_linewidth (renderer, TABLE_ATTR_INDIC_LINE_WIDTH);
-      indicP = startP;
-      indicP.x -= ((TABLE_ATTR_NAME_OFFSET/2.0)
-                   + (TABLE_ATTR_INDIC_WIDTH*scale/4.0));
-      indicP.y -= (attr_font_height/2.0);
-      indicP.y += TABLE_ATTR_INDIC_WIDTH*scale/2.0;
-      if (attr->primary_key)
-        {
-          fill_diamond (renderer,
-                        0.75*TABLE_ATTR_INDIC_WIDTH*scale,
-                        TABLE_ATTR_INDIC_WIDTH*scale,
-                        &indicP,
-                        &table->line_color);
-        }
-      else if (attr->nullable)
-        {
-          renderer_ops->draw_ellipse (renderer,
-                                      &indicP,
-                                      TABLE_ATTR_INDIC_WIDTH*scale,
-                                      TABLE_ATTR_INDIC_WIDTH*scale,
-                                      NULL, &table->line_color);
-        }
-      else
-        {
-          renderer_ops->draw_ellipse (renderer,
-                                      &indicP,
-                                      TABLE_ATTR_INDIC_WIDTH*scale,
-                                      TABLE_ATTR_INDIC_WIDTH*scale,
-                                      &table->line_color, NULL);
-        }
-
-      if (IS_NOT_EMPTY(attr->name))
-        {
-          renderer_ops->draw_string (renderer,
-                                     attr->name,
-                                     &startP,
-                                     ALIGN_LEFT,
-                                     text_color);
-        }
-      if (IS_NOT_EMPTY(attr->type))
-        {
-          startTypeP = startP;
-          startTypeP.x += table->maxwidth_attr_name + TABLE_ATTR_NAME_TYPE_GAP;
-          renderer_ops->draw_string (renderer,
-                                     attr->type,
-                                     &startTypeP,
-                                     ALIGN_LEFT,
-                                     text_color);
-        }
+  while (list != NULL) {
+    TableAttribute * attr = (TableAttribute *) list->data;
+
+    if (attr->primary_key) {
+      attr_font = table->primary_key_font;
+      attr_font_height = table->primary_key_font_height;
+    } else {
+      attr_font = table->normal_font;
+      attr_font_height = table->normal_font_height;
+    }
 
-      if (table->underline_primary_key && attr->primary_key)
-        underline_table_attribute (renderer, startP, attr, table);
+    startP.y += attr_font_height;
+    dia_renderer_set_font (renderer,
+                           attr_font,
+                           attr_font_height);
+
+    dia_renderer_set_linewidth (renderer, TABLE_ATTR_INDIC_LINE_WIDTH);
+    indicP = startP;
+    indicP.x -= ((TABLE_ATTR_NAME_OFFSET/2.0)
+                  + (TABLE_ATTR_INDIC_WIDTH*scale/4.0));
+    indicP.y -= (attr_font_height/2.0);
+    indicP.y += TABLE_ATTR_INDIC_WIDTH*scale/2.0;
+    if (attr->primary_key) {
+      fill_diamond (renderer,
+                    0.75*TABLE_ATTR_INDIC_WIDTH*scale,
+                    TABLE_ATTR_INDIC_WIDTH*scale,
+                    &indicP,
+                    &table->line_color);
+    } else if (attr->nullable) {
+      dia_renderer_draw_ellipse (renderer,
+                                 &indicP,
+                                 TABLE_ATTR_INDIC_WIDTH*scale,
+                                 TABLE_ATTR_INDIC_WIDTH*scale,
+                                 NULL,
+                                 &table->line_color);
+    } else {
+      dia_renderer_draw_ellipse (renderer,
+                                 &indicP,
+                                 TABLE_ATTR_INDIC_WIDTH*scale,
+                                 TABLE_ATTR_INDIC_WIDTH*scale,
+                                 &table->line_color,
+                                 NULL);
+    }
 
-      if (table->visible_comment && IS_NOT_EMPTY(attr->comment))
-        {
-          startP.x += TABLE_ATTR_COMMENT_OFFSET;
-          draw_comments (renderer,
-                         table->comment_font,
-                         table->comment_font_height,
-                         text_color,
-                         attr->comment,
-                         table->tagging_comment,
-                         TABLE_COMMENT_MAXWIDTH,
-                         &startP,
-                         ALIGN_LEFT);
-          startP.x -= TABLE_ATTR_COMMENT_OFFSET;
-          startP.y += table->comment_font_height/2;
-        }
+    if (IS_NOT_EMPTY (attr->name)) {
+      dia_renderer_draw_string (renderer,
+                                attr->name,
+                                &startP,
+                                ALIGN_LEFT,
+                                text_color);
+    }
+    if (IS_NOT_EMPTY (attr->type)) {
+      startTypeP = startP;
+      startTypeP.x += table->maxwidth_attr_name + TABLE_ATTR_NAME_TYPE_GAP;
+      dia_renderer_draw_string (renderer,
+                                attr->type,
+                                &startTypeP,
+                                ALIGN_LEFT,
+                                text_color);
+    }
 
-      list = g_list_next (list);
+    if (table->underline_primary_key && attr->primary_key)
+      underline_table_attribute (renderer, startP, attr, table);
+
+    if (table->visible_comment && IS_NOT_EMPTY (attr->comment)) {
+      startP.x += TABLE_ATTR_COMMENT_OFFSET;
+      draw_comments (renderer,
+                     table->comment_font,
+                     table->comment_font_height,
+                     text_color,
+                     attr->comment,
+                     table->tagging_comment,
+                     TABLE_COMMENT_MAXWIDTH,
+                     &startP,
+                     ALIGN_LEFT);
+      startP.x -= TABLE_ATTR_COMMENT_OFFSET;
+      startP.y += table->comment_font_height/2;
     }
 
+    list = g_list_next (list);
+  }
+
   return Yoffset;
 }
 
@@ -1026,40 +1018,35 @@ table_init_attributesbox_height (Table * table)
 }
 
 static void
-underline_table_attribute(DiaRenderer  *   renderer,
-                          Point            StartPoint,
-                          TableAttribute * attr,
-                          Table *          table)
+underline_table_attribute (DiaRenderer     *renderer,
+                           Point            StartPoint,
+                           TableAttribute  *attr,
+                           Table           *table)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point    UnderlineStartPoint;
   Point    UnderlineEndPoint;
   DiaFont * font;
   real font_height;
 
-  if (attr->primary_key)
-    {
-      font = table->primary_key_font;
-      font_height = table->primary_key_font_height;
-    }
-  else
-    {
-      font = table->normal_font;
-      font_height = table->normal_font_height;
-    }
+  if (attr->primary_key) {
+    font = table->primary_key_font;
+    font_height = table->primary_key_font_height;
+  } else {
+    font = table->normal_font;
+    font_height = table->normal_font_height;
+  }
 
   UnderlineStartPoint = StartPoint;
   UnderlineStartPoint.y += font_height * 0.1;
   UnderlineEndPoint = UnderlineStartPoint;
   UnderlineEndPoint.x += table->maxwidth_attr_name + TABLE_ATTR_NAME_TYPE_GAP;
-  if (IS_NOT_EMPTY(attr->type))
-    {
-      UnderlineEndPoint.x += dia_font_string_width(attr->type,
-                                                   font,
-                                                   font_height);
-    }
-  renderer_ops->set_linewidth(renderer, TABLE_UNDERLINE_WIDTH);
-  renderer_ops->draw_line(renderer,
+  if (IS_NOT_EMPTY (attr->type)) {
+    UnderlineEndPoint.x += dia_font_string_width (attr->type,
+                                                  font,
+                                                  font_height);
+  }
+  dia_renderer_set_linewidth (renderer, TABLE_UNDERLINE_WIDTH);
+  dia_renderer_draw_line (renderer,
                           &UnderlineStartPoint,
                           &UnderlineEndPoint,
                           &table->text_color);
diff --git a/objects/ER/attribute.c b/objects/ER/attribute.c
index 21a8e0fb..90c8b798 100644
--- a/objects/ER/attribute.c
+++ b/objects/ER/attribute.c
@@ -250,9 +250,8 @@ attribute_move(Attribute *attribute, Point *to)
 }
 
 static void
-attribute_draw(Attribute *attribute, DiaRenderer *renderer)
+attribute_draw (Attribute *attribute, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point center;
   Point start, end;
   Point p;
@@ -267,52 +266,64 @@ attribute_draw(Attribute *attribute, DiaRenderer *renderer)
   center.x = elem->corner.x + elem->width/2;
   center.y = elem->corner.y + elem->height/2;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->draw_ellipse (renderer, &center,
-                             elem->width, elem->height,
-                             &attribute->inner_color, NULL);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_draw_ellipse (renderer,
+                             &center,
+                             elem->width,
+                             elem->height,
+                             &attribute->inner_color,
+                             NULL);
 
-  renderer_ops->set_linewidth(renderer, attribute->border_width);
+  dia_renderer_set_linewidth (renderer, attribute->border_width);
   if (attribute->derived) {
-    renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, 0.3);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, 0.3);
   } else {
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
   }
 
-  renderer_ops->draw_ellipse (renderer, &center,
-                             elem->width, elem->height,
-                             NULL, &attribute->border_color);
+  dia_renderer_draw_ellipse (renderer,
+                             &center,
+                             elem->width,
+                             elem->height,
+                             NULL,
+                             &attribute->border_color);
 
   if(attribute->multivalue) {
-    renderer_ops->draw_ellipse (renderer, &center,
-                               elem->width - 2*MULTIVALUE_BORDER_WIDTH_X,
-                               elem->height - 2*MULTIVALUE_BORDER_WIDTH_Y,
-                               NULL, &attribute->border_color);
+    dia_renderer_draw_ellipse (renderer,
+                               &center,
+                               elem->width - 2*MULTIVALUE_BORDER_WIDTH_X,
+                               elem->height - 2*MULTIVALUE_BORDER_WIDTH_Y,
+                               NULL,
+                               &attribute->border_color);
   }
 
   p.x = elem->corner.x + elem->width / 2.0;
   p.y = elem->corner.y + (elem->height - attribute->font_height)/2.0 +
-         dia_font_ascent(attribute->name,
-                         attribute->font, attribute->font_height);
+         dia_font_ascent (attribute->name,
+                          attribute->font,
+                          attribute->font_height);
 
-  renderer_ops->set_font(renderer,  attribute->font, attribute->font_height);
-  renderer_ops->draw_string(renderer, attribute->name,
-                            &p, ALIGN_CENTER,
-                            &color_black);
+  dia_renderer_set_font (renderer, attribute->font, attribute->font_height);
+  dia_renderer_draw_string (renderer,
+                            attribute->name,
+                            &p,
+                            ALIGN_CENTER,
+                            &color_black);
 
   if (attribute->key || attribute->weakkey) {
     if (attribute->weakkey) {
-      renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, 0.3);
+      dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, 0.3);
     } else {
-      renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+      dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
     }
-    width = dia_font_string_width(attribute->name,
-                                  attribute->font, attribute->font_height);
+    width = dia_font_string_width (attribute->name,
+                                   attribute->font,
+                                   attribute->font_height);
     start.x = center.x - width / 2;
     start.y = center.y + 0.4;
     end.x = center.x + width / 2;
     end.y = center.y + 0.4;
-    renderer_ops->draw_line(renderer, &start, &end, &color_black);
+    dia_renderer_draw_line (renderer, &start, &end, &color_black);
   }
 }
 
diff --git a/objects/ER/entity.c b/objects/ER/entity.c
index 6a02ed6e..e7de4660 100644
--- a/objects/ER/entity.c
+++ b/objects/ER/entity.c
@@ -226,9 +226,8 @@ entity_move(Entity *entity, Point *to)
 }
 
 static void
-entity_draw(Entity *entity, DiaRenderer *renderer)
+entity_draw (Entity *entity, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point ul_corner, lr_corner;
   Point p;
   Element *elem;
@@ -244,28 +243,29 @@ entity_draw(Entity *entity, DiaRenderer *renderer)
   lr_corner.x = elem->corner.x + elem->width;
   lr_corner.y = elem->corner.y + elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
 
-  renderer_ops->set_linewidth(renderer, entity->border_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, entity->border_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  renderer_ops->draw_rect(renderer,
-                          &ul_corner,
-                          &lr_corner,
-                          &entity->inner_color,
-                          &entity->border_color);
+  dia_renderer_draw_rect (renderer,
+                          &ul_corner,
+                          &lr_corner,
+                          &entity->inner_color,
+                          &entity->border_color);
 
-  if(entity->weak) {
+  if (entity->weak) {
     diff = WEAK_BORDER_WIDTH/*MIN(elem->width / 2.0 * 0.20, elem->height / 2.0 * 0.20)*/;
     ul_corner.x += diff;
     ul_corner.y += diff;
     lr_corner.x -= diff;
     lr_corner.y -= diff;
-    renderer_ops->draw_rect(renderer,
-                            &ul_corner, &lr_corner,
-                            NULL,
-                            &entity->border_color);
+    dia_renderer_draw_rect (renderer,
+                            &ul_corner,
+                            &lr_corner,
+                            NULL,
+                            &entity->border_color);
   }
   if(entity->associative){
     Point corners[4];
@@ -277,25 +277,26 @@ entity_draw(Entity *entity, DiaRenderer *renderer)
     corners[2].y = elem->corner.y + elem->height / 2;
     corners[3].x = elem->corner.x + elem->width / 2;
     corners[3].y = elem->corner.y + elem->height;
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
 
-    renderer_ops->set_linewidth(renderer, entity->border_width);
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+    dia_renderer_set_linewidth (renderer, entity->border_width);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-    renderer_ops->draw_polygon (renderer, corners, 4,
-                               &entity->inner_color,
-                               &entity->border_color);
+    dia_renderer_draw_polygon (renderer, corners, 4,
+                               &entity->inner_color,
+                               &entity->border_color);
   }
 
   p.x = elem->corner.x + elem->width / 2.0;
   p.y = elem->corner.y + (elem->height - entity->font_height)/2.0 +
-      dia_font_ascent(entity->name,entity->font, entity->font_height);
-  renderer_ops->set_font(renderer, entity->font, entity->font_height);
-  renderer_ops->draw_string(renderer,
-                             entity->name,
-                             &p, ALIGN_CENTER,
-                             &color_black);
+      dia_font_ascent (entity->name,entity->font, entity->font_height);
+  dia_renderer_set_font (renderer, entity->font, entity->font_height);
+  dia_renderer_draw_string (renderer,
+                            entity->name,
+                            &p,
+                            ALIGN_CENTER,
+                            &color_black);
 }
 
 static void
diff --git a/objects/ER/participation.c b/objects/ER/participation.c
index 4f57c8fc..f5ffded2 100644
--- a/objects/ER/participation.c
+++ b/objects/ER/participation.c
@@ -189,9 +189,8 @@ participation_move(Participation *participation, Point *to)
 }
 
 static void
-participation_draw(Participation *participation, DiaRenderer *renderer)
+participation_draw (Participation *participation, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &participation->orth;
   Point *points;
   Point *left_points;
@@ -205,54 +204,54 @@ participation_draw(Participation *participation, DiaRenderer *renderer)
   last_left = 0.0;
   last_right = 0.0;
 
-  renderer_ops->set_linewidth(renderer, PARTICIPATION_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, PARTICIPATION_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (participation->total) {
-    left_points = g_new0(Point, n);
-    right_points = g_new0(Point, n);
+    left_points = g_new0 (Point, n);
+    right_points = g_new0 (Point, n);
     for(i = 0; i < n - 1; i++) {
       if(orth->orientation[i] == HORIZONTAL) { /* HORIZONTAL */
-       if (points[i].x < points[i+1].x) { /* RIGHT */
-         left_points[i].x = points[i].x + last_left;
-         left_points[i].y = points[i].y - TOTAL_SEPARATION / 2.0;
-         last_left = - TOTAL_SEPARATION/2.0;
-         right_points[i].x = points[i].x + last_right;
-         right_points[i].y = points[i].y + TOTAL_SEPARATION / 2.0;
-         last_right = TOTAL_SEPARATION/2.0;
-       } else { /* LEFT */
-         left_points[i].x = points[i].x + last_left;
-         left_points[i].y = points[i].y + TOTAL_SEPARATION / 2.0;
-         last_left = TOTAL_SEPARATION/2.0;
-         right_points[i].x = points[i].x + last_right;
-         right_points[i].y = points[i].y - TOTAL_SEPARATION / 2.0;
-         last_right = - TOTAL_SEPARATION/2.0;
-       }
+        if (points[i].x < points[i+1].x) { /* RIGHT */
+          left_points[i].x = points[i].x + last_left;
+          left_points[i].y = points[i].y - TOTAL_SEPARATION / 2.0;
+          last_left = - TOTAL_SEPARATION/2.0;
+          right_points[i].x = points[i].x + last_right;
+          right_points[i].y = points[i].y + TOTAL_SEPARATION / 2.0;
+          last_right = TOTAL_SEPARATION/2.0;
+        } else { /* LEFT */
+          left_points[i].x = points[i].x + last_left;
+          left_points[i].y = points[i].y + TOTAL_SEPARATION / 2.0;
+          last_left = TOTAL_SEPARATION/2.0;
+          right_points[i].x = points[i].x + last_right;
+          right_points[i].y = points[i].y - TOTAL_SEPARATION / 2.0;
+          last_right = - TOTAL_SEPARATION/2.0;
+        }
       } else { /* VERTICAL */
-       if (points[i].y < points[i+1].y) { /* DOWN */
-         left_points[i].x = points[i].x + TOTAL_SEPARATION / 2.0;
-         left_points[i].y = points[i].y + last_left;
-         last_left = TOTAL_SEPARATION/2.0;
-         right_points[i].x = points[i].x - TOTAL_SEPARATION / 2.0;
-         right_points[i].y = points[i].y + last_right;
-         last_right = - TOTAL_SEPARATION/2.0;
-       } else { /* UP */
-         left_points[i].x = points[i].x - TOTAL_SEPARATION / 2.0;
-         left_points[i].y = points[i].y + last_left;
-         last_left = - TOTAL_SEPARATION/2.0;
-         right_points[i].x = points[i].x + TOTAL_SEPARATION / 2.0;
-         right_points[i].y = points[i].y + last_right;
-         last_right = TOTAL_SEPARATION/2.0;
-       }
+        if (points[i].y < points[i+1].y) { /* DOWN */
+          left_points[i].x = points[i].x + TOTAL_SEPARATION / 2.0;
+          left_points[i].y = points[i].y + last_left;
+          last_left = TOTAL_SEPARATION/2.0;
+          right_points[i].x = points[i].x - TOTAL_SEPARATION / 2.0;
+          right_points[i].y = points[i].y + last_right;
+          last_right = - TOTAL_SEPARATION/2.0;
+        } else { /* UP */
+          left_points[i].x = points[i].x - TOTAL_SEPARATION / 2.0;
+          left_points[i].y = points[i].y + last_left;
+          last_left = - TOTAL_SEPARATION/2.0;
+          right_points[i].x = points[i].x + TOTAL_SEPARATION / 2.0;
+          right_points[i].y = points[i].y + last_right;
+          last_right = TOTAL_SEPARATION/2.0;
+        }
       }
     }
     if(orth->orientation[i-1] == HORIZONTAL) { /* HORIZONTAL */
-       left_points[i].x = points[i].x;
-       left_points[i].y = points[i].y + last_left;
-       right_points[i].x = points[i].x;
-       right_points[i].y = points[i].y + last_right;
+      left_points[i].x = points[i].x;
+      left_points[i].y = points[i].y + last_left;
+      right_points[i].x = points[i].x;
+      right_points[i].y = points[i].y + last_right;
     } else { /* VERTICAL */
       left_points[i].x = points[i].x + last_left;
       left_points[i].y = points[i].y;
@@ -260,12 +259,12 @@ participation_draw(Participation *participation, DiaRenderer *renderer)
       right_points[i].y = points[i].y;
     }
 
-    renderer_ops->draw_polyline(renderer, left_points, n, &color_black);
-    renderer_ops->draw_polyline(renderer, right_points, n, &color_black);
-    g_free(left_points);
-    g_free(right_points);
+    dia_renderer_draw_polyline (renderer, left_points, n, &color_black);
+    dia_renderer_draw_polyline (renderer, right_points, n, &color_black);
+    g_free (left_points);
+    g_free (right_points);
   }  else {
-    renderer_ops->draw_polyline(renderer, points, n, &color_black);
+    dia_renderer_draw_polyline (renderer, points, n, &color_black);
   }
 }
 
diff --git a/objects/ER/relationship.c b/objects/ER/relationship.c
index e59a43ea..d9f78593 100644
--- a/objects/ER/relationship.c
+++ b/objects/ER/relationship.c
@@ -238,9 +238,8 @@ relationship_move(Relationship *relationship, Point *to)
 }
 
 static void
-relationship_draw(Relationship *relationship, DiaRenderer *renderer)
+relationship_draw (Relationship *relationship, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point corners[4];
   Point lc, rc;
   Point p;
@@ -262,15 +261,17 @@ relationship_draw(Relationship *relationship, DiaRenderer *renderer)
   corners[3].x = elem->corner.x + elem->width / 2;
   corners[3].y = elem->corner.y + elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
 
-  renderer_ops->set_linewidth(renderer, relationship->border_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, relationship->border_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  renderer_ops->draw_polygon(renderer, corners, 4,
-                            &relationship->inner_color,
-                            &relationship->border_color);
+  dia_renderer_draw_polygon (renderer,
+                             corners,
+                             4,
+                             &relationship->inner_color,
+                             &relationship->border_color);
 
   if (relationship->rotate) {
     lc.x = corners[1].x + 0.2;
@@ -293,29 +294,38 @@ relationship_draw(Relationship *relationship, DiaRenderer *renderer)
     corners[2].x -= diff;
     corners[3].y -= diff*DIAMOND_RATIO;
 
-    renderer_ops->draw_polygon(renderer, corners, 4,
-                              NULL, &relationship->border_color);
+    dia_renderer_draw_polygon (renderer,
+                               corners,
+                               4,
+                               NULL,
+                               &relationship->border_color);
   }
 
-  renderer_ops->set_font(renderer, relationship->font, relationship->font_height);
-  renderer_ops->draw_string(renderer,
-                            relationship->left_cardinality,
-                            &lc, left_align,
-                            &color_black);
-  renderer_ops->draw_string(renderer,
-                            relationship->right_cardinality,
-                            &rc, ALIGN_LEFT,
-                            &color_black);
+  dia_renderer_set_font (renderer,
+                         relationship->font,
+                         relationship->font_height);
+  dia_renderer_draw_string (renderer,
+                            relationship->left_cardinality,
+                            &lc,
+                            left_align,
+                            &color_black);
+  dia_renderer_draw_string (renderer,
+                            relationship->right_cardinality,
+                            &rc,
+                            ALIGN_LEFT,
+                            &color_black);
 
   p.x = elem->corner.x + elem->width / 2.0;
   p.y = elem->corner.y + (elem->height - relationship->font_height)/2.0 +
-         dia_font_ascent(relationship->name,
-                         relationship->font, relationship->font_height);
-
-  renderer_ops->draw_string(renderer,
-                            relationship->name,
-                            &p, ALIGN_CENTER,
-                            &color_black);
+         dia_font_ascent (relationship->name,
+                          relationship->font,
+                          relationship->font_height);
+
+  dia_renderer_draw_string (renderer,
+                            relationship->name,
+                            &p,
+                            ALIGN_CENTER,
+                            &color_black);
 }
 
 static void
diff --git a/objects/FS/flow-ortho.c b/objects/FS/flow-ortho.c
index 6b2a2f4e..653a746a 100644
--- a/objects/FS/flow-ortho.c
+++ b/objects/FS/flow-ortho.c
@@ -335,9 +335,8 @@ orthflow_move(Orthflow *orthflow, Point *to)
 }
 
 static void
-orthflow_draw(Orthflow *orthflow, DiaRenderer *renderer)
+orthflow_draw (Orthflow *orthflow, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   int n = orthflow->orth.numpoints ;
   Color* render_color = &orthflow_color_signal;
   Point *points;
@@ -353,36 +352,39 @@ orthflow_draw(Orthflow *orthflow, DiaRenderer *renderer)
 
   points = &orthflow->orth.points[0];
 
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   switch (orthflow->type) {
-  case ORTHFLOW_SIGNAL:
-    linewidth = ORTHFLOW_WIDTH;
-    renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, ORTHFLOW_DASHLEN);
-    render_color = &orthflow_color_signal ;
-    break ;
-  case ORTHFLOW_MATERIAL:
-    linewidth = ORTHFLOW_MATERIAL_WIDTH;
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-    render_color = &orthflow_color_material ;
-    break ;
-  case ORTHFLOW_ENERGY:
-    linewidth = ORTHFLOW_WIDTH;
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-    render_color = &orthflow_color_energy ;
-    break ;
-  default:
-    linewidth = 0.001;
-    break;
+    case ORTHFLOW_SIGNAL:
+      linewidth = ORTHFLOW_WIDTH;
+      dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, ORTHFLOW_DASHLEN);
+      render_color = &orthflow_color_signal;
+      break ;
+    case ORTHFLOW_MATERIAL:
+      linewidth = ORTHFLOW_MATERIAL_WIDTH;
+      dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+      render_color = &orthflow_color_material;
+      break ;
+    case ORTHFLOW_ENERGY:
+      linewidth = ORTHFLOW_WIDTH;
+      dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+      render_color = &orthflow_color_energy;
+      break ;
+    default:
+      linewidth = 0.001;
+      break;
   }
 
-  renderer_ops->set_linewidth(renderer, linewidth);
-  renderer_ops->draw_polyline_with_arrows(renderer, points, n,
-                                         ORTHFLOW_WIDTH,
-                                         render_color,
-                                         NULL, &arrow);
+  dia_renderer_set_linewidth (renderer, linewidth);
+  dia_renderer_draw_polyline_with_arrows (renderer,
+                                          points,
+                                          n,
+                                          ORTHFLOW_WIDTH,
+                                          render_color,
+                                          NULL,
+                                          &arrow);
 
-  text_draw(orthflow->text, renderer);
+  text_draw (orthflow->text, renderer);
 }
 
 static DiaObject *
diff --git a/objects/FS/flow.c b/objects/FS/flow.c
index 60aeae4a..ccf405f4 100644
--- a/objects/FS/flow.c
+++ b/objects/FS/flow.c
@@ -304,9 +304,8 @@ flow_move(Flow *flow, Point *to)
 }
 
 static void
-flow_draw(Flow *flow, DiaRenderer *renderer)
+flow_draw (Flow *flow, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints, p1, p2;
   Arrow arrow;
   int n1 = 1, n2 = 0;
@@ -321,35 +320,37 @@ flow_draw(Flow *flow, DiaRenderer *renderer)
 
   endpoints = &flow->connection.endpoints[0];
 
-  renderer_ops->set_linewidth(renderer, FLOW_WIDTH);
+  dia_renderer_set_linewidth (renderer, FLOW_WIDTH);
 
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   switch (flow->type) {
-  case FLOW_SIGNAL:
-    renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, FLOW_DASHLEN);
-    render_color = &flow_color_signal ;
-    break ;
-  case FLOW_MATERIAL:
-    renderer_ops->set_linewidth(renderer, FLOW_MATERIAL_WIDTH ) ;
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-    render_color = &flow_color_material ;
-    break ;
-  case FLOW_ENERGY:
-    render_color = &flow_color_energy ;
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+    case FLOW_SIGNAL:
+      dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, FLOW_DASHLEN);
+      render_color = &flow_color_signal ;
+      break ;
+    case FLOW_MATERIAL:
+      dia_renderer_set_linewidth (renderer, FLOW_MATERIAL_WIDTH);
+      dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+      render_color = &flow_color_material;
+      break ;
+    case FLOW_ENERGY:
+      render_color = &flow_color_energy;
+      dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
   }
 
   p1 = endpoints[n1];
   p2 = endpoints[n2];
 
-  renderer_ops->draw_line_with_arrows(renderer,
-                                      &p1, &p2,
-                                      FLOW_WIDTH,
-                                      render_color,
-                                      &arrow, NULL);
+  dia_renderer_draw_line_with_arrows (renderer,
+                                      &p1,
+                                      &p2,
+                                      FLOW_WIDTH,
+                                      render_color,
+                                      &arrow,
+                                      NULL);
 
-  text_draw(flow->text, renderer);
+  text_draw (flow->text, renderer);
 }
 
 static DiaObject *
diff --git a/objects/FS/function.c b/objects/FS/function.c
index 1c49537a..5fdbfc25 100644
--- a/objects/FS/function.c
+++ b/objects/FS/function.c
@@ -277,9 +277,8 @@ function_move(Function *pkg, Point *to)
 }
 
 static void
-function_draw(Function *pkg, DiaRenderer *renderer)
+function_draw (Function *pkg, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point p1, p2;
@@ -298,35 +297,39 @@ function_draw(Function *pkg, DiaRenderer *renderer)
 
   font_height = pkg->text->height ;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, font_height / FUNCTION_BORDERWIDTH_SCALE );
-  if (pkg->is_wish)
-    renderer_ops->set_linestyle( renderer, LINESTYLE_DASHED, font_height / FUNCTION_DASHLENGTH_SCALE ) ;
-  else
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer,
+                              font_height / FUNCTION_BORDERWIDTH_SCALE);
+  if (pkg->is_wish) {
+    dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED,
+                                font_height / FUNCTION_DASHLENGTH_SCALE);
+  } else {
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  }
 
   p1.x = x; p1.y = y;
   p2.x = x+w; p2.y = y+h;
 
   if (pkg->is_user) {
-    renderer_ops->draw_rect(renderer,
-                            &p1, &p2,
-                            &color_white,
-                            &color_black);
+    dia_renderer_draw_rect (renderer,
+                            &p1,
+                            &p2,
+                            &color_white,
+                            &color_black);
     p1.x += font_height / FUNCTION_MARGIN_SCALE;
     p1.y += font_height / FUNCTION_MARGIN_SCALE;
     p2.y -= font_height / FUNCTION_MARGIN_SCALE;
     p2.x -= font_height / FUNCTION_MARGIN_SCALE;
     /* y += FUNCTION_MARGIN_M; */
   }
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &color_white,
-                          &color_black);
-
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &color_white,
+                          &color_black);
 
-  text_draw(pkg->text, renderer);
 
+  text_draw (pkg->text, renderer);
 }
 
 static void
diff --git a/objects/GRAFCET/action.c b/objects/GRAFCET/action.c
index 4503ec42..e3227c83 100644
--- a/objects/GRAFCET/action.c
+++ b/objects/GRAFCET/action.c
@@ -318,25 +318,25 @@ action_update_data(Action *action)
 
 
 static void
-action_draw(Action *action, DiaRenderer *renderer)
+action_draw (Action *action, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Connection *conn = &action->connection;
   Point ul,br,p1,p2;
   int i;
   real chunksize;
   Color cl;
 
-  renderer_ops->set_linewidth(renderer, ACTION_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, ACTION_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   /* first, draw the line or polyline from the step to the action label */
   if (conn->endpoints[0].y == conn->endpoints[1].y) {
     /* simpler case */
-    renderer_ops->draw_line(renderer,
-                            &conn->endpoints[0],&conn->endpoints[1],
-                            &color_black);
+    dia_renderer_draw_line (renderer,
+                            &conn->endpoints[0],
+                            &conn->endpoints[1],
+                            &color_black);
   } else {
     Point pts[4];
     pts[0] = conn->endpoints[0];
@@ -345,9 +345,10 @@ action_draw(Action *action, DiaRenderer *renderer)
     pts[2].y = pts[3].y;
     pts[1].x = pts[2].x = .5 * (pts[0].x + pts[3].x);
 
-    renderer_ops->draw_polyline(renderer,
-                                pts,sizeof(pts)/sizeof(pts[0]),
-                                &color_black);
+    dia_renderer_draw_polyline (renderer,
+                                pts,
+                                sizeof(pts)/sizeof(pts[0]),
+                                &color_black);
   }
 
   /* Now, draw the action label. */
@@ -356,28 +357,28 @@ action_draw(Action *action, DiaRenderer *renderer)
   br.x = ul.x + action->label_width;
   br.y = ul.y + ACTION_HEIGHT;
 
-  renderer_ops->draw_rect(renderer,&ul,&br,&color_white, NULL);
+  dia_renderer_draw_rect (renderer, &ul, &br, &color_white, NULL);
 
-  action_text_draw(action->text,renderer);
+  action_text_draw (action->text,renderer);
 
   p1.x = p2.x = ul.x;
   p1.y = ul.y; p2.y = br.y;
 
   for (i=0; i<action->text->numlines-1; i++) {
-    chunksize = text_get_line_width(action->text, i);
+    chunksize = text_get_line_width (action->text, i);
     p1.x = p2.x = p1.x + chunksize + 2 * action->space_width;
-    renderer_ops->draw_line(renderer,&p1,&p2,&color_black);
+    dia_renderer_draw_line (renderer, &p1, &p2, &color_black);
   }
 
   if (action->macro_call) {
     p1.x = p2.x = ul.x + 2.0 * action->space_width;
-    renderer_ops->draw_line(renderer,&p1,&p2,&color_black);
+    dia_renderer_draw_line (renderer, &p1, &p2, &color_black);
     p1.x = p2.x = br.x - 2.0 * action->space_width;
-    renderer_ops->draw_line(renderer,&p1,&p2,&color_black);
+    dia_renderer_draw_line (renderer, &p1, &p2, &color_black);
   }
 
   cl.red = 1.0; cl.blue = cl.green = .2; cl.alpha = 1.0;
-  renderer_ops->draw_rect(renderer,&ul,&br,NULL,&color_black);
+  dia_renderer_draw_rect (renderer, &ul, &br, NULL, &color_black);
 }
 
 static DiaObject *
diff --git a/objects/GRAFCET/action_text_draw.c b/objects/GRAFCET/action_text_draw.c
index 0aeadc53..d0e557cb 100644
--- a/objects/GRAFCET/action_text_draw.c
+++ b/objects/GRAFCET/action_text_draw.c
@@ -37,26 +37,26 @@
    Now it's just a code fork. */
 
 void
-action_text_draw(Text *text, DiaRenderer *renderer)
+action_text_draw (Text *text, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pos;
   int i;
   real space_width;
 
-  renderer_ops->set_font(renderer, text->font, text->height);
+  dia_renderer_set_font (renderer, text->font, text->height);
 
   pos = text->position;
 
-  space_width = action_text_spacewidth(text);
+  space_width = action_text_spacewidth (text);
 
   /* TODO: Use the TextLine object when available for faster rendering. */
   for (i=0;i<text->numlines;i++) {
-    renderer_ops->draw_string(renderer,
-                             text_get_line(text, i),
-                             &pos, text->alignment,
-                             &text->color);
-    pos.x += text_get_line_width(text, i) +
+    dia_renderer_draw_string (renderer,
+                              text_get_line (text, i),
+                              &pos,
+                              text->alignment,
+                              &text->color);
+    pos.x += text_get_line_width (text, i) +
       2 * space_width;
   }
 
@@ -67,31 +67,28 @@ action_text_draw(Text *text, DiaRenderer *renderer)
     Point p1, p2;
 
 
-    str_width_first =
-      renderer_ops->get_text_width(renderer,
-                                   text_get_line(text, text->cursor_row),
-                                   text->cursor_pos);
-    str_width_whole =
-      renderer_ops->get_text_width(renderer,
-                                   text_get_line(text, text->cursor_row),
-                                   text_get_line_strlen(text, text->cursor_row));
+    str_width_first = dia_renderer_get_text_width (renderer,
+                                                   text_get_line (text, text->cursor_row),
+                                                   text->cursor_pos);
+    str_width_whole = dia_renderer_get_text_width (renderer,
+                                                   text_get_line (text, text->cursor_row),
+                                                   text_get_line_strlen (text, text->cursor_row));
 
     curs_x = text->position.x + str_width_first;
-    for (i=0;i<text->cursor_row;i++) {
-      curs_x += text_get_line_width(text, i) +
-       2 * space_width;
+    for (i = 0; i < text->cursor_row; i++) {
+      curs_x += text_get_line_width (text, i) + 2 * space_width;
     }
     curs_y = text->position.y - text->ascent;
 
     switch (text->alignment) {
-    case ALIGN_LEFT:
-      break;
-    case ALIGN_CENTER:
-      curs_x -= str_width_whole / 2.0; /* undefined behaviour ! */
-      break;
-    case ALIGN_RIGHT:
-      curs_x -= str_width_whole; /* undefined behaviour ! */
-      break;
+      case ALIGN_LEFT:
+        break;
+      case ALIGN_CENTER:
+        curs_x -= str_width_whole / 2.0; /* undefined behaviour ! */
+        break;
+      case ALIGN_RIGHT:
+        curs_x -= str_width_whole; /* undefined behaviour ! */
+        break;
     }
 
     p1.x = curs_x;
@@ -99,9 +96,9 @@ action_text_draw(Text *text, DiaRenderer *renderer)
     p2.x = curs_x;
     p2.y = curs_y + text->height;
 
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-    renderer_ops->set_linewidth(renderer, 0.1);
-    renderer_ops->draw_line(renderer, &p1, &p2, &color_black);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linewidth (renderer, 0.1);
+    dia_renderer_draw_line (renderer, &p1, &p2, &color_black);
   }
 }
 
diff --git a/objects/GRAFCET/boolequation.c b/objects/GRAFCET/boolequation.c
index 58b9c5a7..476b6335 100644
--- a/objects/GRAFCET/boolequation.c
+++ b/objects/GRAFCET/boolequation.c
@@ -1,7 +1,7 @@
 /* Dia -- an diagram creation/manipulation program
  * Copyright (C) 1998 Alexander Larsson
  *
- * This code renders boolean equations, as needed by the transitions' 
+ * This code renders boolean equations, as needed by the transitions'
  * receptivities.
  *
  * Copyright (C) 2000 Cyrille Chepelov
@@ -33,8 +33,8 @@ typedef enum {OP_AND, OP_OR, OP_XOR, OP_RISE, OP_FALL,
 
 typedef void (*BlockGetBBFunc)(Block *block, Point *relpos, Boolequation *booleq,
                               Rectangle *rect);
-typedef void (*BlockDrawFunc)(Block *block, 
-                             Boolequation *booleq, 
+typedef void (*BlockDrawFunc)(Block *block,
+                             Boolequation *booleq,
                              DiaRenderer *render);
 typedef void (*BlockDestroyFunc)(Block *block);
 
@@ -43,7 +43,7 @@ typedef struct {
   BlockDrawFunc draw;
   BlockDestroyFunc destroy;
 } BlockOps;
-  
+
 struct _Block {
   BlockType type;
   BlockOps *ops;
@@ -58,7 +58,7 @@ struct _Block {
 
 
 /* utility */
-inline static gboolean isspecial(gunichar c) 
+inline static gboolean isspecial(gunichar c)
 {
   switch (c) {
   case '!':
@@ -79,8 +79,8 @@ inline static gboolean isspecial(gunichar c)
 }
 
 /* Text block definition */
-static void 
-textblock_get_boundingbox(Block *block, Point *relpos, 
+static void
+textblock_get_boundingbox(Block *block, Point *relpos,
                          Boolequation *booleq, Rectangle *rect)
 {
   g_assert(block); g_assert(block->type == BLOCK_TEXT);
@@ -102,17 +102,19 @@ textblock_get_boundingbox(Block *block, Point *relpos,
   rect->right = block->ur.x;
 }
 
-static void 
-textblock_draw(Block *block,Boolequation *booleq,DiaRenderer *renderer)
+static void
+textblock_draw (Block *block, Boolequation *booleq, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   g_assert(block); g_assert(block->type == BLOCK_TEXT);
-  renderer_ops->set_font(renderer,booleq->font,booleq->fontheight);
-  renderer_ops->draw_string(renderer,block->d.text,
-                            &block->pos,ALIGN_LEFT,&booleq->color);
+  dia_renderer_set_font (renderer,booleq->font,booleq->fontheight);
+  dia_renderer_draw_string (renderer,
+                            block->d.text,
+                            &block->pos,
+                            ALIGN_LEFT,
+                            &booleq->color);
 }
 
-static void 
+static void
 textblock_destroy(Block *block)
 {
   if (!block) return;
@@ -125,8 +127,8 @@ static BlockOps text_block_ops = {
   textblock_get_boundingbox,
   textblock_draw,
   textblock_destroy};
-  
-static Block *textblock_create(const gchar **str) 
+
+static Block *textblock_create(const gchar **str)
 {
   const gchar *p = *str;
   Block *block;
@@ -139,7 +141,7 @@ static Block *textblock_create(const gchar **str)
     if (isspecial(c)) break;
     *str = p1;
   }
-  
+
   block = g_new0(Block,1);
   block->type = BLOCK_TEXT;
   block->ops = &text_block_ops;
@@ -183,9 +185,9 @@ opblock_get_boundingbox(Block *block, Point *relpos,
 {
   const gchar* ops;
   g_assert(block); g_assert(block->type == BLOCK_OPERATOR);
-  
+
   ops = opstring(block->d.operator);
-  
+
   block->pos = *relpos;
   block->bl.x = block->pos.x;
   block->bl.y = block->pos.y +
@@ -199,16 +201,18 @@ opblock_get_boundingbox(Block *block, Point *relpos,
   rect->right = block->ur.x;
 }
 
-static void 
-opblock_draw(Block *block, Boolequation *booleq,DiaRenderer *renderer)
+static void
+opblock_draw (Block *block, Boolequation *booleq, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   g_assert(block); g_assert(block->type == BLOCK_OPERATOR);
-  renderer_ops->set_font(renderer,booleq->font,booleq->fontheight);
-  renderer_ops->draw_string(renderer,opstring(block->d.operator),&block->pos,
-                            ALIGN_LEFT,&booleq->color);
+  dia_renderer_set_font (renderer,booleq->font,booleq->fontheight);
+  dia_renderer_draw_string (renderer,
+                            opstring (block->d.operator),
+                            &block->pos,
+                            ALIGN_LEFT,
+                            &booleq->color);
 }
-    
+
 static void opblock_destroy(Block *block)
 {
   if (!block) return;
@@ -221,7 +225,7 @@ static BlockOps operator_block_ops = {
   opblock_draw,
   opblock_destroy};
 
-static Block *opblock_create(const gchar **str) 
+static Block *opblock_create(const gchar **str)
 {
   Block *block;
   gunichar c;
@@ -233,7 +237,7 @@ static Block *opblock_create(const gchar **str)
   block->type = BLOCK_OPERATOR;
   block->ops = &operator_block_ops;
   switch(c) {
-  case '&': 
+  case '&':
   case '.':
     block->d.operator = OP_AND;
     break;
@@ -248,7 +252,7 @@ static Block *opblock_create(const gchar **str)
   case '=':
     block->d.operator = OP_EQUAL;
     break;
-  case '<': 
+  case '<':
     block->d.operator = OP_LT;
     break;
   case '>':
@@ -272,12 +276,12 @@ overlineblock_get_boundingbox(Block *block, Point *relpos,
                              Boolequation *booleq, Rectangle *rect)
 {
   g_assert(block); g_assert(block->type == BLOCK_OVERLINE);
-  
+
   block->d.inside->ops->get_boundingbox(block->d.inside,relpos,booleq,rect);
 
   block->bl = block->d.inside->bl;
   block->ur.x = block->d.inside->ur.x;
-  block->ur.y = 
+  block->ur.y =
     block->d.inside->ur.y - (3.0 * OVERLINE_RATIO * booleq->fontheight);
 
   /*rect->left = bl.x; */
@@ -286,23 +290,22 @@ overlineblock_get_boundingbox(Block *block, Point *relpos,
     rect->right = ur.x;*/
 }
 
-static void 
-overlineblock_draw(Block *block,Boolequation *booleq,DiaRenderer *renderer)
+static void
+overlineblock_draw (Block *block, Boolequation *booleq, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point ul,ur;
   g_assert(block); g_assert(block->type == BLOCK_OVERLINE);
-  block->d.inside->ops->draw(block->d.inside,booleq,renderer);
-  renderer_ops->set_linestyle(renderer,LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linewidth(renderer,booleq->fontheight * OVERLINE_RATIO);
+  block->d.inside->ops->draw (block->d.inside,booleq,renderer);
+  dia_renderer_set_linestyle (renderer,LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer,booleq->fontheight * OVERLINE_RATIO);
   ul.x = block->bl.x;
   ur.y = ul.y = block->ur.y;
 
       /* FIXME: try to get the actual block width */
   ur.x = block->ur.x -
-      (dia_font_string_width("_", booleq->font,booleq->fontheight) / 2);
-  
-  renderer_ops->draw_line(renderer,&ul,&ur,&booleq->color);
+      (dia_font_string_width ("_", booleq->font,booleq->fontheight) / 2);
+
+  dia_renderer_draw_line (renderer,&ul,&ur,&booleq->color);
 }
 
 static void
@@ -346,7 +349,7 @@ parensblock_get_boundingbox(Block *block, Point *relpos,
   pwidth = dia_font_string_width("()",booleq->font,pheight) / 2;
   temppos.x += pwidth;
   block->d.inside->ops->get_boundingbox(block->d.inside,&temppos,booleq,rect);
-  
+
   block->bl.x = block->pos.x;
   block->bl.y = block->pos.y + dia_font_descent("()",booleq->font,pheight);
   block->ur.x = block->d.inside->ur.x + pwidth;
@@ -358,26 +361,25 @@ parensblock_get_boundingbox(Block *block, Point *relpos,
   rect->right = block->ur.x;
 }
 
-static void 
-parensblock_draw(Block *block,Boolequation *booleq,DiaRenderer *renderer)
+static void
+parensblock_draw (Block *block, Boolequation *booleq, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pt;
   real pheight;
 
   g_assert(block); g_assert(block->type == BLOCK_PARENS);
 
   pheight = block->d.inside->bl.y - block->d.inside->ur.y;
-  block->d.inside->ops->draw(block->d.inside,booleq,renderer);
+  block->d.inside->ops->draw (block->d.inside,booleq,renderer);
 
-  renderer_ops->set_font(renderer,booleq->font,pheight);
+  dia_renderer_set_font (renderer,booleq->font,pheight);
   pt.y = block->pos.y;
   pt.x = block->d.inside->ur.x;
 
-  renderer_ops->draw_string(renderer,"(",&block->pos,ALIGN_LEFT,&booleq->color);
-  renderer_ops->draw_string(renderer,")",&pt,ALIGN_LEFT,&booleq->color);
+  dia_renderer_draw_string (renderer,"(",&block->pos,ALIGN_LEFT,&booleq->color);
+  dia_renderer_draw_string (renderer,")",&pt,ALIGN_LEFT,&booleq->color);
 }
- 
+
 static void
 parensblock_destroy(Block *block)
 {
@@ -391,8 +393,8 @@ static BlockOps parens_block_ops = {
   parensblock_get_boundingbox,
   parensblock_draw,
   parensblock_destroy};
-  
-static Block *parensblock_create(Block *inside) 
+
+static Block *parensblock_create(Block *inside)
 {
   Block *block;
   /* *str is already in the inside */
@@ -405,7 +407,7 @@ static Block *parensblock_create(Block *inside)
 }
 
 /* Compoundblock : */
-static void 
+static void
 compoundblock_get_boundingbox(Block *block, Point *relpos,
                              Boolequation *booleq, Rectangle *rect)
 {
@@ -427,10 +429,10 @@ compoundblock_get_boundingbox(Block *block, Point *relpos,
   while (elem) {
     inblk = (Block *)(elem->data);
     if (!inblk) break;
-    
+
     inblk->ops->get_boundingbox(inblk,&pos,booleq,&inrect);
     rectangle_union(rect,&inrect);
-    
+
     pos.x = inblk->ur.x;
 
     elem = g_slist_next(elem);
@@ -453,19 +455,19 @@ static void compoundblock_draw(Block *block,
   while (elem) {
     inblk = (Block *)(elem->data);
     if (!inblk) break;
-    
+
     inblk->ops->draw(inblk,booleq,renderer);
-    
+
     elem = g_slist_next(elem);
   }
 }
 
-static void 
+static void
 compoundblock_destroy(Block *block)
 {
   GSList *elem;
   Block *inblk;
-  
+
   if (!block) return;
   g_assert(block->type == BLOCK_COMPOUND);
 
@@ -476,7 +478,7 @@ compoundblock_destroy(Block *block)
 
     inblk->ops->destroy(inblk);
     elem->data = NULL;
-    
+
     elem = g_slist_next(elem);
   }
 
@@ -490,10 +492,10 @@ static BlockOps compound_block_ops = {
   compoundblock_destroy};
 
 static Block *
-compoundblock_create(const gchar **str) 
+compoundblock_create(const gchar **str)
 {
   Block *block, *inblk;
-  
+
   block = g_new0(Block,1);
   block->type = BLOCK_COMPOUND;
   block->ops = &compound_block_ops;
@@ -551,7 +553,7 @@ compoundblock_create(const gchar **str)
 
 
 /* Boolequation : */
-void 
+void
 boolequation_set_value(Boolequation *booleq, const gchar *value)
 {
   g_return_if_fail(booleq);
@@ -579,7 +581,7 @@ boolequation_create(const gchar *value, DiaFont *font, real fontheight,
   return booleq;
 }
 
-void 
+void
 boolequation_destroy(Boolequation *booleq)
 {
   g_return_if_fail(booleq);
@@ -596,7 +598,7 @@ save_boolequation(ObjectNode obj_node, const gchar *attrname,
   data_add_string(new_attribute(obj_node,attrname),(gchar *)booleq->value, ctx);
 }
 
-void 
+void
 boolequation_draw(Boolequation *booleq, DiaRenderer *renderer)
 {
   if (booleq->rootblock) {
@@ -610,14 +612,14 @@ void boolequation_calc_boundingbox(Boolequation *booleq, Rectangle *box)
           booleq->ascent = dia_font_ascent(booleq->font,booleq->fontheight);
           booleq->descent = dia_font_descent(booleq->font,booleq->fontheight);
         */
-          
+
   box->left = box->right = booleq->pos.x;
   box->top = box->bottom = booleq->pos.y;
 
   if (booleq->rootblock) {
     booleq->rootblock->ops->get_boundingbox(booleq->rootblock,
                                             &booleq->pos,booleq,box);
-  }  
+  }
 
   booleq->width = box->right - box->left;
   booleq->height = box->bottom - box->top;
diff --git a/objects/GRAFCET/condition.c b/objects/GRAFCET/condition.c
index 3a066f51..6787c43b 100644
--- a/objects/GRAFCET/condition.c
+++ b/objects/GRAFCET/condition.c
@@ -286,32 +286,34 @@ condition_update_data(Condition *condition)
 
 
 static void
-condition_draw(Condition *condition, DiaRenderer *renderer)
+condition_draw (Condition *condition, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Connection *conn = &condition->connection;
 
-  renderer_ops->set_linewidth(renderer, CONDITION_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, CONDITION_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (CONDITION_ARROW_SIZE > (CONDITION_LINE_WIDTH/2.0)) {
     Arrow arrow;
     arrow.type = ARROW_FILLED_TRIANGLE;
     arrow.width = CONDITION_ARROW_SIZE;
     arrow.length = CONDITION_ARROW_SIZE/2;
-    renderer_ops->draw_line_with_arrows(renderer,
-                                        &conn->endpoints[0],&conn->endpoints[1],
-                                        CONDITION_LINE_WIDTH,
-                                        &color_black,
-                                        &arrow, NULL);
+    dia_renderer_draw_line_with_arrows (renderer,
+                                        &conn->endpoints[0],
+                                        &conn->endpoints[1],
+                                        CONDITION_LINE_WIDTH,
+                                        &color_black,
+                                        &arrow,
+                                        NULL);
   } else {
-    renderer_ops->draw_line(renderer,
-                            &conn->endpoints[0],&conn->endpoints[1],
-                            &color_black);
+    dia_renderer_draw_line (renderer,
+                            &conn->endpoints[0],
+                            &conn->endpoints[1],
+                            &color_black);
   }
 
-  boolequation_draw(condition->cond,renderer);
+  boolequation_draw (condition->cond, renderer);
 }
 
 static DiaObject *
diff --git a/objects/GRAFCET/step.c b/objects/GRAFCET/step.c
index 940a8d72..beb65347 100644
--- a/objects/GRAFCET/step.c
+++ b/objects/GRAFCET/step.c
@@ -320,56 +320,64 @@ step_move(Step *step, Point *to)
 
 
 static void
-step_draw(Step *step, DiaRenderer *renderer)
+step_draw (Step *step, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pts[4];
   assert(step != NULL);
   assert(renderer != NULL);
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, STEP_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, STEP_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
   pts[0] = step->north.pos;
   pts[1] = step->NU1;
   pts[2] = step->NU2;
   pts[3] = step->A;
-  renderer_ops->draw_polyline(renderer,pts,sizeof(pts)/sizeof(pts[0]),
-                              &color_black);
+  dia_renderer_draw_polyline (renderer,
+                              pts,
+                              sizeof(pts)/sizeof(pts[0]),
+                              &color_black);
   pts[0] = step->D;
   pts[1] = step->SD1;
   pts[2] = step->SD2;
   pts[3] = step->south.pos;
-  renderer_ops->draw_polyline(renderer,pts,sizeof(pts)/sizeof(pts[0]),
-                              &color_black);
+  dia_renderer_draw_polyline (renderer,
+                              pts,
+                              sizeof(pts)/sizeof(pts[0]),
+                              &color_black);
 
   if ((step->type == STEP_INITIAL) ||
       (step->type == STEP_MACROCALL) ||
       (step->type == STEP_SUBPCALL)) {
-    renderer_ops->draw_rect(renderer, &step->I, &step->J, &color_white, &color_black);
-    renderer_ops->draw_rect(renderer, &step->E, &step->F, NULL, &color_black);
+    dia_renderer_draw_rect (renderer, &step->I, &step->J, &color_white, &color_black);
+    dia_renderer_draw_rect (renderer, &step->E, &step->F, NULL, &color_black);
   } else {
-    renderer_ops->draw_rect(renderer, &step->E, &step->F, &color_white, &color_black);
+    dia_renderer_draw_rect (renderer, &step->E, &step->F, &color_white, &color_black);
   }
 
-  if (step->type != STEP_MACROENTRY)
-    renderer_ops->draw_line(renderer,&step->A,&step->B,&color_black);
-  if (step->type != STEP_MACROEXIT)
-    renderer_ops->draw_line(renderer,&step->C,&step->D,&color_black);
-
-  renderer_ops->set_font(renderer, step->font, step->font_size);
-
-  renderer_ops->draw_string(renderer,
-                            step->id,
-                            &step->G, ALIGN_CENTER,
-                            &step->font_color);
-  if (step->active)
-    renderer_ops->draw_ellipse(renderer,
-                              &step->H,
-                              STEP_DOT_RADIUS,STEP_DOT_RADIUS,
-                              &color_red, NULL);
+  if (step->type != STEP_MACROENTRY) {
+    dia_renderer_draw_line (renderer,&step->A,&step->B,&color_black);
+  }
+  if (step->type != STEP_MACROEXIT) {
+    dia_renderer_draw_line (renderer,&step->C,&step->D,&color_black);
+  }
+
+  dia_renderer_set_font (renderer, step->font, step->font_size);
+
+  dia_renderer_draw_string (renderer,
+                            step->id,
+                            &step->G,
+                            ALIGN_CENTER,
+                            &step->font_color);
+  if (step->active) {
+    dia_renderer_draw_ellipse (renderer,
+                               &step->H,
+                               STEP_DOT_RADIUS,STEP_DOT_RADIUS,
+                               &color_red,
+                               NULL);
+  }
 }
 
 static void
diff --git a/objects/GRAFCET/transition.c b/objects/GRAFCET/transition.c
index 602e2021..af295c5d 100644
--- a/objects/GRAFCET/transition.c
+++ b/objects/GRAFCET/transition.c
@@ -336,13 +336,12 @@ transition_move(Transition *transition, Point *to)
 
 
 static void
-transition_draw(Transition *transition, DiaRenderer *renderer)
+transition_draw (Transition *transition, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pts[6];
-  renderer_ops->set_linewidth(renderer, TRANSITION_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, TRANSITION_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   pts[0] = transition->north.pos;
   pts[1] = transition->NU1;
@@ -350,14 +349,17 @@ transition_draw(Transition *transition, DiaRenderer *renderer)
   pts[3] = transition->SD1;
   pts[4] = transition->SD2;
   pts[5] = transition->south.pos;
-  renderer_ops->draw_polyline(renderer,pts,sizeof(pts)/sizeof(pts[0]),
-                              &color_black);
+  dia_renderer_draw_polyline (renderer,
+                              pts,
+                              sizeof(pts)/sizeof(pts[0]),
+                              &color_black);
 
-  renderer_ops->draw_line(renderer,
-                            &transition->C,&transition->D,
-                            &color_black);
+  dia_renderer_draw_line (renderer,
+                          &transition->C,
+                          &transition->D,
+                          &color_black);
 
-  boolequation_draw(transition->receptivity,renderer);
+  boolequation_draw (transition->receptivity,renderer);
 }
 
 static DiaObject *
diff --git a/objects/GRAFCET/vector.c b/objects/GRAFCET/vector.c
index 6d420c2f..2e83b71f 100644
--- a/objects/GRAFCET/vector.c
+++ b/objects/GRAFCET/vector.c
@@ -194,9 +194,8 @@ arc_move(Arc *arc, Point *to)
 }
 
 static void
-arc_draw(Arc *arc, DiaRenderer *renderer)
+arc_draw (Arc *arc, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &arc->orth;
   Point *points;
   int n,i;
@@ -204,26 +203,30 @@ arc_draw(Arc *arc, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, ARC_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, ARC_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  renderer_ops->draw_polyline(renderer, points, n, &color_black);
+  dia_renderer_draw_polyline (renderer, points, n, &color_black);
 
   if (arc->uparrow) {
     for (i=0;i<n-1; i++) {
       if ((points[i].y > points[i+1].y) &&
-         (ABS(points[i+1].y-points[i].y) > 5 * ARC_ARROW_LENGTH)) {
-       /* Draw an arrow on the middle of the line */
-       Point m;
-       m.x = points[i].x; /* == points[i+1].x */
-       m.y = .5 * (points[i].y + points[i+1].y) - (.5 * ARC_ARROW_LENGTH);
-       arrow_draw(renderer, ARC_ARROW_TYPE,
-                  &m,&points[i],
-                  ARC_ARROW_LENGTH, ARC_ARROW_WIDTH,
-                  ARC_LINE_WIDTH,
-                  &color_black, &color_white);
+          (ABS (points[i+1].y-points[i].y) > 5 * ARC_ARROW_LENGTH)) {
+        /* Draw an arrow on the middle of the line */
+        Point m;
+        m.x = points[i].x; /* == points[i+1].x */
+        m.y = .5 * (points[i].y + points[i+1].y) - (.5 * ARC_ARROW_LENGTH);
+        arrow_draw (renderer,
+                    ARC_ARROW_TYPE,
+                    &m,
+                    &points[i],
+                    ARC_ARROW_LENGTH,
+                    ARC_ARROW_WIDTH,
+                    ARC_LINE_WIDTH,
+                    &color_black,
+                    &color_white);
       }
     }
   }
diff --git a/objects/GRAFCET/vergent.c b/objects/GRAFCET/vergent.c
index bca8a51f..0bb24a93 100644
--- a/objects/GRAFCET/vergent.c
+++ b/objects/GRAFCET/vergent.c
@@ -237,34 +237,35 @@ vergent_move(Vergent *vergent, Point *to)
 
 
 static void
-vergent_draw(Vergent *vergent, DiaRenderer *renderer)
+vergent_draw (Vergent *vergent, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Connection *conn = &vergent->connection;
   Point p1,p2;
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   switch(vergent->type) {
-  case VERGENT_OR:
-    renderer_ops->set_linewidth(renderer, VERGENT_LINE_WIDTH);
-    renderer_ops->draw_line(renderer,
-                            &conn->endpoints[0],&conn->endpoints[1],
-                            &color_black);
-    break;
-  case VERGENT_AND:
-    renderer_ops->set_linewidth(renderer, 2.0 * VERGENT_LINE_WIDTH);
-    renderer_ops->draw_line(renderer,
-                            &conn->endpoints[0],&conn->endpoints[1],
-                            &color_white);
-    renderer_ops->set_linewidth(renderer, VERGENT_LINE_WIDTH);
-    p1.x = conn->endpoints[0].x;
-    p2.x = conn->endpoints[1].x;
-    p1.y = p2.y = conn->endpoints[0].y - VERGENT_LINE_WIDTH;
-    renderer_ops->draw_line(renderer,&p1,&p2,&color_black);
-    p1.y = p2.y = conn->endpoints[0].y + VERGENT_LINE_WIDTH;
-    renderer_ops->draw_line(renderer,&p1,&p2,&color_black);
-    break;
+    case VERGENT_OR:
+      dia_renderer_set_linewidth (renderer, VERGENT_LINE_WIDTH);
+      dia_renderer_draw_line (renderer,
+                              &conn->endpoints[0],
+                              &conn->endpoints[1],
+                              &color_black);
+      break;
+    case VERGENT_AND:
+      dia_renderer_set_linewidth (renderer, 2.0 * VERGENT_LINE_WIDTH);
+      dia_renderer_draw_line (renderer,
+                              &conn->endpoints[0],
+                              &conn->endpoints[1],
+                              &color_white);
+      dia_renderer_set_linewidth (renderer, VERGENT_LINE_WIDTH);
+      p1.x = conn->endpoints[0].x;
+      p2.x = conn->endpoints[1].x;
+      p1.y = p2.y = conn->endpoints[0].y - VERGENT_LINE_WIDTH;
+      dia_renderer_draw_line (renderer,&p1,&p2,&color_black);
+      p1.y = p2.y = conn->endpoints[0].y + VERGENT_LINE_WIDTH;
+      dia_renderer_draw_line (renderer,&p1,&p2,&color_black);
+      break;
   }
 }
 
diff --git a/objects/Istar/actor.c b/objects/Istar/actor.c
index b1fb7b45..c8f74c02 100644
--- a/objects/Istar/actor.c
+++ b/objects/Istar/actor.c
@@ -251,9 +251,8 @@ actor_move(Actor *actor, Point *to)
 
 /* drawing stuff */
 static void
-actor_draw(Actor *actor, DiaRenderer *renderer)
+actor_draw (Actor *actor, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   Point center;
   double dx,dy,r,th;
@@ -268,15 +267,19 @@ actor_draw(Actor *actor, DiaRenderer *renderer)
   center.y = elem->corner.y + elem->height/2;
 
   /* background */
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
   /* foreground */
-  renderer_ops->set_linewidth(renderer, ACTOR_BORDER_WIDTH);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->draw_ellipse(renderer, &center, elem->width, elem->height,
-                            &ACTOR_BG_COLOR, &ACTOR_FG_COLOR);
+  dia_renderer_set_linewidth (renderer, ACTOR_BORDER_WIDTH);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_draw_ellipse (renderer,
+                             &center,
+                             elem->width,
+                             elem->height,
+                             &ACTOR_BG_COLOR,
+                             &ACTOR_FG_COLOR);
 
   /* text */
-  text_draw(actor->text, renderer);
+  text_draw (actor->text, renderer);
 
   /* computing and drawing decorations */
   r  = elem->height/2.0;
@@ -294,17 +297,17 @@ actor_draw(Actor *actor, DiaRenderer *renderer)
   pi2.x=ps2.x;
   pi2.y=pi1.y;
 
-  renderer_ops->set_linewidth(renderer, ACTOR_BORDER_WIDTH);
+  dia_renderer_set_linewidth (renderer, ACTOR_BORDER_WIDTH);
   switch (actor->type) {
     case ACTOR_AGENT:
-      renderer_ops->draw_line(renderer, &ps1, &ps2, &ACTOR_FG_COLOR);
+      dia_renderer_draw_line (renderer, &ps1, &ps2, &ACTOR_FG_COLOR);
       break;
     case ACTOR_POSITION:
-      renderer_ops->draw_line(renderer, &ps1, &ps2, &ACTOR_FG_COLOR);
-      renderer_ops->draw_line(renderer, &pi1, &pi2, &ACTOR_FG_COLOR);
+      dia_renderer_draw_line (renderer, &ps1, &ps2, &ACTOR_FG_COLOR);
+      dia_renderer_draw_line (renderer, &pi1, &pi2, &ACTOR_FG_COLOR);
       break;
     case ACTOR_ROLE:
-      renderer_ops->draw_line(renderer, &pi1, &pi2, &ACTOR_FG_COLOR);
+      dia_renderer_draw_line (renderer, &pi1, &pi2, &ACTOR_FG_COLOR);
       break;
     case ACTOR_UNSPECIFIED:
       break;
diff --git a/objects/Istar/goal.c b/objects/Istar/goal.c
index 27d388ba..12d5c7d1 100644
--- a/objects/Istar/goal.c
+++ b/objects/Istar/goal.c
@@ -306,9 +306,8 @@ static void compute_cloud(Goal *goal, BezPoint* bpl) {
 
 /* drawing stuff */
 static void
-goal_draw(Goal *goal, DiaRenderer *renderer)
+goal_draw (Goal *goal, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point p1,p2;
   BezPoint bpl[5];
   Element *elem;
@@ -319,26 +318,29 @@ goal_draw(Goal *goal, DiaRenderer *renderer)
 
   elem = &goal->element;
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linewidth(renderer, GOAL_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, GOAL_LINE_WIDTH);
 
   if (goal->type==GOAL) {  /* goal */
     p1.x=elem->corner.x;
     p1.y= elem->corner.y;
     p2.x=p1.x+elem->width;
     p2.y=p1.y+elem->height;
-    renderer_ops->draw_rounded_rect (renderer,&p1,&p2,
-                                    &GOAL_BG_COLOR, &GOAL_FG_COLOR,
-                                    elem->height/2.0);
+    dia_renderer_draw_rounded_rect (renderer,
+                                    &p1,
+                                    &p2,
+                                    &GOAL_BG_COLOR,
+                                    &GOAL_FG_COLOR,
+                                    elem->height/2.0);
   } else {                 /* softgoal */
-     compute_cloud(goal,bpl);
-     renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-     renderer_ops->draw_beziergon(renderer,bpl,5,&GOAL_BG_COLOR,&GOAL_FG_COLOR);
+    compute_cloud (goal,bpl);
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+    dia_renderer_draw_beziergon (renderer, bpl, 5, &GOAL_BG_COLOR, &GOAL_FG_COLOR);
   }
 
   /* drawing text */
-  text_draw(goal->text, renderer);
+  text_draw (goal->text, renderer);
 }
 
 static void
diff --git a/objects/Istar/link.c b/objects/Istar/link.c
index 42e0c1a5..40129bac 100644
--- a/objects/Istar/link.c
+++ b/objects/Istar/link.c
@@ -451,9 +451,8 @@ compute_line(Point* p1, Point* p2, Point *pm, BezPoint* line) {
 
 /* drawing here -- TBD inverse flow ??  */
 static void
-link_draw(Link *link, DiaRenderer *renderer)
+link_draw (Link *link, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints, p1, p2, pa;
   Arrow arrow;
   gchar *annot;
@@ -503,21 +502,28 @@ link_draw(Link *link, DiaRenderer *renderer)
   }
 
   /** drawing line **/
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linewidth(renderer, w);
-  renderer_ops->draw_bezier_with_arrows(renderer, link->line, 3, w, &LINK_FG_COLOR, NULL, &arrow);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, w);
+  dia_renderer_draw_bezier_with_arrows (renderer,
+                                        link->line,
+                                        3,
+                                        w,
+                                        &LINK_FG_COLOR,
+                                        NULL,
+                                        &arrow);
 
   /** drawing decoration **/
-  renderer_ops->set_font(renderer, link_font, LINK_FONTHEIGHT);
-  if ((annot!=NULL)&& strlen(annot) != 0)
-    renderer_ops->draw_string(renderer, annot, &pa, ALIGN_CENTER, &color_black);
+  dia_renderer_set_font (renderer, link_font, LINK_FONTHEIGHT);
+  if ((annot != NULL) && strlen (annot) != 0) {
+    dia_renderer_draw_string (renderer, annot, &pa, ALIGN_CENTER, &color_black);
+  }
   if (annot!=NULL) g_free(annot);
 
   /** special stuff for dependency **/
-  if (link->type==DEPENDENCY) {
-    compute_dependency(link->line,bpl);
-    renderer_ops->draw_bezier(renderer, bpl, 4, &LINK_FG_COLOR);
+  if (link->type == DEPENDENCY) {
+    compute_dependency (link->line,bpl);
+    dia_renderer_draw_bezier (renderer, bpl, 4, &LINK_FG_COLOR);
   }
 }
 
diff --git a/objects/Istar/other.c b/objects/Istar/other.c
index 9344bbda..54d1baf9 100644
--- a/objects/Istar/other.c
+++ b/objects/Istar/other.c
@@ -286,9 +286,8 @@ static void compute_task(Other *other, Point *pl) {
 
 /* drawing stuff */
 static void
-other_draw(Other *other, DiaRenderer *renderer)
+other_draw (Other *other, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pl[6],p1,p2;
   Element *elem;
 
@@ -298,8 +297,8 @@ other_draw(Other *other, DiaRenderer *renderer)
 
   elem = &other->element;
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
   switch (other->type) {
     case RESOURCE:
@@ -307,19 +306,19 @@ other_draw(Other *other, DiaRenderer *renderer)
       p1.y= elem->corner.y;
       p2.x=p1.x+elem->width;
       p2.y=p1.y+elem->height;
-      renderer_ops->set_linewidth(renderer, OTHER_LINE_WIDTH);
-      renderer_ops->draw_rect(renderer,&p1,&p2, &OTHER_BG_COLOR, &OTHER_FG_COLOR);
+      dia_renderer_set_linewidth (renderer, OTHER_LINE_WIDTH);
+      dia_renderer_draw_rect (renderer,&p1,&p2, &OTHER_BG_COLOR, &OTHER_FG_COLOR);
       break;
     case TASK:
-      compute_task(other,pl);
-      renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-      renderer_ops->set_linewidth(renderer, OTHER_LINE_WIDTH);
-      renderer_ops->draw_polygon(renderer, pl, 6, &OTHER_BG_COLOR, &OTHER_FG_COLOR);
+      compute_task (other, pl);
+      dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+      dia_renderer_set_linewidth (renderer, OTHER_LINE_WIDTH);
+      dia_renderer_draw_polygon (renderer, pl, 6, &OTHER_BG_COLOR, &OTHER_FG_COLOR);
       break;
   }
 
   /* drawing text */
-  text_draw(other->text, renderer);
+  text_draw (other->text, renderer);
 }
 
 static void
diff --git a/objects/Jackson/domain.c b/objects/Jackson/domain.c
index 878b81d2..bd0c62c7 100644
--- a/objects/Jackson/domain.c
+++ b/objects/Jackson/domain.c
@@ -314,9 +314,8 @@ jackson_box_move(Box *box, Point *to)
 
 /* draw method */
 static void
-jackson_box_draw(Box *box, DiaRenderer *renderer)
+jackson_box_draw (Box *box, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point b0,b1,b2,b3,p1t,p1b,p2t,p2b;
   Element *elem;
   real idfontheight;
@@ -345,26 +344,26 @@ jackson_box_draw(Box *box, DiaRenderer *renderer)
   p2b.y= p1b.y;
 
   /* drawing main box */
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
 
-  renderer_ops->set_linewidth(renderer, JACKSON_BOX_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, JACKSON_BOX_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  renderer_ops->draw_rect(renderer, &b0, &b1, &JACKSON_BOX_BG_COLOR, &JACKSON_BOX_FG_COLOR);
+  dia_renderer_draw_rect (renderer, &b0, &b1, &JACKSON_BOX_BG_COLOR, &JACKSON_BOX_FG_COLOR);
 
   /* adding lines for designed/machine domains */
   if (box->domtype!=DOMAIN_GIVEN) {
-      renderer_ops->draw_line(renderer, &p1t, &p1b, &JACKSON_BOX_FG_COLOR);
+    dia_renderer_draw_line (renderer, &p1t, &p1b, &JACKSON_BOX_FG_COLOR);
   }
 
   if (box->domtype==DOMAIN_MACHINE) {
-      renderer_ops->draw_line(renderer, &p2t, &p2b, &JACKSON_BOX_FG_COLOR);
+    dia_renderer_draw_line (renderer, &p2t, &p2b, &JACKSON_BOX_FG_COLOR);
   }
 
   /* adding corner for optional qualifier */
   idfontheight = box->text->height;
-  renderer_ops->set_font(renderer, box->text->font, idfontheight);
+  dia_renderer_set_font (renderer, box->text->font, idfontheight);
   b2 = b3 = b1;
   b2.x -= .2 * idfontheight;
   b2.y -= .2 * idfontheight;
@@ -378,12 +377,12 @@ jackson_box_draw(Box *box, DiaRenderer *renderer)
     default: s=NULL;
   }
 
-  if (s!=NULL) {
-    renderer_ops->draw_rect(renderer, &b3, &b1, NULL, &JACKSON_BOX_FG_COLOR);
-    renderer_ops->draw_string(renderer, s, &b2, ALIGN_RIGHT, &box->text->color);
+  if (s != NULL) {
+    dia_renderer_draw_rect (renderer, &b3, &b1, NULL, &JACKSON_BOX_FG_COLOR);
+    dia_renderer_draw_string (renderer, s, &b2, ALIGN_RIGHT, &box->text->color);
   }
 
-  text_draw(box->text, renderer);
+  text_draw (box->text, renderer);
 }
 
 /* resize stuff */
diff --git a/objects/Jackson/phenomenon.c b/objects/Jackson/phenomenon.c
index 14808d43..ceaecc4e 100644
--- a/objects/Jackson/phenomenon.c
+++ b/objects/Jackson/phenomenon.c
@@ -254,13 +254,12 @@ message_move(Message *message, Point *to)
 
 /* drawing here -- TBD inverse flow ??  */
 static void
-message_draw(Message *message, DiaRenderer *renderer)
+message_draw (Message *message, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints, p1, p2;
   Arrow arrow;
   int n1 = 1, n2 = 0;
-  gchar *mname = g_strdup(message->text);
+  gchar *mname = g_strdup (message->text);
 
   /* some asserts */
   assert(message != NULL);
@@ -269,15 +268,15 @@ message_draw(Message *message, DiaRenderer *renderer)
   /* arrow type */
   endpoints = &message->connection.endpoints[0];
 
-  renderer_ops->set_linewidth(renderer, MESSAGE_WIDTH);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, MESSAGE_WIDTH);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (message->type==MSG_REQ) {
-      renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, MESSAGE_DASHLEN);
-      arrow.type = ARROW_FILLED_TRIANGLE;
+    dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, MESSAGE_DASHLEN);
+    arrow.type = ARROW_FILLED_TRIANGLE;
   } else {
-      renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-      arrow.type = ARROW_NONE;
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+    arrow.type = ARROW_NONE;
   }
 
   arrow.length = MESSAGE_ARROWLEN;
@@ -288,15 +287,22 @@ message_draw(Message *message, DiaRenderer *renderer)
   p2 = endpoints[n2];
 
   /* drawing directed line */
-  renderer_ops->draw_line_with_arrows(renderer, &p1, &p2, MESSAGE_WIDTH, &color_black, &arrow, NULL);
+  dia_renderer_draw_line_with_arrows (renderer,
+                                      &p1,
+                                      &p2,
+                                      MESSAGE_WIDTH,
+                                      &color_black,
+                                      &arrow,
+                                      NULL);
 
   /* writing text on arrow (maybe not a good idea) */
-  renderer_ops->set_font(renderer, message_font, MESSAGE_FONTHEIGHT);
+  dia_renderer_set_font (renderer, message_font, MESSAGE_FONTHEIGHT);
 
-  if (mname && strlen(mname) != 0)
-      renderer_ops->draw_string(renderer, mname, &message->text_pos, ALIGN_CENTER, &color_black);
+  if (mname && strlen (mname) != 0) {
+    dia_renderer_draw_string (renderer, mname, &message->text_pos, ALIGN_CENTER, &color_black);
+  }
 
-  if (mname) g_free(mname);
+  if (mname) g_free (mname);
 }
 
 /* creation here */
diff --git a/objects/Jackson/requirement.c b/objects/Jackson/requirement.c
index 416df574..372f0262 100644
--- a/objects/Jackson/requirement.c
+++ b/objects/Jackson/requirement.c
@@ -217,9 +217,8 @@ req_move(Requirement *req, Point *to)
 
 /** draw is here */
 static void
-req_draw(Requirement *req, DiaRenderer *renderer)
+req_draw (Requirement *req, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point c;
@@ -237,14 +236,14 @@ req_draw(Requirement *req, DiaRenderer *renderer)
   c.x = x + w/2.0;
   c.y = y + h/2.0;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, REQ_LINEWIDTH);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, REQ_LINEWIDTH);
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, REQ_DASHLEN);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, REQ_DASHLEN);
 
-  renderer_ops->draw_ellipse(renderer, &c, w, h, &color_white, &color_black);
+  dia_renderer_draw_ellipse (renderer, &c, w, h, &color_white, &color_black);
 
-  text_draw(req->text, renderer);
+  text_draw (req->text, renderer);
 }
 
 
diff --git a/objects/KAOS/goal.c b/objects/KAOS/goal.c
index 36ac79ac..67e78205 100644
--- a/objects/KAOS/goal.c
+++ b/objects/KAOS/goal.c
@@ -350,9 +350,8 @@ static void compute_cloud(Goal *goal, BezPoint* bpl) {
 
 /* drawing stuff */
 static void
-goal_draw(Goal *goal, DiaRenderer *renderer)
+goal_draw (Goal *goal, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   double dx,ix;
   Point pl[4],p1,p2;
   BezPoint bpl[9];
@@ -392,39 +391,41 @@ goal_draw(Goal *goal, DiaRenderer *renderer)
       break;
   }
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  if (goal->type!=SOFTGOAL) {
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  if (goal->type != SOFTGOAL) {
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
 
-    if ((goal->type==REQUIREMENT) || (goal->type==ASSUMPTION)) {
-      renderer_ops->set_linewidth(renderer, GOAL_LINE_DOUBLE_WIDTH);
+    if ((goal->type == REQUIREMENT) || (goal->type == ASSUMPTION)) {
+      dia_renderer_set_linewidth (renderer, GOAL_LINE_DOUBLE_WIDTH);
     } else {
-      renderer_ops->set_linewidth(renderer, GOAL_LINE_SIMPLE_WIDTH);
+      dia_renderer_set_linewidth (renderer, GOAL_LINE_SIMPLE_WIDTH);
     }
 
-    renderer_ops->draw_polygon(renderer, pl, 4, &GOAL_BG_COLOR, &GOAL_FG_COLOR);
+    dia_renderer_draw_polygon (renderer, pl, 4, &GOAL_BG_COLOR, &GOAL_FG_COLOR);
 
     /* adding decoration for assumption */
-    if (goal->type==ASSUMPTION) {
+    if (goal->type == ASSUMPTION) {
       dx=GOAL_OFFSET+elem->height/10;
-      if (dx+GOAL_OFFSET>elem->height) dx=elem->height-GOAL_OFFSET; /* min size */
+      if (dx + GOAL_OFFSET > elem->height) {
+        dx=elem->height-GOAL_OFFSET; /* min size */
+      }
       p1.x=elem->corner.x+ GOAL_OFFSET + dx;
       p1.y=elem->corner.y;
       ix=GOAL_OFFSET*(GOAL_OFFSET+dx-elem->height)/(GOAL_OFFSET-elem->height);
       p2.x=elem->corner.x+ix;
       p2.y=elem->corner.y+GOAL_OFFSET+dx-ix;
-      renderer_ops->draw_line(renderer,&p1,&p2,&GOAL_FG_COLOR);
+      dia_renderer_draw_line (renderer, &p1, &p2, &GOAL_FG_COLOR);
     }
   } else { /* SOFTGOAL IS HERE */
-     compute_cloud(goal,bpl);
-     renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-     renderer_ops->draw_beziergon(renderer,bpl,9,&GOAL_BG_COLOR,&GOAL_FG_COLOR);
+    compute_cloud (goal,bpl);
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+    dia_renderer_draw_beziergon (renderer, bpl, 9, &GOAL_BG_COLOR, &GOAL_FG_COLOR);
   }
 
   /* drawing text */
-  text_draw(goal->text, renderer);
+  text_draw (goal->text, renderer);
 }
 
 static void
diff --git a/objects/KAOS/metaandorrel.c b/objects/KAOS/metaandorrel.c
index 68a7a94c..acc7da10 100644
--- a/objects/KAOS/metaandorrel.c
+++ b/objects/KAOS/metaandorrel.c
@@ -371,56 +371,56 @@ static void compute_oper(Point *p, double w, double h, Point *pl) {
 }
 
 static void
-draw_agent_icon(Maor *maor, double w, double h,
-               DiaRenderer *renderer)
+draw_agent_icon (Maor        *maor,
+                 double       w,
+                 double       h,
+                 DiaRenderer *renderer)
 {
-     DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-     double rx,ry;
-     Point ref,c,p1,p2;
-
-     ref=maor->connection.endpoints[0];
-     rx=ref.x;
-     ry=ref.y-h*0.2;
-
-     /* head */
-     c.x=rx;
-     c.y=ry;
-     renderer_ops->draw_ellipse(renderer,&c,h/5,h/5,&MAOR_FG_COLOR, NULL);
-
-     /* body */
-     p1.x=rx;
-     p1.y=ry;
-     p2.x=p1.x;
-     p2.y=p1.y+3.5*h/10;
-     renderer_ops->draw_line(renderer,&p1,&p2,&MAOR_FG_COLOR);
-
-     /* arms */
-     p1.x=rx-1.5*h/10;
-     p1.y=ry+2.2*h/10;
-     p2.x=rx+1.5*h/10;
-     p2.y=p1.y;
-     renderer_ops->draw_line(renderer,&p1,&p2,&MAOR_FG_COLOR);
-
-     /* left leg */
-     p1.x=rx;
-     p1.y=ry+3.5*h/10;
-     p2.x=p1.x-h/10;
-     p2.y=p1.y+2*h/10;
-     renderer_ops->draw_line(renderer,&p1,&p2,&MAOR_FG_COLOR);
-
-     /* right leg */
-     p1.x=rx;
-     p1.y=ry+3.5*h/10;
-     p2.x=p1.x+h/10;
-     p2.y=p1.y+2*h/10;
-     renderer_ops->draw_line(renderer,&p1,&p2,&MAOR_FG_COLOR);
+  double rx,ry;
+  Point ref,c,p1,p2;
+
+  ref=maor->connection.endpoints[0];
+  rx=ref.x;
+  ry=ref.y-h*0.2;
+
+  /* head */
+  c.x=rx;
+  c.y=ry;
+  dia_renderer_draw_ellipse (renderer,&c,h/5,h/5,&MAOR_FG_COLOR, NULL);
+
+  /* body */
+  p1.x=rx;
+  p1.y=ry;
+  p2.x=p1.x;
+  p2.y=p1.y+3.5*h/10;
+  dia_renderer_draw_line (renderer,&p1,&p2,&MAOR_FG_COLOR);
+
+  /* arms */
+  p1.x=rx-1.5*h/10;
+  p1.y=ry+2.2*h/10;
+  p2.x=rx+1.5*h/10;
+  p2.y=p1.y;
+  dia_renderer_draw_line (renderer,&p1,&p2,&MAOR_FG_COLOR);
+
+  /* left leg */
+  p1.x=rx;
+  p1.y=ry+3.5*h/10;
+  p2.x=p1.x-h/10;
+  p2.y=p1.y+2*h/10;
+  dia_renderer_draw_line (renderer,&p1,&p2,&MAOR_FG_COLOR);
+
+  /* right leg */
+  p1.x=rx;
+  p1.y=ry+3.5*h/10;
+  p2.x=p1.x+h/10;
+  p2.y=p1.y+2*h/10;
+  dia_renderer_draw_line (renderer,&p1,&p2,&MAOR_FG_COLOR);
 }
 
 /* drawing here -- TBD inverse flow ??  */
 static void
-maor_draw(Maor *maor, DiaRenderer *renderer)
+maor_draw (Maor *maor, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints, p1, p2;
   Arrow arrow;
   BezPoint bpl[6];
@@ -443,49 +443,48 @@ maor_draw(Maor *maor, DiaRenderer *renderer)
   p2 = endpoints[1];
 
   /** drawing directed line **/
-  renderer_ops->set_linewidth(renderer, MAOR_WIDTH);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0);
-  renderer_ops->draw_line_with_arrows(renderer,&p1,&p2,MAOR_WIDTH,&MAOR_FG_COLOR,NULL,&arrow);
+  dia_renderer_set_linewidth (renderer, MAOR_WIDTH);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0);
+  dia_renderer_draw_line_with_arrows (renderer,&p1,&p2,MAOR_WIDTH,&MAOR_FG_COLOR,NULL,&arrow);
 
   /** drawing vector decoration  **/
   /* and ref */
   switch (maor->type) {
     case MAOR_AND_REF:
-      compute_and(&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
-      renderer_ops->draw_beziergon(renderer,bpl,6,&MAOR_BG_COLOR,&MAOR_FG_COLOR);
+      compute_and (&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
+      dia_renderer_draw_beziergon (renderer,bpl,6,&MAOR_BG_COLOR,&MAOR_FG_COLOR);
       break;
 
     case MAOR_AND_COMP_REF:
-      compute_and(&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
-      renderer_ops->draw_beziergon(renderer,bpl,6,&MAOR_FG_COLOR,NULL);
+      compute_and (&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
+      dia_renderer_draw_beziergon (renderer,bpl,6,&MAOR_FG_COLOR,NULL);
       break;
 
     case MAOR_OR_REF:
-      compute_or(&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
-      renderer_ops->draw_beziergon(renderer,bpl,4,&MAOR_BG_COLOR,&MAOR_FG_COLOR);
+      compute_or (&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
+      dia_renderer_draw_beziergon (renderer,bpl,4,&MAOR_BG_COLOR,&MAOR_FG_COLOR);
       break;
 
     case MAOR_OR_COMP_REF:
-      compute_or(&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
-      renderer_ops->draw_beziergon(renderer,bpl,4,&MAOR_FG_COLOR,NULL);
+      compute_or (&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,bpl);
+      dia_renderer_draw_beziergon (renderer,bpl,4,&MAOR_FG_COLOR,NULL);
       break;
 
     case MAOR_OPER_REF:
-      compute_oper(&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,pl);
-      renderer_ops->draw_polygon(renderer,pl,7,&MAOR_BG_COLOR,&MAOR_FG_COLOR);
-      draw_agent_icon(maor,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,renderer);
+      compute_oper (&p1,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,pl);
+      dia_renderer_draw_polygon (renderer,pl,7,&MAOR_BG_COLOR,&MAOR_FG_COLOR);
+      draw_agent_icon (maor,MAOR_REF_WIDTH,MAOR_REF_HEIGHT,renderer);
       break;
   }
 
   /** writing text on arrow (maybe not a good idea) **/
-  renderer_ops->set_font(renderer,maor_font,MAOR_FONTHEIGHT);
+  dia_renderer_set_font (renderer,maor_font,MAOR_FONTHEIGHT);
 
-  if (mname && strlen(mname) != 0)
-      renderer_ops->draw_string(renderer,mname,&maor->text_pos, ALIGN_CENTER,&color_black);
+  if (mname && strlen (mname) != 0)
+    dia_renderer_draw_string (renderer,mname,&maor->text_pos, ALIGN_CENTER,&color_black);
 
   if (mname) g_free(mname);
-
 }
 
 /* creation here */
diff --git a/objects/KAOS/metabinrel.c b/objects/KAOS/metabinrel.c
index bdaa31d8..cadb8706 100644
--- a/objects/KAOS/metabinrel.c
+++ b/objects/KAOS/metabinrel.c
@@ -348,9 +348,8 @@ static gchar* compute_text(Mbr *mbr) {
 
 /* drawing here -- TBD inverse flow ??  */
 static void
-mbr_draw(Mbr *mbr, DiaRenderer *renderer)
+mbr_draw (Mbr *mbr, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints;
   Point p1,p2,pm1,pm2;
   Point pa1,pa2;
@@ -363,10 +362,11 @@ mbr_draw(Mbr *mbr, DiaRenderer *renderer)
   assert(renderer != NULL);
 
   /* arrow type */
-  if (mbr->type!=MBR_CONFLICTS)
+  if (mbr->type!=MBR_CONFLICTS) {
     arrow.type = ARROW_FILLED_TRIANGLE;
-  else
+  } else {
     arrow.type = ARROW_NONE;
+  }
   arrow.length = MBR_ARROWLEN;
   arrow.width = MBR_ARROWWIDTH;
 
@@ -377,18 +377,18 @@ mbr_draw(Mbr *mbr, DiaRenderer *renderer)
   p2 = endpoints[1];
 
   /** drawing directed line **/
-  renderer_ops->set_linewidth(renderer, MBR_WIDTH);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, MBR_WIDTH);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   dx=p1.x-p2.x;
   dy=p1.y-p2.y;
   k=sqrt(dx*dx+dy*dy)*2/MBR_DEC_SIZE;
 
   if (k<0.05) {  /* bug fix for closed bezier */
-    renderer_ops->draw_line_with_arrows(renderer,&p1,&p2,MBR_WIDTH,&MBR_FG_COLOR,NULL, &arrow);
+    dia_renderer_draw_line_with_arrows (renderer,&p1,&p2,MBR_WIDTH,&MBR_FG_COLOR,NULL, &arrow);
   } else {
-    renderer_ops->draw_bezier_with_arrows(renderer, mbr->line, 3, MBR_WIDTH, &MBR_FG_COLOR, NULL, &arrow);
+    dia_renderer_draw_bezier_with_arrows (renderer, mbr->line, 3, MBR_WIDTH, &MBR_FG_COLOR, NULL, &arrow);
   }
 
   /** drawing vector decoration  **/
@@ -406,8 +406,8 @@ mbr_draw(Mbr *mbr, DiaRenderer *renderer)
     pm2.x=mbr->pm.x+dxp;
     pm2.y=mbr->pm.y+dyp;
 
-    renderer_ops->set_linewidth(renderer, MBR_WIDTH*2);
-    renderer_ops->draw_line_with_arrows(renderer,&pm1,&pm2,MBR_WIDTH,&MBR_RED_COLOR,NULL,NULL);
+    dia_renderer_set_linewidth (renderer, MBR_WIDTH*2);
+    dia_renderer_draw_line_with_arrows (renderer,&pm1,&pm2,MBR_WIDTH,&MBR_RED_COLOR,NULL,NULL);
   }
 
   if (mbr->type==MBR_CONFLICTS) {
@@ -416,32 +416,32 @@ mbr_draw(Mbr *mbr, DiaRenderer *renderer)
     pm2.x=mbr->pm.x+dxn+dxp;
     pm2.y=mbr->pm.y+dyn+dyp;
 
-    renderer_ops->set_linewidth(renderer, MBR_WIDTH*2);
-    renderer_ops->draw_line_with_arrows(renderer,&pm1,&pm2,MBR_WIDTH,&MBR_RED_COLOR,NULL,NULL);
+    dia_renderer_set_linewidth (renderer, MBR_WIDTH*2);
+    dia_renderer_draw_line_with_arrows (renderer,&pm1,&pm2,MBR_WIDTH,&MBR_RED_COLOR,NULL,NULL);
 
     pm1.x=mbr->pm.x-dxn+dxp;
     pm1.y=mbr->pm.y-dyn+dyp;
     pm2.x=mbr->pm.x+dxn-dxp;
     pm2.y=mbr->pm.y+dyn-dyp;
 
-    renderer_ops->draw_line_with_arrows(renderer,&pm1,&pm2,MBR_WIDTH,&MBR_RED_COLOR,NULL,NULL);
+    dia_renderer_draw_line_with_arrows (renderer,&pm1,&pm2,MBR_WIDTH,&MBR_RED_COLOR,NULL,NULL);
   }
 
 
   /** writing decoration text **/
-  annot=compute_text(mbr);
-  renderer_ops->set_font(renderer, mbr_font, MBR_DECFONTHEIGHT);
+  annot = compute_text (mbr);
+  dia_renderer_set_font (renderer, mbr_font, MBR_DECFONTHEIGHT);
 
   if (annot && strlen(annot) != 0) {
-      pa1.x=mbr->pm.x-mbr->text_width/2;
-      pa1.y=mbr->pm.y-mbr->text_ascent +0.1;  /* with some fix... */
-      pa2.x=pa1.x+mbr->text_width;
-      pa2.y=pa1.y+MBR_DECFONTHEIGHT    +0.1;  /* with some fix... */
-      renderer_ops->draw_rect(renderer,&pa1,&pa2,&color_white, NULL);
-      renderer_ops->draw_string(renderer,annot,&mbr->pm,ALIGN_CENTER,&MBR_FG_COLOR);
+    pa1.x=mbr->pm.x-mbr->text_width/2;
+    pa1.y=mbr->pm.y-mbr->text_ascent +0.1;  /* with some fix... */
+    pa2.x=pa1.x+mbr->text_width;
+    pa2.y=pa1.y+MBR_DECFONTHEIGHT    +0.1;  /* with some fix... */
+    dia_renderer_draw_rect (renderer,&pa1,&pa2,&color_white, NULL);
+    dia_renderer_draw_string (renderer,annot,&mbr->pm,ALIGN_CENTER,&MBR_FG_COLOR);
   }
 
-  g_free(annot);
+  g_free (annot);
 }
 
 /* creation here */
diff --git a/objects/KAOS/other.c b/objects/KAOS/other.c
index a28648f2..d8429066 100644
--- a/objects/KAOS/other.c
+++ b/objects/KAOS/other.c
@@ -289,81 +289,79 @@ static void compute_agent(Other *other, Point *pl) {
 }
 
 static void
-draw_agent_icon(Other *other, DiaRenderer *renderer)
+draw_agent_icon (Other *other, DiaRenderer *renderer)
 {
-     DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-     double rx,ry,h;
-     Point c,p1,p2;
-     Element *elem;
+  double rx,ry,h;
+  Point c,p1,p2;
+  Element *elem;
 
-     elem=&other->element;
-     h=elem->height;
-     rx=elem->corner.x+h/2;
-     ry=elem->corner.y+3*h/10;
-
-     /* head */
-     c.x=rx;
-     c.y=ry;
-     renderer_ops->draw_ellipse(renderer,&c,h/5,h/5,&OTHER_FG_COLOR, NULL);
-
-     /* body */
-     p1.x=rx;
-     p1.y=ry;
-     p2.x=p1.x;
-     p2.y=p1.y+3.5*h/10;
-     renderer_ops->draw_line(renderer,&p1,&p2,&OTHER_FG_COLOR);
-
-     /* arms */
-     p1.x=rx-1.5*h/10;
-     p1.y=ry+2.2*h/10;
-     p2.x=rx+1.5*h/10;
-     p2.y=p1.y;
-     renderer_ops->draw_line(renderer,&p1,&p2,&OTHER_FG_COLOR);
-
-     /* left leg */
-     p1.x=rx;
-     p1.y=ry+3.5*h/10;
-     p2.x=p1.x-h/10;
-     p2.y=p1.y+2*h/10;
-     renderer_ops->draw_line(renderer,&p1,&p2,&OTHER_FG_COLOR);
-
-     /* right leg */
-     p1.x=rx;
-     p1.y=ry+3.5*h/10;
-     p2.x=p1.x+h/10;
-     p2.y=p1.y+2*h/10;
-     renderer_ops->draw_line(renderer,&p1,&p2,&OTHER_FG_COLOR);
+  elem=&other->element;
+  h=elem->height;
+  rx=elem->corner.x+h/2;
+  ry=elem->corner.y+3*h/10;
+
+  /* head */
+  c.x=rx;
+  c.y=ry;
+  dia_renderer_draw_ellipse (renderer, &c, h/5, h/5, &OTHER_FG_COLOR, NULL);
+
+  /* body */
+  p1.x=rx;
+  p1.y=ry;
+  p2.x=p1.x;
+  p2.y=p1.y+3.5*h/10;
+  dia_renderer_draw_line (renderer, &p1, &p2, &OTHER_FG_COLOR);
+
+  /* arms */
+  p1.x=rx-1.5*h/10;
+  p1.y=ry+2.2*h/10;
+  p2.x=rx+1.5*h/10;
+  p2.y=p1.y;
+  dia_renderer_draw_line (renderer, &p1, &p2, &OTHER_FG_COLOR);
+
+  /* left leg */
+  p1.x=rx;
+  p1.y=ry+3.5*h/10;
+  p2.x=p1.x-h/10;
+  p2.y=p1.y+2*h/10;
+  dia_renderer_draw_line (renderer, &p1, &p2, &OTHER_FG_COLOR);
+
+  /* right leg */
+  p1.x=rx;
+  p1.y=ry+3.5*h/10;
+  p2.x=p1.x+h/10;
+  p2.y=p1.y+2*h/10;
+  dia_renderer_draw_line (renderer, &p1, &p2, &OTHER_FG_COLOR);
 }
 
 /* drawing stuff */
 static void
-other_draw(Other *other, DiaRenderer *renderer)
+other_draw (Other *other, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pl[6];
 
   /* some asserts */
   assert(other != NULL);
   assert(renderer != NULL);
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
   if (other->type==AGENT) {
-    compute_agent(other,pl);
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-    renderer_ops->set_linewidth(renderer, OTHER_LINE_SIMPLE_WIDTH);
-    renderer_ops->draw_polygon(renderer,
-                          pl,
-                          6,
-                          &OTHER_BG_COLOR,
-                          &OTHER_FG_COLOR);
-
-    draw_agent_icon(other,renderer);
+    compute_agent (other,pl);
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+    dia_renderer_set_linewidth (renderer, OTHER_LINE_SIMPLE_WIDTH);
+    dia_renderer_draw_polygon (renderer,
+                               pl,
+                               6,
+                               &OTHER_BG_COLOR,
+                               &OTHER_FG_COLOR);
+
+    draw_agent_icon (other,renderer);
   }
 
   /* drawing text */
-  text_draw(other->text, renderer);
+  text_draw (other->text, renderer);
 }
 
 static void
diff --git a/objects/Misc/analog_clock.c b/objects/Misc/analog_clock.c
index 433f1161..07055d0f 100644
--- a/objects/Misc/analog_clock.c
+++ b/objects/Misc/analog_clock.c
@@ -309,63 +309,64 @@ analog_clock_update_data(Analog_Clock *analog_clock)
 }
 
 static void
-analog_clock_draw(Analog_Clock *analog_clock, DiaRenderer *renderer)
+analog_clock_draw (Analog_Clock *analog_clock, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-
   g_assert(analog_clock != NULL);
   g_assert(renderer != NULL);
 
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0);
-  renderer_ops->set_linewidth(renderer, analog_clock->border_line_width);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0);
+  dia_renderer_set_linewidth (renderer, analog_clock->border_line_width);
 
-  renderer_ops->draw_ellipse(renderer,&analog_clock->centre,
-                             2*analog_clock->radius,2*analog_clock->radius,
-                             (analog_clock->show_background) ? &analog_clock->inner_color : NULL,
-                             &analog_clock->border_color);
-  if (analog_clock->show_ticks)
-  {
+  dia_renderer_draw_ellipse (renderer,
+                             &analog_clock->centre,
+                             2*analog_clock->radius,2*analog_clock->radius,
+                             (analog_clock->show_background) ? &analog_clock->inner_color : NULL,
+                             &analog_clock->border_color);
+  if (analog_clock->show_ticks) {
     Point out, in;
     unsigned i;
 
     for (i = 0; i < 12; ++i) {
       real ticklen;
       switch(i) {
-          case 0:
-            ticklen = 3.5 * analog_clock->border_line_width; break;
-          case 3: case 6: case 9:
-            ticklen = 3 * analog_clock->border_line_width; break;
-          default:
-            ticklen = 2 * analog_clock->border_line_width; break;
+        case 0:
+          ticklen = 3.5 * analog_clock->border_line_width; break;
+        case 3: case 6: case 9:
+          ticklen = 3 * analog_clock->border_line_width; break;
+        default:
+          ticklen = 2 * analog_clock->border_line_width; break;
       }
-      make_hours(&analog_clock->centre, i, 0,
-                 analog_clock->radius, &out);
-      make_hours(&analog_clock->centre, i, 0,
-                 analog_clock->radius-ticklen, &in);
-      renderer_ops->draw_line(renderer,&out,&in,&analog_clock->border_color);
+      make_hours (&analog_clock->centre, i, 0,
+                  analog_clock->radius, &out);
+      make_hours (&analog_clock->centre, i, 0,
+                  analog_clock->radius-ticklen, &in);
+      dia_renderer_draw_line (renderer, &out, &in, &analog_clock->border_color);
     }
   }
 
-  analog_clock_update_arrow_tips(analog_clock);
-
-  renderer_ops->set_linewidth(renderer, analog_clock->arrow_line_width);
-  renderer_ops->draw_line(renderer,
-                           &analog_clock->hour_tip.pos, &analog_clock->centre,
-                           &analog_clock->arrow_color);
-  renderer_ops->draw_line(renderer,
-                           &analog_clock->min_tip.pos, &analog_clock->centre,
-                           &analog_clock->arrow_color);
-
-  renderer_ops->set_linewidth(renderer, analog_clock->sec_arrow_line_width);
-  renderer_ops->draw_line(renderer,
-                           &analog_clock->sec_tip.pos, &analog_clock->centre,
-                           &analog_clock->sec_arrow_color);
-  renderer_ops->draw_ellipse (renderer,&analog_clock->centre,
-                              analog_clock->arrow_line_width*2.25,
-                              analog_clock->arrow_line_width*2.25,
-                              &analog_clock->sec_arrow_color, NULL);
-
+  analog_clock_update_arrow_tips (analog_clock);
+
+  dia_renderer_set_linewidth (renderer, analog_clock->arrow_line_width);
+  dia_renderer_draw_line (renderer,
+                          &analog_clock->hour_tip.pos,
+                          &analog_clock->centre,
+                          &analog_clock->arrow_color);
+  dia_renderer_draw_line (renderer,
+                          &analog_clock->min_tip.pos,
+                          &analog_clock->centre,
+                          &analog_clock->arrow_color);
+
+  dia_renderer_set_linewidth (renderer, analog_clock->sec_arrow_line_width);
+  dia_renderer_draw_line (renderer,
+                          &analog_clock->sec_tip.pos,
+                          &analog_clock->centre,
+                          &analog_clock->sec_arrow_color);
+  dia_renderer_draw_ellipse (renderer,
+                             &analog_clock->centre,
+                             analog_clock->arrow_line_width*2.25,
+                             analog_clock->arrow_line_width*2.25,
+                             &analog_clock->sec_arrow_color, NULL);
 }
 
 
diff --git a/objects/Misc/diagram_as_object.c b/objects/Misc/diagram_as_object.c
index 0a030ff1..3dac4ee6 100644
--- a/objects/Misc/diagram_as_object.c
+++ b/objects/Misc/diagram_as_object.c
@@ -65,7 +65,7 @@ typedef struct _DiagramAsElement {
 
   /* for indirect rendering*/
   DiaImage *image;
-  
+
   real scale;
 } DiagramAsElement;
 
@@ -130,7 +130,7 @@ static PropOffset _dae_offsets[] = {
 };
 static void
 _dae_get_props(DiagramAsElement *dae, GPtrArray *props)
-{  
+{
   object_get_props_from_offsets(&dae->element.object, _dae_offsets, props);
 }
 static void
@@ -152,7 +152,7 @@ _dae_select(DiagramAsElement *dae, Point *clicked_point, DiaRenderer *interactiv
 }
 static ObjectChange*
 _dae_move_handle(DiagramAsElement *dae, Handle *handle,
-                Point *to, ConnectionPoint *cp, 
+                Point *to, ConnectionPoint *cp,
                 HandleMoveReason reason, ModifierKeys modifiers)
 {
   Element *elem = &dae->element;
@@ -174,21 +174,24 @@ _dae_move(DiagramAsElement *dae, Point *to)
 
   return NULL;
 }
+
 static void
-_dae_draw(DiagramAsElement *dae, DiaRenderer *renderer)
+_dae_draw (DiagramAsElement *dae, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem = &dae->element;
 
   if (!dae->data) {
     /* just draw the box */
     Point lower_right = {
       elem->corner.x + elem->width,
-      elem->corner.y + elem->height 
+      elem->corner.y + elem->height
     };
 
-    renderer_ops->draw_rect(renderer,&elem->corner, &lower_right, 
-                            NULL, &dae->border_color);
+    dia_renderer_draw_rect (renderer,
+                            &elem->corner,
+                            &lower_right,
+                            NULL,
+                            &dae->border_color);
 
   } else {
     if (FALSE) {
@@ -200,38 +203,45 @@ _dae_draw(DiagramAsElement *dae, DiaRenderer *renderer)
     } else {
       /* we have to render to an image and draw that */
       if (!dae->image) { /* lazy creation */
-       gchar *imgfname = NULL;
-       gint fd = g_file_open_tmp ("diagram-as-elementXXXXXX.png", &imgfname, NULL);
-       if (fd != -1) {
+        gchar *imgfname = NULL;
+        gint fd = g_file_open_tmp ("diagram-as-elementXXXXXX.png", &imgfname, NULL);
+        if (fd != -1) {
           DiaExportFilter *ef = filter_export_get_by_name ("cairo-alpha-png");
-         if (!ef) /* prefer cairo with alpha, but don't require it */
-           ef = filter_guess_export_filter (imgfname);
-         close(fd);
-         if (ef) {
-           DiaContext *ctx = dia_context_new ("Diagram as Object");
-
-           dia_context_set_filename (ctx, imgfname);
-           if (ef->export_func (dae->data, ctx, imgfname, dae->filename, ef->user_data)) {
-             DiaImage *tmp_image = dia_image_load (imgfname);
-
-             /* some extra gymnastics to create an image w/o filename */
-             if (tmp_image) {
-               dae->image = dia_image_new_from_pixbuf ((GdkPixbuf *)dia_image_pixbuf (tmp_image));
-               g_object_unref (tmp_image);
-             }
-             /* FIXME: where to put the message in case of an error? */
-             dia_context_release (ctx);
-           }
-         } /* found a filter */
-         g_unlink (imgfname);
-         g_free (imgfname);
-       } /* temporary file created*/
+          if (!ef) { /* prefer cairo with alpha, but don't require it */
+            ef = filter_guess_export_filter (imgfname);
+          }
+          close(fd);
+          if (ef) {
+            DiaContext *ctx = dia_context_new ("Diagram as Object");
+
+            dia_context_set_filename (ctx, imgfname);
+            if (ef->export_func (dae->data, ctx, imgfname, dae->filename, ef->user_data)) {
+              DiaImage *tmp_image = dia_image_load (imgfname);
+
+              /* some extra gymnastics to create an image w/o filename */
+              if (tmp_image) {
+                dae->image = dia_image_new_from_pixbuf ((GdkPixbuf *) dia_image_pixbuf (tmp_image));
+                g_object_unref (tmp_image);
+              }
+              /* FIXME: where to put the message in case of an error? */
+              dia_context_release (ctx);
+            }
+          } /* found a filter */
+          g_unlink (imgfname);
+          g_free (imgfname);
+        } /* temporary file created*/
       } /* only if we have no image yet */
-      if (dae->image)
-       renderer_ops->draw_image (renderer, &elem->corner, elem->width, elem->height, dae->image);
+      if (dae->image) {
+        dia_renderer_draw_image (renderer,
+                                 &elem->corner,
+                                 elem->width,
+                                 elem->height,
+                                 dae->image);
+      }
     }
   }
 }
+
 static void
 _dae_update_data(DiagramAsElement *dae)
 {
@@ -239,7 +249,7 @@ _dae_update_data(DiagramAsElement *dae)
   Element *elem = &dae->element;
   DiaObject *obj = &elem->object;
   static int working = 0;
-  
+
   if (working > 2)
     return; /* protect against infinite recursion */
   ++working;
@@ -287,14 +297,14 @@ _dae_update_data(DiagramAsElement *dae)
 
   --working;
 }
-static void 
-_dae_destroy(DiagramAsElement *dae) 
+static void
+_dae_destroy(DiagramAsElement *dae)
 {
   if (dae->data)
     g_object_unref(dae->data);
 
   g_free(dae->filename);
-  
+
   if (dae->image)
     g_object_unref (dae->image);
 
@@ -341,7 +351,7 @@ _dae_create (Point *startpoint,
   elem->corner = *startpoint;
   elem->width = DEFAULT_WIDTH;
   elem->height = DEFAULT_HEIGHT;
-  
+
   element_init(elem, 8, NUM_CONNECTIONS);
 
   for (i=0; i<NUM_CONNECTIONS; i++) {
@@ -356,7 +366,7 @@ _dae_create (Point *startpoint,
   _dae_update_data(dae);
 
   *handle1 = NULL;
-  *handle2 = obj->handles[7];  
+  *handle2 = obj->handles[7];
   return &dae->element.object;
 }
 
@@ -365,7 +375,7 @@ _dae_load (ObjectNode obj_node, int version, DiaContext *ctx)
 {
   DiaObject *obj;
   DiagramAsElement *dae;
- 
+
   obj = object_load_using_properties (&diagram_as_element_type,
                                        obj_node, version, ctx);
   /* filename de-normalization */
diff --git a/objects/Misc/grid_object.c b/objects/Misc/grid_object.c
index 257dec6b..91b494a5 100644
--- a/objects/Misc/grid_object.c
+++ b/objects/Misc/grid_object.c
@@ -264,10 +264,10 @@ grid_object_update_data(Grid_Object *grid_object)
 }
 
 static void
-grid_object_draw_gridlines (Grid_Object *grid_object, DiaRenderer *renderer,
-               Point* lr_corner)
+grid_object_draw_gridlines (Grid_Object *grid_object,
+                            DiaRenderer *renderer,
+                            Point       *lr_corner)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   Point st, fn;
   real cell_size;
@@ -294,7 +294,7 @@ grid_object_draw_gridlines (Grid_Object *grid_object, DiaRenderer *renderer,
   for (i = 1; i < grid_object->grid_rows; ++i) {
     st.y += cell_size;
     fn.y += cell_size;
-    renderer_ops->draw_line(renderer,&st,&fn,&grid_object->gridline_color);
+    dia_renderer_draw_line (renderer,&st,&fn,&grid_object->gridline_color);
   }
 
   /* vertical gridlines */
@@ -310,14 +310,13 @@ grid_object_draw_gridlines (Grid_Object *grid_object, DiaRenderer *renderer,
   for (i = 1; i < grid_object->grid_cols; ++i) {
     st.x += cell_size;
     fn.x += cell_size;
-    renderer_ops->draw_line(renderer,&st,&fn,&grid_object->gridline_color);
+    dia_renderer_draw_line (renderer, &st, &fn, &grid_object->gridline_color);
   }
 }
 
 static void
-grid_object_draw(Grid_Object *grid_object, DiaRenderer *renderer)
+grid_object_draw (Grid_Object *grid_object, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   Point lr_corner;
 
@@ -329,19 +328,24 @@ grid_object_draw(Grid_Object *grid_object, DiaRenderer *renderer)
   lr_corner.x = elem->corner.x + elem->width;
   lr_corner.y = elem->corner.y + elem->height;
 
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   /* draw gridlines */
-  renderer_ops->set_linewidth(renderer, grid_object->gridline_width);
-  grid_object_draw_gridlines(grid_object, renderer, &lr_corner);
+  dia_renderer_set_linewidth (renderer,
+                              grid_object->gridline_width);
+  grid_object_draw_gridlines (grid_object,
+                              renderer,
+                              &lr_corner);
 
   /* draw outline */
-  renderer_ops->set_linewidth(renderer, grid_object->border_line_width);
-  renderer_ops->draw_rect(renderer,&elem->corner,
-                         &lr_corner,
-                         (grid_object->show_background) ? &grid_object->inner_color : NULL,
-                         &grid_object->border_color);
+  dia_renderer_set_linewidth (renderer,
+                              grid_object->border_line_width);
+  dia_renderer_draw_rect (renderer,
+                          &elem->corner,
+                          &lr_corner,
+                          (grid_object->show_background) ? &grid_object->inner_color : NULL,
+                          &grid_object->border_color);
 }
 
 
diff --git a/objects/Misc/measure.c b/objects/Misc/measure.c
index 7b962688..4ed7122d 100644
--- a/objects/Misc/measure.c
+++ b/objects/Misc/measure.c
@@ -34,7 +34,7 @@
 /* Object definition */
 typedef struct _Measure {
   Connection connection;
-  
+
   DiaFont *font;
   real font_height;
 
@@ -44,7 +44,7 @@ typedef struct _Measure {
   DiaUnit unit;
   int     precision;
 
-  /* caclculated data */  
+  /* caclculated data */
   char *name; /* the calculated measurment */
   Point text_pos;
 } Measure;
@@ -127,7 +127,7 @@ measure_create (Point *startpoint,
   Connection *conn;
   DiaObject *obj;
   Point defaultlen = { 1.0, 1.0 };
- 
+
   measure = g_new0 (Measure,1);
   obj = &measure->connection.object;
   obj->type = &measure_type;
@@ -141,7 +141,7 @@ measure_create (Point *startpoint,
   connection_init(conn, 2, 0);
 
   /* kind of measurement can only be set via user data */
-  
+
   attributes_get_default_font (&measure->font, &measure->font_height);
 
   measure->line_width = attributes_get_default_linewidth();
@@ -180,7 +180,7 @@ static PropNumData precision_data = {1, 9, 1};
 /* Class/Object implementation */
 static PropDescription measure_props[] = {
   CONNECTION_COMMON_PROPERTIES,
-  { "name", PROP_TYPE_STRING,/*PROP_FLAG_VISIBLE|*/PROP_FLAG_DONT_MERGE, 
+  { "name", PROP_TYPE_STRING,/*PROP_FLAG_VISIBLE|*/PROP_FLAG_DONT_MERGE,
     N_("Measurement"),NULL }, /* FIXME: mark read-only */
   { "scale", PROP_TYPE_REAL, PROP_FLAG_VISIBLE, N_("Scale"), NULL, &scale_range},
   { "unit", PROP_TYPE_ENUM, PROP_FLAG_VISIBLE, N_("Unit"), NULL, &unit_data },
@@ -217,10 +217,10 @@ measure_update_data (Measure *measure)
   Rectangle bbox;
   Arrow arrow = MEASURE_ARROW(measure);
   real ascent, width, theta;
-  
+
   g_return_if_fail (obj->handles != NULL);
   connection_update_handles(conn);
-  
+
   extra->start_trans =
   extra->end_trans   =
   extra->start_long  =
@@ -231,20 +231,20 @@ measure_update_data (Measure *measure)
   value *= measure->scale;
   value *= (28.346457 / units[measure->unit].factor);
   measure->name = g_strdup_printf ("%.*g %s", measure->precision, value, units[measure->unit].unit);
-  
+
   ascent = dia_font_ascent (measure->name, measure->font, measure->font_height);
   width = dia_font_string_width (measure->name, measure->font, measure->font_height);
   theta = atan2(ends[1].y-ends[0].y, ends[1].x-ends[0].x);
   theta = (0 >= theta ? theta + M_PI : theta);
 
-  if (theta >= M_PI * 3/4) { 
+  if (theta >= M_PI * 3/4) {
     measure->text_pos.x = (ends[0].x + ends[1].x) / 2 - sin(theta) * measure->font_height/2 - width * (2.5 - 
2/M_PI * ( theta - 3/4 * M_PI ));
     measure->text_pos.y = (ends[0].y + ends[1].y) / 2 + cos(theta) * measure->font_height/2;
   } else  {
     measure->text_pos.x = (ends[0].x + ends[1].x) / 2 + sin(theta) * measure->font_height/2;
     measure->text_pos.y = (ends[0].y + ends[1].y) / 2 - cos(theta) * measure->font_height/2;
   }
-  
+
   line_bbox (&ends[0], &ends[0], &conn->extra_spacing,&conn->object.bounding_box);
   arrow_bbox (&arrow, measure->line_width, &ends[0], &ends[1], &bbox);
   rectangle_union(&obj->bounding_box, &bbox);
@@ -259,29 +259,33 @@ measure_update_data (Measure *measure)
 
   obj->position = conn->endpoints[0];
 }
-static void 
-measure_draw(Measure *measure, DiaRenderer *renderer)
+
+static void
+measure_draw (Measure *measure, DiaRenderer *renderer)
 {
   Arrow arrow = MEASURE_ARROW(measure);
 
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, measure->line_width);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin(renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps(renderer, LINECAPS_ROUND);
-  
-  DIA_RENDERER_GET_CLASS (renderer)->draw_line_with_arrows (
-                                       renderer,
-                                       &measure->connection.endpoints[0], &measure->connection.endpoints[1],
-                                       measure->line_width, &measure->line_color,
-                                       &arrow, &arrow);
-
-  DIA_RENDERER_GET_CLASS (renderer)->set_font(renderer, 
-                                        measure->font, measure->font_height);
-  DIA_RENDERER_GET_CLASS (renderer)->draw_string (
-                                       renderer, measure->name, 
-                                       &measure->text_pos, ALIGN_LEFT, 
-                                       &measure->line_color);
+  dia_renderer_set_linewidth (renderer, measure->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_ROUND);
+
+  dia_renderer_draw_line_with_arrows (renderer,
+                                      &measure->connection.endpoints[0],
+                                      &measure->connection.endpoints[1],
+                                      measure->line_width,
+                                      &measure->line_color,
+                                      &arrow,
+                                      &arrow);
+
+  dia_renderer_set_font (renderer, measure->font, measure->font_height);
+  dia_renderer_draw_string (renderer,
+                            measure->name,
+                            &measure->text_pos,
+                            ALIGN_LEFT,
+                            &measure->line_color);
 }
+
 /*! A standard props compliant object needs to describe its parameters */
 static const PropDescription *
 measure_describe_props (Measure *measure)
@@ -290,12 +294,12 @@ measure_describe_props (Measure *measure)
     prop_desc_list_calculate_quarks(measure_props);
   return measure_props;
 }
-static void 
+static void
 measure_get_props (Measure *measure, GPtrArray *props)
 {
   object_get_props_from_offsets(&measure->connection.object, measure_offsets, props);
 }
-static void 
+static void
 measure_set_props (Measure *measure, GPtrArray *props)
 {
   object_set_props_from_offsets(&measure->connection.object, measure_offsets, props);
@@ -315,7 +319,7 @@ measure_select(Measure *measure, Point *clicked_point,
 {
   connection_update_handles(&measure->connection);
 }
-static ObjectChange* 
+static ObjectChange*
 measure_move_handle (Measure *measure,
                      Handle *handle,
                     Point *to, ConnectionPoint *cp,
@@ -332,11 +336,11 @@ measure_get_object_menu(Measure *measure,
   return NULL;
 }
 
-static ObjectChange* 
+static ObjectChange*
 measure_move (Measure *measure, Point *to)
 {
   Point start_to_end;
-  Point *ends = &measure->connection.endpoints[0]; 
+  Point *ends = &measure->connection.endpoints[0];
 
   start_to_end = ends[1];
   point_sub(&start_to_end, &ends[0]);
diff --git a/objects/Misc/n_gon.c b/objects/Misc/n_gon.c
index fe7b4b1a..d107f7ba 100644
--- a/objects/Misc/n_gon.c
+++ b/objects/Misc/n_gon.c
@@ -185,7 +185,7 @@ _ngon_select(Ngon *ng, Point *clicked_point, DiaRenderer *interactive_renderer)
 }
 static ObjectChange*
 _ngon_move_handle (Ngon *ng, Handle *handle,
-                  Point *to, ConnectionPoint *cp, 
+                  Point *to, ConnectionPoint *cp,
                   HandleMoveReason reason, ModifierKeys modifiers)
 {
   Element *elem = &ng->element;
@@ -221,34 +221,37 @@ _ngon_move(Ngon *ng, Point *to)
 
   return NULL;
 }
+
 static void
-_ngon_draw(Ngon *ng, DiaRenderer *renderer)
+_ngon_draw (Ngon *ng, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-  gboolean pattern_fill =   ng->show_background
-                        && ng->pattern != NULL
-                        && renderer_ops->is_capable_to(renderer, RENDER_PATTERN);
+  gboolean pattern_fill = ng->show_background
+              && ng->pattern != NULL
+              && dia_renderer_is_capable_of (renderer, RENDER_PATTERN);
   Color fill;
 
   g_return_if_fail (ng->points->len);
 
-  renderer_ops->set_linewidth(renderer, ng->line_width);
-  renderer_ops->set_linestyle(renderer, ng->line_style, ng->dashlength);
-  renderer_ops->set_linejoin(renderer, ng->line_join);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
-  if (ng->pattern)
+  dia_renderer_set_linewidth (renderer, ng->line_width);
+  dia_renderer_set_linestyle (renderer, ng->line_style, ng->dashlength);
+  dia_renderer_set_linejoin (renderer, ng->line_join);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+  if (ng->pattern) {
     dia_pattern_get_fallback_color (ng->pattern, &fill);
-  else
+  } else {
     fill = ng->fill;
-  if (pattern_fill)
-    renderer_ops->set_pattern (renderer, ng->pattern);
-  renderer_ops->draw_polygon(renderer,
-                            &g_array_index (ng->points, Point, 0),
-                            ng->points->len,
-                            ng->show_background ? &fill : NULL,
-                            &ng->stroke);
-  if (pattern_fill)
-    renderer_ops->set_pattern (renderer, NULL);
+  }
+  if (pattern_fill) {
+    dia_renderer_set_pattern (renderer, ng->pattern);
+  }
+  dia_renderer_draw_polygon (renderer,
+                             &g_array_index (ng->points, Point, 0),
+                             ng->points->len,
+                             ng->show_background ? &fill : NULL,
+                             &ng->stroke);
+  if (pattern_fill) {
+    dia_renderer_set_pattern (renderer, NULL);
+  }
 }
 
 /* greatest common divider */
@@ -484,10 +487,10 @@ _ngon_update_data (Ngon *ng)
   elem->corner.y = ng->center.y - ng->ray_len;
   elem->width = elem->height = 2 * ng->ray_len;
   element_update_handles(elem);
-  
+
 }
-static void 
-_ngon_destroy(Ngon *ng) 
+static void
+_ngon_destroy(Ngon *ng)
 {
   g_array_free (ng->points, TRUE);
   if (ng->pattern)
@@ -600,7 +603,7 @@ _ngon_load (ObjectNode obj_node, int version, DiaContext *ctx)
 {
   DiaObject *obj;
   Ngon *ng;
- 
+
   obj = object_load_using_properties (&_ngon_type, obj_node, version, ctx);
   ng = (Ngon *)obj;
   if (version == 0) { /* default to maximum */
diff --git a/objects/Misc/tree.c b/objects/Misc/tree.c
index 298088b5..bb9a91bc 100644
--- a/objects/Misc/tree.c
+++ b/objects/Misc/tree.c
@@ -291,9 +291,8 @@ tree_move(Tree *tree, Point *to)
 }
 
 static void
-tree_draw(Tree *tree, DiaRenderer *renderer)
+tree_draw (Tree *tree, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints;
   int i;
 
@@ -302,19 +301,20 @@ tree_draw(Tree *tree, DiaRenderer *renderer)
 
   endpoints = &tree->real_ends[0];
 
-  renderer_ops->set_linewidth(renderer, LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  renderer_ops->draw_line(renderer,
-                          &endpoints[0], &endpoints[1],
-                          &tree->line_color);
+  dia_renderer_draw_line (renderer,
+                          &endpoints[0],
+                          &endpoints[1],
+                          &tree->line_color);
 
   for (i=0;i<tree->num_handles;i++) {
-    renderer_ops->draw_line(renderer,
-                            &tree->parallel_points[i],
-                            &tree->handles[i]->pos,
-                            &tree->line_color);
+    dia_renderer_draw_line (renderer,
+                            &tree->parallel_points[i],
+                            &tree->handles[i]->pos,
+                            &tree->line_color);
   }
 }
 
diff --git a/objects/SADT/annotation.c b/objects/SADT/annotation.c
index c9265f47..dfc8b0c7 100644
--- a/objects/SADT/annotation.c
+++ b/objects/SADT/annotation.c
@@ -273,50 +273,50 @@ annotation_move(Annotation *annotation, Point *to)
 }
 
 static void
-annotation_draw(Annotation *annotation, DiaRenderer *renderer)
+annotation_draw (Annotation *annotation, DiaRenderer *renderer)
 {
   Point vect,rvect,v1,v2;
   Point pts[4];
   real vlen;
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
 
   assert(annotation != NULL);
   assert(renderer != NULL);
 
-  renderer_ops->set_linewidth(renderer, ANNOTATION_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, ANNOTATION_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   vect = annotation->connection.endpoints[1];
-  point_sub(&vect,&annotation->connection.endpoints[0]);
-  vlen = distance_point_point(&annotation->connection.endpoints[0],
-                             &annotation->connection.endpoints[1]);
+  point_sub (&vect,&annotation->connection.endpoints[0]);
+  vlen = distance_point_point (&annotation->connection.endpoints[0],
+                               &annotation->connection.endpoints[1]);
   if (vlen > 0.0) {
     /* draw the squiggle */
-    point_scale(&vect,1/vlen);
+    point_scale (&vect,1/vlen);
     rvect.y = vect.x;
     rvect.x = -vect.y;
 
     pts[0] = annotation->connection.endpoints[0];
     pts[1] = annotation->connection.endpoints[0];
     v1 = vect;
-    point_scale(&v1,.5*vlen);
-    point_add(&pts[1],&v1);
+    point_scale (&v1,.5*vlen);
+    point_add (&pts[1],&v1);
     pts[2] = pts[1];
     /* pts[1] and pts[2] are currently both at the middle of (pts[0],pts[3]) */
     v1 = vect;
-    point_scale(&v1,ANNOTATION_ZLEN);
+    point_scale (&v1,ANNOTATION_ZLEN);
     v2 = rvect;
-    point_scale(&v2,ANNOTATION_ZLEN);
-    point_sub(&v1,&v2);
-    point_add(&pts[1],&v1);
-    point_sub(&pts[2],&v1);
+    point_scale (&v2,ANNOTATION_ZLEN);
+    point_sub (&v1,&v2);
+    point_add (&pts[1],&v1);
+    point_sub (&pts[2],&v1);
     pts[3] = annotation->connection.endpoints[1];
-    renderer_ops->draw_polyline(renderer,
-                            pts, sizeof(pts) / sizeof(pts[0]),
-                            &annotation->line_color);
+    dia_renderer_draw_polyline (renderer,
+                                pts,
+                                sizeof(pts) / sizeof(pts[0]),
+                                &annotation->line_color);
   }
-  text_draw(annotation->text,renderer);
+  text_draw (annotation->text,renderer);
 }
 
 static DiaObject *
diff --git a/objects/SADT/arrow.c b/objects/SADT/arrow.c
index 4f2d096e..30b9ed1c 100644
--- a/objects/SADT/arrow.c
+++ b/objects/SADT/arrow.c
@@ -235,9 +235,8 @@ static void draw_tunnel(DiaRenderer *renderer,
 #define GMULT .55
 
 static void
-sadtarrow_draw(Sadtarrow *sadtarrow, DiaRenderer *renderer)
+sadtarrow_draw (Sadtarrow *sadtarrow, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &sadtarrow->orth;
   Point *points;
   int n;
@@ -247,9 +246,9 @@ sadtarrow_draw(Sadtarrow *sadtarrow, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, ARROW_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, ARROW_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   col = sadtarrow->line_color;
   if (sadtarrow->autogray &&
@@ -264,102 +263,112 @@ sadtarrow_draw(Sadtarrow *sadtarrow, DiaRenderer *renderer)
   arrow.length = ARROW_HEAD_LENGTH;
   arrow.width = ARROW_HEAD_WIDTH;
 
-  renderer_ops->draw_rounded_polyline_with_arrows
-    (renderer, points, n, ARROW_LINE_WIDTH, &col,
-     sadtarrow->style == SADT_ARROW_DOTTED?&arrow:NULL,
-     sadtarrow->style != SADT_ARROW_DISABLED?&arrow:NULL,
-     ARROW_CORNER_RADIUS);
+  dia_renderer_draw_rounded_polyline_with_arrows (renderer,
+                                                  points,
+                                                  n,
+                                                  ARROW_LINE_WIDTH,
+                                                  &col,
+                                                  sadtarrow->style == SADT_ARROW_DOTTED?&arrow:NULL,
+                                                  sadtarrow->style != SADT_ARROW_DISABLED?&arrow:NULL,
+                                                  ARROW_CORNER_RADIUS);
 
   /* Draw the extra stuff. */
   switch (sadtarrow->style) {
-  case SADT_ARROW_IMPORTED:
-    draw_tunnel(renderer,&points[0],&points[1],&col);
-    break;
-  case SADT_ARROW_IMPLIED:
-    draw_tunnel(renderer,&points[n-1],&points[n-2],&col);
-    break;
-  case SADT_ARROW_DOTTED:
-    draw_dot(renderer,&points[n-1], &points[n-2],&col);
-    draw_dot(renderer,&points[0], &points[1],&col);
-    break;
-  case SADT_ARROW_NORMAL:
-  case SADT_ARROW_DISABLED:
-    break;
+    case SADT_ARROW_IMPORTED:
+      draw_tunnel (renderer,&points[0],&points[1],&col);
+      break;
+    case SADT_ARROW_IMPLIED:
+      draw_tunnel (renderer,&points[n-1],&points[n-2],&col);
+      break;
+    case SADT_ARROW_DOTTED:
+      draw_dot (renderer,&points[n-1], &points[n-2],&col);
+      draw_dot (renderer,&points[0], &points[1],&col);
+      break;
+    case SADT_ARROW_NORMAL:
+    case SADT_ARROW_DISABLED:
+      break;
   }
 }
 
-static void draw_dot(DiaRenderer *renderer,
-                    Point *end, Point *vect, Color *col)
+static void
+draw_dot (DiaRenderer *renderer,
+          Point       *end,
+          Point       *vect,
+          Color       *col)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point vv,vp,vt,pt;
   real vlen;
   vv = *end;
-  point_sub(&vv,vect);
-  vlen = distance_point_point(vect,end);
+  point_sub (&vv,vect);
+  vlen = distance_point_point (vect,end);
   if (vlen < 1E-7) return;
-  point_scale(&vv,1/vlen);
+  point_scale (&vv,1/vlen);
 
   vp.y = vv.x;
   vp.x = -vv.y;
 
   pt = *end;
     vt = vp;
-  point_scale(&vt,ARROW_DOT_WOFFSET);
-  point_add(&pt,&vt);
+  point_scale (&vt,ARROW_DOT_WOFFSET);
+  point_add (&pt,&vt);
   vt = vv;
-  point_scale(&vt,-ARROW_DOT_LOFFSET);
-  point_add(&pt,&vt);
-
-  renderer_ops->set_fillstyle(renderer,FILLSTYLE_SOLID);
-  renderer_ops->draw_ellipse(renderer,&pt,
-                            ARROW_DOT_RADIUS,ARROW_DOT_RADIUS,
-                            col, NULL);
+  point_scale (&vt,-ARROW_DOT_LOFFSET);
+  point_add (&pt,&vt);
+
+  dia_renderer_set_fillstyle (renderer,FILLSTYLE_SOLID);
+  dia_renderer_draw_ellipse (renderer,
+                             &pt,
+                             ARROW_DOT_RADIUS,
+                             ARROW_DOT_RADIUS,
+                             col,
+                             NULL);
 }
 
-static void draw_tunnel(DiaRenderer *renderer,
-                            Point *end, Point *vect, Color *col)
+static void
+draw_tunnel (DiaRenderer *renderer,
+             Point       *end,
+             Point       *vect,
+             Color       *col)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point vv,vp,vt1,vt2;
   BezPoint curve1[2];
   BezPoint curve2[2];
 
   real vlen;
   vv = *end;
-  point_sub(&vv,vect);
-  vlen = distance_point_point(vect,end);
+  point_sub (&vv,vect);
+  vlen = distance_point_point (vect,end);
   if (vlen < 1E-7) return;
-  point_scale(&vv,1/vlen);
+  point_scale (&vv,1/vlen);
   vp.y = vv.x;
   vp.x = -vv.y;
 
   curve1[0].type = curve2[0].type = BEZ_MOVE_TO;
   curve1[0].p1   = curve2[0].p1   = *end;
   vt1 = vv;
-  point_scale(&vt1,-ARROW_PARENS_LOFFSET - (.5*ARROW_PARENS_LENGTH));
-  point_add(&curve1[0].p1,&vt1); point_add(&curve2[0].p1,&vt1);
+  point_scale (&vt1,-ARROW_PARENS_LOFFSET - (.5*ARROW_PARENS_LENGTH));
+  point_add (&curve1[0].p1,&vt1); point_add (&curve2[0].p1,&vt1);
                                            /* gcc, work for me, please. */
   vt2 = vp;
-  point_scale(&vt2,ARROW_PARENS_WOFFSET);
-  point_add(&curve1[0].p1,&vt2);  point_sub(&curve2[0].p1,&vt2);
+  point_scale (&vt2,ARROW_PARENS_WOFFSET);
+  point_add (&curve1[0].p1,&vt2);  point_sub (&curve2[0].p1,&vt2);
 
   vt2 = vp;
   vt1 = vv;
-  point_scale(&vt1,2.0*ARROW_PARENS_LENGTH / 6.0);
-  point_scale(&vt2,ARROW_PARENS_LENGTH / 6.0);
+  point_scale (&vt1,2.0*ARROW_PARENS_LENGTH / 6.0);
+  point_scale (&vt2,ARROW_PARENS_LENGTH / 6.0);
   curve1[1].type = curve2[1].type = BEZ_CURVE_TO;
   curve1[1].p1 = curve1[0].p1;  curve2[1].p1 = curve2[0].p1;
-  point_add(&curve1[1].p1,&vt1);  point_add(&curve2[1].p1,&vt1);
-  point_add(&curve1[1].p1,&vt2);  point_sub(&curve2[1].p1,&vt2);
+  point_add (&curve1[1].p1,&vt1);  point_add (&curve2[1].p1,&vt1);
+  point_add (&curve1[1].p1,&vt2);  point_sub (&curve2[1].p1,&vt2);
   curve1[1].p2 = curve1[1].p1;  curve2[1].p2 = curve2[1].p1;
-  point_add(&curve1[1].p2,&vt1);  point_add(&curve2[1].p2,&vt1);
+  point_add (&curve1[1].p2,&vt1);  point_add (&curve2[1].p2,&vt1);
   curve1[1].p3 = curve1[1].p2;  curve2[1].p3 = curve2[1].p2;
-  point_add(&curve1[1].p3,&vt1);  point_add(&curve2[1].p3,&vt1);
-  point_sub(&curve1[1].p3,&vt2);  point_add(&curve2[1].p3,&vt2);
+  point_add (&curve1[1].p3,&vt1);  point_add (&curve2[1].p3,&vt1);
+  point_sub (&curve1[1].p3,&vt2);  point_add (&curve2[1].p3,&vt2);
 
-  renderer_ops->draw_bezier(renderer,curve1,2,col);
-  renderer_ops->draw_bezier(renderer,curve2,2,col);
+  dia_renderer_draw_bezier (renderer,curve1,2,col);
+  dia_renderer_draw_bezier (renderer,curve2,2,col);
 }
 
 
diff --git a/objects/SADT/box.c b/objects/SADT/box.c
index 14bb2b64..e36eac96 100644
--- a/objects/SADT/box.c
+++ b/objects/SADT/box.c
@@ -261,9 +261,8 @@ sadtbox_move(Box *box, Point *to)
 }
 
 static void
-sadtbox_draw(Box *box, DiaRenderer *renderer)
+sadtbox_draw (Box *box, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point lr_corner,pos;
   Element *elem;
   real idfontheight;
@@ -276,29 +275,29 @@ sadtbox_draw(Box *box, DiaRenderer *renderer)
   lr_corner.x = elem->corner.x + elem->width;
   lr_corner.y = elem->corner.y + elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, SADTBOX_LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, SADTBOX_LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  renderer_ops->draw_rect(renderer,
-                          &elem->corner,
-                          &lr_corner,
-                          &box->fill_color,
-                          &box->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &elem->corner,
+                          &lr_corner,
+                          &box->fill_color,
+                          &box->line_color);
 
 
-  text_draw(box->text, renderer);
+  text_draw (box->text, renderer);
 
   idfontheight = .75 * box->text->height;
-  renderer_ops->set_font(renderer, box->text->font, idfontheight);
+  dia_renderer_set_font (renderer, box->text->font, idfontheight);
   pos = lr_corner;
   pos.x -= .3 * idfontheight;
   pos.y -= .3 * idfontheight;
-  renderer_ops->draw_string(renderer,
-                            box->id,
-                            &pos, ALIGN_RIGHT,
-                            &box->text->color);
+  dia_renderer_draw_string (renderer,
+                            box->id,
+                            &pos, ALIGN_RIGHT,
+                            &box->text->color);
 }
 
 static void
diff --git a/objects/UML/activity.c b/objects/UML/activity.c
index 632e99e1..59f8554a 100644
--- a/objects/UML/activity.c
+++ b/objects/UML/activity.c
@@ -206,7 +206,6 @@ state_move(State *state, Point *to)
 static void
 state_draw(State *state, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point p1, p2;
@@ -221,17 +220,21 @@ state_draw(State *state, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, STATE_LINEWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, STATE_LINEWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   p1.x = x;
   p1.y = y;
   p2.x = x + w;
   p2.y = y + h;
-  renderer_ops->draw_rounded_rect(renderer, &p1, &p2,
-                                 &state->fill_color, &state->line_color, 1.0);
-  text_draw(state->text, renderer);
+  dia_renderer_draw_rounded_rect (renderer,
+                                  &p1,
+                                  &p2,
+                                  &state->fill_color,
+                                  &state->line_color,
+                                  1.0);
+  text_draw (state->text, renderer);
 }
 
 
diff --git a/objects/UML/actor.c b/objects/UML/actor.c
index 39d8e2ca..28829823 100644
--- a/objects/UML/actor.c
+++ b/objects/UML/actor.c
@@ -209,7 +209,6 @@ actor_move(Actor *actor, Point *to)
 static void
 actor_draw(Actor *actor, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w;
   real r, r1;
@@ -226,11 +225,11 @@ actor_draw(Actor *actor, DiaRenderer *renderer)
   w = elem->width;
   actor_height = elem->height - actor->text->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, actor->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, actor->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-  r = ACTOR_HEAD(actor_height);
+  r = ACTOR_HEAD (actor_height);
   r1 = 2*r;
   ch.x = x + w*0.5;
   ch.y = y + r + ACTOR_MARGIN_Y;
@@ -238,38 +237,44 @@ actor_draw(Actor *actor, DiaRenderer *renderer)
   cb.y = ch.y + r1 + r;
 
   /* head */
-  renderer_ops->draw_ellipse(renderer,
-                            &ch,
-                            r, r,
-                            &actor->fill_color, &actor->line_color);
+  dia_renderer_draw_ellipse (renderer,
+                             &ch,
+                             r,
+                             r,
+                             &actor->fill_color,
+                             &actor->line_color);
 
   /* Arms */
   p1.x = ch.x - r1;
   p2.x = ch.x + r1;
   p1.y = p2.y = ch.y + r;
-  renderer_ops->draw_line(renderer,
-                          &p1, &p2,
-                          &actor->line_color);
+  dia_renderer_draw_line (renderer,
+                          &p1,
+                          &p2,
+                          &actor->line_color);
 
   p1.x = ch.x;
   p1.y = ch.y + r*0.5;
   /* body & legs  */
-  renderer_ops->draw_line(renderer,
-                          &p1, &cb,
-                          &actor->line_color);
+  dia_renderer_draw_line (renderer,
+                          &p1,
+                          &cb,
+                          &actor->line_color);
 
   p2.x = ch.x - r1;
-  p2.y = y + ACTOR_BODY(actor_height);
-  renderer_ops->draw_line(renderer,
-                          &cb, &p2,
-                          &actor->line_color);
+  p2.y = y + ACTOR_BODY (actor_height);
+  dia_renderer_draw_line (renderer,
+                          &cb,
+                          &p2,
+                          &actor->line_color);
 
   p2.x =  ch.x + r1;
-  renderer_ops->draw_line(renderer,
-                          &cb, &p2,
-                          &actor->line_color);
+  dia_renderer_draw_line (renderer,
+                          &cb,
+                          &p2,
+                          &actor->line_color);
 
-  text_draw(actor->text, renderer);
+  text_draw (actor->text, renderer);
 }
 
 static void
diff --git a/objects/UML/association.c b/objects/UML/association.c
index 14fd4c8a..facbb5be 100644
--- a/objects/UML/association.c
+++ b/objects/UML/association.c
@@ -403,9 +403,8 @@ assoc_get_direction_poly (Association *assoc, Point* poly)
 }
 
 static void
-association_draw(Association *assoc, DiaRenderer *renderer)
+association_draw (Association *assoc, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &assoc->orth;
   Point *points;
   Point poly[3];
@@ -416,10 +415,10 @@ association_draw(Association *assoc, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, assoc->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, assoc->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   startarrow.length = ASSOCIATION_TRIANGLESIZE;
   startarrow.width = ASSOCIATION_TRIANGLESIZE;
@@ -429,7 +428,7 @@ association_draw(Association *assoc, DiaRenderer *renderer)
     startarrow.length = ASSOCIATION_DIAMONDLEN;
     startarrow.width = ASSOCIATION_TRIANGLESIZE*0.6;
     startarrow.type = assoc->end[0].aggregate == AGGREGATE_NORMAL ?
-      ARROW_HOLLOW_DIAMOND : ARROW_FILLED_DIAMOND;
+                          ARROW_HOLLOW_DIAMOND : ARROW_FILLED_DIAMOND;
   } else {
     startarrow.type = ARROW_NONE;
   }
@@ -441,49 +440,57 @@ association_draw(Association *assoc, DiaRenderer *renderer)
     endarrow.length = ASSOCIATION_DIAMONDLEN;
     endarrow.width = ASSOCIATION_TRIANGLESIZE*0.6;
     endarrow.type = assoc->end[1].aggregate == AGGREGATE_NORMAL ?
-      ARROW_HOLLOW_DIAMOND : ARROW_FILLED_DIAMOND;
+                        ARROW_HOLLOW_DIAMOND : ARROW_FILLED_DIAMOND;
   } else {
     endarrow.type = ARROW_NONE;
   }
-  renderer_ops->draw_polyline_with_arrows(renderer, points, n,
-                                          assoc->line_width,
-                                          &assoc->line_color,
-                                          &startarrow, &endarrow);
+  dia_renderer_draw_polyline_with_arrows (renderer,
+                                          points,
+                                          n,
+                                          assoc->line_width,
+                                          &assoc->line_color,
+                                          &startarrow,
+                                          &endarrow);
 
   /* Name: */
-  renderer_ops->set_font(renderer, assoc->font, assoc->font_height);
+  dia_renderer_set_font (renderer, assoc->font, assoc->font_height);
 
   if (assoc->name != NULL) {
     pos = assoc->text_pos;
-    renderer_ops->draw_string(renderer, assoc->name,
-                              &pos, assoc->text_align,
-                              &assoc->text_color);
+    dia_renderer_draw_string (renderer,
+                              assoc->name,
+                              &pos,
+                              assoc->text_align,
+                              &assoc->text_color);
   }
 
   /* Direction: */
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
 
-  if (assoc_get_direction_poly (assoc, poly))
-    renderer_ops->draw_polygon(renderer, poly, 3, &assoc->line_color, NULL);
+  if (assoc_get_direction_poly (assoc, poly)) {
+    dia_renderer_draw_polygon (renderer, poly, 3, &assoc->line_color, NULL);
+  }
 
-  for (i=0;i<2;i++) {
+  for (i = 0; i < 2; i++) {
     AssociationEnd *end = &assoc->end[i];
     pos = end->text_pos;
 
     if (end->role != NULL && *end->role) {
       gchar *role_name = g_strdup_printf ("%c%s", visible_char[(int) end->visibility], end->role);
-      renderer_ops->draw_string(renderer,
+      dia_renderer_draw_string (renderer,
                                 role_name,
-                               &pos,
-                               end->text_align,
-                               &assoc->text_color);
+                                &pos,
+                                end->text_align,
+                                &assoc->text_color);
       g_free (role_name);
       pos.y += assoc->font_height;
     }
     if (end->multiplicity != NULL) {
-      renderer_ops->draw_string(renderer, end->multiplicity,
-                                &pos, end->text_align,
-                                &assoc->text_color);
+      dia_renderer_draw_string (renderer,
+                                end->multiplicity,
+                                &pos,
+                                end->text_align,
+                                &assoc->text_color);
     }
   }
 }
diff --git a/objects/UML/branch.c b/objects/UML/branch.c
index cf15a981..09936470 100644
--- a/objects/UML/branch.c
+++ b/objects/UML/branch.c
@@ -194,9 +194,9 @@ branch_move(Branch *branch, Point *to)
   return NULL;
 }
 
-static void branch_draw(Branch *branch, DiaRenderer *renderer)
+static void
+branch_draw (Branch *branch, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real w, h;
   Point points[4];
@@ -212,11 +212,11 @@ static void branch_draw(Branch *branch, DiaRenderer *renderer)
   points[2].x = elem->corner.x + 2*w, points[2].y = elem->corner.y + h;
   points[3].x = elem->corner.x + w,   points[3].y = elem->corner.y + 2*h;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, BRANCH_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, BRANCH_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-  renderer_ops->draw_polygon(renderer, points, 4, &branch->fill_color, &branch->line_color);
+  dia_renderer_draw_polygon (renderer, points, 4, &branch->fill_color, &branch->line_color);
 }
 
 static void branch_update_data(Branch *branch)
diff --git a/objects/UML/class.c b/objects/UML/class.c
index 5bd37a96..4c1d2f69 100644
--- a/objects/UML/class.c
+++ b/objects/UML/class.c
@@ -565,16 +565,15 @@ umlclass_move(UMLClass *umlclass, Point *to)
  *
  */
 static void
-uml_underline_text(DiaRenderer  *renderer,
-               Point         StartPoint,
-               DiaFont      *font,
-               real          font_height,
-               gchar        *string,
-               Color        *color,
-               real          line_width,
-               real          underline_width)
+uml_underline_text (DiaRenderer  *renderer,
+                    Point         StartPoint,
+                    DiaFont      *font,
+                    real          font_height,
+                    gchar        *string,
+                    Color        *color,
+                    real          line_width,
+                    real          underline_width)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point    UnderlineStartPoint;
   Point    UnderlineEndPoint;
   gchar *whitespaces;
@@ -586,18 +585,18 @@ uml_underline_text(DiaRenderer  *renderer,
 
   whitespaces = string;
   while (whitespaces &&
-        g_unichar_isspace(g_utf8_get_char(whitespaces))) {
-    whitespaces = g_utf8_next_char(whitespaces);
+         g_unichar_isspace (g_utf8_get_char (whitespaces))) {
+    whitespaces = g_utf8_next_char (whitespaces);
   }
   first_non_whitespace = whitespaces - string;
-  whitespaces = g_strdup(string);
+  whitespaces = g_strdup (string);
   whitespaces[first_non_whitespace] = '\0';
-  UnderlineStartPoint.x += dia_font_string_width(whitespaces, font, font_height);
+  UnderlineStartPoint.x += dia_font_string_width (whitespaces, font, font_height);
   g_free(whitespaces);
-  UnderlineEndPoint.x += dia_font_string_width(string, font, font_height);
-  renderer_ops->set_linewidth(renderer, underline_width);
-  renderer_ops->draw_line(renderer, &UnderlineStartPoint, &UnderlineEndPoint, color);
-  renderer_ops->set_linewidth(renderer, line_width);
+  UnderlineEndPoint.x += dia_font_string_width (string, font, font_height);
+  dia_renderer_set_linewidth (renderer, underline_width);
+  dia_renderer_draw_line (renderer, &UnderlineStartPoint, &UnderlineEndPoint, color);
+  dia_renderer_set_linewidth (renderer, line_width);
 }
 
 /**
@@ -715,15 +714,15 @@ uml_create_documentation_tag (gchar * comment,
  * @see   uml_create_documentation
  */
 static void
-uml_draw_comments(DiaRenderer *renderer,
-                  DiaFont     *font,
-                  real         font_height,
-                  Color       *text_color,
-                  gchar       *comment,
-                 gboolean     comment_tagging,
-                  gint         Comment_line_length,
-                  Point       *p,
-                  gint         alignment)
+uml_draw_comments (DiaRenderer *renderer,
+                   DiaFont     *font,
+                   real         font_height,
+                   Color       *text_color,
+                   gchar       *comment,
+                   gboolean     comment_tagging,
+                   gint         Comment_line_length,
+                   Point       *p,
+                   gint         alignment)
 {
   gint      NumberOfLines = 0;
   gint      Index;
@@ -732,35 +731,29 @@ uml_draw_comments(DiaRenderer *renderer,
   gchar     *NewLineP= NULL;
   gchar     *RenderP;
 
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-
   CommentString =
-        uml_create_documentation_tag(comment, comment_tagging, Comment_line_length, &NumberOfLines);
+        uml_create_documentation_tag (comment, comment_tagging, Comment_line_length, &NumberOfLines);
   RenderP = CommentString;
-  renderer_ops->set_font(renderer, font, font_height);
-  ascent = dia_font_ascent(RenderP, font, font_height);
-  for ( Index=0; Index < NumberOfLines; Index++)
-  {
-    NewLineP = strchr(RenderP, '\n');
-    if ( NewLineP != NULL)
-    {
+  dia_renderer_set_font (renderer, font, font_height);
+  ascent = dia_font_ascent (RenderP, font, font_height);
+  for ( Index=0; Index < NumberOfLines; Index++) {
+    NewLineP = strchr (RenderP, '\n');
+    if ( NewLineP != NULL) {
       *NewLineP++ = '\0';
     }
     if (Index == 0) {
       p->y += ascent;
-    }
-    else
-    {
+    } else {
       p->y += font_height;                    /* Advance to the next line */
     }
-    renderer_ops->draw_string(renderer, RenderP, p, alignment, text_color);
+    dia_renderer_draw_string (renderer, RenderP, p, alignment, text_color);
     RenderP = NewLineP;
-    if ( NewLineP == NULL){
+    if (NewLineP == NULL) {
         break;
     }
   }
   p->y += font_height - ascent;
-  g_free(CommentString);
+  g_free (CommentString);
 }
 
 
@@ -784,9 +777,10 @@ uml_draw_comments(DiaRenderer *renderer,
  *
  */
 static real
-umlclass_draw_namebox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem )
+umlclass_draw_namebox (UMLClass    *umlclass,
+                       DiaRenderer *renderer,
+                       Element     *elem)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   real     font_height;
   real     ascent;
   DiaFont *font;
@@ -795,8 +789,6 @@ umlclass_draw_namebox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem )
   real    Yoffset;
   Color   *text_color = &umlclass->text_color;
 
-
-
   StartPoint.x = elem->corner.x;
   StartPoint.y = elem->corner.y;
 
@@ -807,8 +799,11 @@ umlclass_draw_namebox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem )
   LowerRightPoint.y  = Yoffset;
 
   /* First draw the outer box and fill color for the class name object */
-  renderer_ops->draw_rect(renderer, &StartPoint, &LowerRightPoint,
-                         &umlclass->fill_color, &umlclass->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &StartPoint,
+                          &LowerRightPoint,
+                          &umlclass->fill_color,
+                          &umlclass->line_color);
 
   /* Start at the midpoint on the X axis */
   StartPoint.x += elem->width / 2.0;
@@ -817,10 +812,10 @@ umlclass_draw_namebox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem )
   /* stereotype: */
   if (umlclass->stereotype != NULL && umlclass->stereotype[0] != '\0') {
     gchar *String = umlclass->stereotype_string;
-    ascent = dia_font_ascent(String, umlclass->normal_font, umlclass->font_height);
+    ascent = dia_font_ascent (String, umlclass->normal_font, umlclass->font_height);
     StartPoint.y += ascent;
-    renderer_ops->set_font(renderer, umlclass->normal_font, umlclass->font_height);
-    renderer_ops->draw_string(renderer,  String, &StartPoint, ALIGN_CENTER, text_color);
+    dia_renderer_set_font (renderer, umlclass->normal_font, umlclass->font_height);
+    dia_renderer_draw_string (renderer,  String, &StartPoint, ALIGN_CENTER, text_color);
     StartPoint.y += umlclass->font_height - ascent;
   }
 
@@ -833,19 +828,25 @@ umlclass_draw_namebox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem )
       font = umlclass->classname_font;
       font_height = umlclass->classname_font_height;
     }
-    ascent = dia_font_ascent(umlclass->name, font, font_height);
+    ascent = dia_font_ascent (umlclass->name, font, font_height);
     StartPoint.y += ascent;
 
-    renderer_ops->set_font(renderer, font, font_height);
-    renderer_ops->draw_string(renderer, umlclass->name, &StartPoint, ALIGN_CENTER, text_color);
+    dia_renderer_set_font (renderer, font, font_height);
+    dia_renderer_draw_string (renderer, umlclass->name, &StartPoint, ALIGN_CENTER, text_color);
     StartPoint.y += font_height - ascent;
   }
 
   /* comment */
   if (umlclass->visible_comments && umlclass->comment != NULL && umlclass->comment[0] != '\0'){
-    uml_draw_comments(renderer, umlclass->comment_font ,umlclass->comment_font_height,
-                           &umlclass->text_color, umlclass->comment, umlclass->comment_tagging,
-                           umlclass->comment_line_length, &StartPoint, ALIGN_CENTER);
+    uml_draw_comments (renderer,
+                       umlclass->comment_font,
+                       umlclass->comment_font_height,
+                       &umlclass->text_color,
+                       umlclass->comment,
+                       umlclass->comment_tagging,
+                       umlclass->comment_line_length,
+                       &StartPoint,
+                       ALIGN_CENTER);
   }
   return Yoffset;
 }
@@ -870,9 +871,11 @@ umlclass_draw_namebox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem )
  * @see uml_draw_comments
  */
 static real
-umlclass_draw_attributebox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem, real Yoffset)
+umlclass_draw_attributebox (UMLClass    *umlclass,
+                            DiaRenderer *renderer,
+                            Element     *elem,
+                            real         Yoffset)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   real     font_height;
   real     ascent;
   Point    StartPoint;
@@ -891,7 +894,7 @@ umlclass_draw_attributebox(UMLClass *umlclass, DiaRenderer *renderer, Element *e
   LowerRight.x += elem->width;
   LowerRight.y = Yoffset;
 
-  renderer_ops->draw_rect(renderer, &StartPoint, &LowerRight, fill_color, line_color);
+  dia_renderer_draw_rect (renderer, &StartPoint, &LowerRight, fill_color, line_color);
 
   if (!umlclass->suppress_attributes) {
     gint i = 0;
@@ -899,37 +902,47 @@ umlclass_draw_attributebox(UMLClass *umlclass, DiaRenderer *renderer, Element *e
     StartPoint.y += 0.1;
 
     list = umlclass->attributes;
-    while (list != NULL)
-    {
+    while (list != NULL) {
       UMLAttribute *attr   = (UMLAttribute *)list->data;
-      gchar        *attstr = uml_get_attribute_string(attr);
+      gchar        *attstr = uml_get_attribute_string (attr);
 
       if (attr->abstract)  {
         font = umlclass->abstract_font;
         font_height = umlclass->abstract_font_height;
-      }
-      else  {
+      } else {
         font = umlclass->normal_font;
         font_height = umlclass->font_height;
       }
-      ascent = dia_font_ascent(attstr, font, font_height);
+      ascent = dia_font_ascent (attstr, font, font_height);
       StartPoint.y += ascent;
-      renderer_ops->set_font (renderer, font, font_height);
-      renderer_ops->draw_string(renderer, attstr, &StartPoint, ALIGN_LEFT, text_color);
+      dia_renderer_set_font (renderer, font, font_height);
+      dia_renderer_draw_string (renderer, attstr, &StartPoint, ALIGN_LEFT, text_color);
       StartPoint.y += font_height - ascent;
 
       if (attr->class_scope) {
-        uml_underline_text(renderer, StartPoint, font, font_height, attstr, line_color,
-                        umlclass->line_width, UMLCLASS_UNDERLINEWIDTH );
+        uml_underline_text (renderer,
+                            StartPoint,
+                            font,
+                            font_height,
+                            attstr,
+                            line_color,
+                            umlclass->line_width,
+                            UMLCLASS_UNDERLINEWIDTH);
       }
 
       if (umlclass->visible_comments && attr->comment != NULL && attr->comment[0] != '\0') {
-        uml_draw_comments(renderer, umlclass->comment_font ,umlclass->comment_font_height,
-                               &umlclass->text_color, attr->comment, umlclass->comment_tagging,
-                               umlclass->comment_line_length, &StartPoint, ALIGN_LEFT);
+        uml_draw_comments (renderer,
+                           umlclass->comment_font,
+                           umlclass->comment_font_height,
+                           &umlclass->text_color,
+                           attr->comment,
+                           umlclass->comment_tagging,
+                           umlclass->comment_line_length,
+                           &StartPoint,
+                           ALIGN_LEFT);
         StartPoint.y += umlclass->comment_font_height/2;
       }
-      list = g_list_next(list);
+      list = g_list_next (list);
       i++;
       g_free (attstr);
     }
@@ -957,9 +970,11 @@ umlclass_draw_attributebox(UMLClass *umlclass, DiaRenderer *renderer, Element *e
  *
  */
 static real
-umlclass_draw_operationbox(UMLClass *umlclass, DiaRenderer *renderer, Element *elem, real Yoffset)
+umlclass_draw_operationbox (UMLClass    *umlclass,
+                            DiaRenderer *renderer,
+                            Element     *elem,
+                            real         Yoffset)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   real     font_height;
   Point    StartPoint;
   Point    LowerRight;
@@ -978,7 +993,7 @@ umlclass_draw_operationbox(UMLClass *umlclass, DiaRenderer *renderer, Element *e
   LowerRight.x += elem->width;
   LowerRight.y = Yoffset;
 
-  renderer_ops->draw_rect(renderer, &StartPoint, &LowerRight, fill_color, line_color);
+  dia_renderer_draw_rect (renderer, &StartPoint, &LowerRight, fill_color, line_color);
 
   if (!umlclass->suppress_operations) {
     gint i = 0;
@@ -997,96 +1012,110 @@ umlclass_draw_operationbox(UMLClass *umlclass, DiaRenderer *renderer, Element *e
       real ascent;
 
       switch (op->inheritance_type) {
-      case UML_ABSTRACT:
-        font = umlclass->abstract_font;
-        font_height = umlclass->abstract_font_height;
-        break;
-      case UML_POLYMORPHIC:
-        font = umlclass->polymorphic_font;
-        font_height = umlclass->polymorphic_font_height;
-        break;
-      case UML_LEAF:
-      default:
-        font = umlclass->normal_font;
-        font_height = umlclass->font_height;
+        case UML_ABSTRACT:
+          font = umlclass->abstract_font;
+          font_height = umlclass->abstract_font_height;
+          break;
+        case UML_POLYMORPHIC:
+          font = umlclass->polymorphic_font;
+          font_height = umlclass->polymorphic_font_height;
+          break;
+        case UML_LEAF:
+        default:
+          font = umlclass->normal_font;
+          font_height = umlclass->font_height;
       }
 
-      ascent = dia_font_ascent(opstr, font, font_height);
+      ascent = dia_font_ascent (opstr, font, font_height);
       op->ascent = ascent;
-      renderer_ops->set_font(renderer, font, font_height);
+      dia_renderer_set_font (renderer, font, font_height);
 
       if( umlclass->wrap_operations && op->needs_wrapping) {
-       ident = op->wrap_indent;
-       wrapsublist = op->wrappos;
+        ident = op->wrap_indent;
+        wrapsublist = op->wrappos;
         last_wrap_pos = 0;
 
-        while( wrapsublist != NULL)   {
-          wrap_pos = GPOINTER_TO_INT( wrapsublist->data);
+        while( wrapsublist != NULL) {
+          wrap_pos = GPOINTER_TO_INT (wrapsublist->data);
 
-          if( last_wrap_pos == 0)  {
+          if (last_wrap_pos == 0) {
             part_opstr_need = wrap_pos + 1;
             if (part_opstr_len < part_opstr_need) {
               part_opstr_len = part_opstr_need;
               part_opstr = g_realloc (part_opstr, part_opstr_need);
             } else {
               /* ensure to never strncpy to NULL and not shrink */
-              part_opstr = g_realloc (part_opstr, MAX(part_opstr_need, part_opstr_len));
+              part_opstr = g_realloc (part_opstr, MAX (part_opstr_need, part_opstr_len));
             }
-            strncpy( part_opstr, opstr, wrap_pos);
-            memset( part_opstr+wrap_pos, '\0', 1);
+            strncpy (part_opstr, opstr, wrap_pos);
+            memset (part_opstr+wrap_pos, '\0', 1);
           } else   {
             part_opstr_need = ident + wrap_pos - last_wrap_pos + 1;
             if (part_opstr_len < part_opstr_need) {
               part_opstr_len = part_opstr_need;
               part_opstr = g_realloc (part_opstr, part_opstr_need);
             }
-            memset( part_opstr, ' ', ident);
-            memset( part_opstr+ident, '\0', 1);
-            strncat( part_opstr, opstr+last_wrap_pos, wrap_pos-last_wrap_pos);
+            memset (part_opstr, ' ', ident);
+            memset (part_opstr+ident, '\0', 1);
+            strncat (part_opstr, opstr+last_wrap_pos, wrap_pos-last_wrap_pos);
           }
 
           if( last_wrap_pos == 0 ) {
             StartPoint.y += ascent;
-          }
-          else
-          {
+          } else {
             StartPoint.y += font_height;
           }
-          renderer_ops->draw_string(renderer, part_opstr, &StartPoint, ALIGN_LEFT, text_color);
-         if (op->class_scope) {
-           uml_underline_text(renderer, StartPoint, font, font_height, part_opstr, line_color,
-                              umlclass->line_width, UMLCLASS_UNDERLINEWIDTH );
-         }
+          dia_renderer_draw_string (renderer, part_opstr, &StartPoint, ALIGN_LEFT, text_color);
+          if (op->class_scope) {
+            uml_underline_text (renderer,
+                                StartPoint,
+                                font,
+                                font_height,
+                                part_opstr,
+                                line_color,
+                                umlclass->line_width,
+                                UMLCLASS_UNDERLINEWIDTH);
+          }
           last_wrap_pos = wrap_pos;
-          wrapsublist = g_list_next( wrapsublist);
+          wrapsublist = g_list_next (wrapsublist);
         }
-      }
-      else
-      {
+      } else {
         StartPoint.y += ascent;
-        renderer_ops->draw_string(renderer, opstr, &StartPoint, ALIGN_LEFT, text_color);
-       if (op->class_scope) {
-         uml_underline_text(renderer, StartPoint, font, font_height, opstr, line_color,
-                            umlclass->line_width, UMLCLASS_UNDERLINEWIDTH );
-       }
+        dia_renderer_draw_string (renderer, opstr, &StartPoint, ALIGN_LEFT, text_color);
+        if (op->class_scope) {
+          uml_underline_text (renderer,
+                              StartPoint,
+                              font,
+                              font_height,
+                              opstr,
+                              line_color,
+                              umlclass->line_width,
+                              UMLCLASS_UNDERLINEWIDTH);
+        }
       }
 
 
       StartPoint.y += font_height - ascent;
 
-      if (umlclass->visible_comments && op->comment != NULL && op->comment[0] != '\0'){
-        uml_draw_comments(renderer, umlclass->comment_font ,umlclass->comment_font_height,
-                               &umlclass->text_color, op->comment, umlclass->comment_tagging,
-                               umlclass->comment_line_length, &StartPoint, ALIGN_LEFT);
+      if (umlclass->visible_comments && op->comment != NULL && op->comment[0] != '\0') {
+        uml_draw_comments (renderer,
+                           umlclass->comment_font,
+                           umlclass->comment_font_height,
+                           &umlclass->text_color,
+                           op->comment,
+                           umlclass->comment_tagging,
+                           umlclass->comment_line_length,
+                           &StartPoint,
+                           ALIGN_LEFT);
         StartPoint.y += umlclass->comment_font_height/2;
       }
 
-      list = g_list_next(list);
+      list = g_list_next (list);
       i++;
       g_free (opstr);
     }
-    if (part_opstr){
-      g_free(part_opstr);
+    if (part_opstr) {
+      g_free (part_opstr);
     }
   }
   return Yoffset;
@@ -1106,9 +1135,10 @@ umlclass_draw_operationbox(UMLClass *umlclass, DiaRenderer *renderer, Element *e
  *
  */
 static void
-umlclass_draw_template_parameters_box(UMLClass *umlclass, DiaRenderer *renderer, Element *elem)
+umlclass_draw_template_parameters_box (UMLClass    *umlclass,
+                                       DiaRenderer *renderer,
+                                       Element     *elem)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point UpperLeft;
   Point LowerRight;
   Point TextInsert;
@@ -1132,24 +1162,23 @@ umlclass_draw_template_parameters_box(UMLClass *umlclass, DiaRenderer *renderer,
   LowerRight.x += umlclass->templates_width;
   LowerRight.y += umlclass->templates_height;
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, 0.3);
-  renderer_ops->draw_rect(renderer, &UpperLeft, &LowerRight, fill_color, line_color);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, 0.3);
+  dia_renderer_draw_rect (renderer, &UpperLeft, &LowerRight, fill_color, line_color);
 
   TextInsert.x += 0.3;
   TextInsert.y += 0.1;
-  renderer_ops->set_font(renderer, font, font_height);
+  dia_renderer_set_font (renderer, font, font_height);
   i = 0;
   list = umlclass->formal_params;
-  while (list != NULL)
-  {
-    gchar *paramstr = uml_get_formalparameter_string((UMLFormalParameter *)list->data);
+  while (list != NULL) {
+    gchar *paramstr = uml_get_formalparameter_string ((UMLFormalParameter *)list->data);
 
-    ascent = dia_font_ascent(paramstr, font, font_height);
+    ascent = dia_font_ascent (paramstr, font, font_height);
     TextInsert.y += ascent;
-    renderer_ops->draw_string(renderer, paramstr, &TextInsert, ALIGN_LEFT, text_color);
+    dia_renderer_draw_string (renderer, paramstr, &TextInsert, ALIGN_LEFT, text_color);
     TextInsert.y += font_height - ascent;
 
-    list = g_list_next(list);
+    list = g_list_next (list);
     i++;
     g_free (paramstr);
   }
@@ -1168,30 +1197,29 @@ umlclass_draw_template_parameters_box(UMLClass *umlclass, DiaRenderer *renderer,
  */
 
 static void
-umlclass_draw(UMLClass *umlclass, DiaRenderer *renderer)
+umlclass_draw (UMLClass *umlclass, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   real     y  = 0.0;
   Element *elem;
 
   assert(umlclass != NULL);
   assert(renderer != NULL);
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, umlclass->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, umlclass->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   elem = &umlclass->element;
 
-  y = umlclass_draw_namebox(umlclass, renderer, elem);
+  y = umlclass_draw_namebox (umlclass, renderer, elem);
   if (umlclass->visible_attributes) {
-    y = umlclass_draw_attributebox(umlclass, renderer, elem, y);
+    y = umlclass_draw_attributebox (umlclass, renderer, elem, y);
   }
   if (umlclass->visible_operations) {
-    umlclass_draw_operationbox(umlclass, renderer, elem, y);
+    umlclass_draw_operationbox (umlclass, renderer, elem, y);
   }
   if (umlclass->template) {
-    umlclass_draw_template_parameters_box(umlclass, renderer, elem);
+    umlclass_draw_template_parameters_box (umlclass, renderer, elem);
   }
 }
 
diff --git a/objects/UML/classicon.c b/objects/UML/classicon.c
index 0d92edcd..1cc9b1b7 100644
--- a/objects/UML/classicon.c
+++ b/objects/UML/classicon.c
@@ -237,9 +237,8 @@ classicon_move(Classicon *cicon, Point *to)
 }
 
 static void
-classicon_draw(Classicon *icon, DiaRenderer *renderer)
+classicon_draw (Classicon *icon, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real r, x, y, w;
   Point center, p1, p2;
@@ -258,74 +257,75 @@ classicon_draw(Classicon *icon, DiaRenderer *renderer)
   center.x = x + elem->width/2;
   center.y = y + r + CLASSICON_ARROW;
 
-  if (icon->stereotype==CLASSICON_BOUNDARY)
-      center.x += r/2.0;
-
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, icon->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  if (icon->stereotype==CLASSICON_BOUNDARY) {
+    center.x += r/2.0;
+  }
 
-  renderer_ops->draw_ellipse(renderer,
-                             &center,
-                             2*r, 2*r,
-                             &icon->fill_color,
-                             &icon->line_color);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, icon->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
+  dia_renderer_draw_ellipse (renderer,
+                             &center,
+                             2*r, 2*r,
+                             &icon->fill_color,
+                             &icon->line_color);
 
   switch (icon->stereotype) {
-  case CLASSICON_CONTROL:
+    case CLASSICON_CONTROL:
       p1.x = center.x - r*0.258819045102521;
       p1.y = center.y-r*0.965925826289068;
 
       p2.x = p1.x + CLASSICON_ARROW;
       p2.y = p1.y + CLASSICON_ARROW/1.5;
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &icon->line_color);
+      dia_renderer_draw_line (renderer,
+                              &p1, &p2,
+                              &icon->line_color);
       p2.x = p1.x + CLASSICON_ARROW;
       p2.y = p1.y - CLASSICON_ARROW/1.5;
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &icon->line_color);
+      dia_renderer_draw_line (renderer,
+                              &p1, &p2,
+                              &icon->line_color);
       break;
 
-  case CLASSICON_BOUNDARY:
+    case CLASSICON_BOUNDARY:
       p1.x = center.x - r;
       p2.x = p1.x - r;
       p1.y = p2.y = center.y;
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &icon->line_color);
+      dia_renderer_draw_line (renderer,
+                              &p1, &p2,
+                              &icon->line_color);
       p1.x = p2.x;
       p1.y = center.y - r;
       p2.y = center.y + r;
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &icon->line_color);
+      dia_renderer_draw_line (renderer,
+                              &p1, &p2,
+                              &icon->line_color);
       break;
-  case CLASSICON_ENTITY:
+    case CLASSICON_ENTITY:
       p1.x = center.x - r;
       p2.x = center.x + r;
       p1.y = p2.y = center.y + r;
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &icon->line_color);
+      dia_renderer_draw_line (renderer,
+                              &p1, &p2,
+                              &icon->line_color);
       break;
   }
 
-  text_draw(icon->text, renderer);
+  text_draw (icon->text, renderer);
 
   if (icon->is_object) {
-    renderer_ops->set_linewidth(renderer, 0.01);
-    if (icon->stereotype==CLASSICON_BOUNDARY)
+    dia_renderer_set_linewidth (renderer, 0.01);
+    if (icon->stereotype==CLASSICON_BOUNDARY) {
       x += r/2.0;
-    p1.y = p2.y = icon->text->position.y + text_get_descent(icon->text);
+    }
+    p1.y = p2.y = icon->text->position.y + text_get_descent (icon->text);
     for (i=0; i<icon->text->numlines; i++) {
-      p1.x = x + (w - text_get_line_width(icon->text, i))/2;
-      p2.x = p1.x + text_get_line_width(icon->text, i);
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &icon->line_color);
+      p1.x = x + (w - text_get_line_width (icon->text, i))/2;
+      p2.x = p1.x + text_get_line_width (icon->text, i);
+      dia_renderer_draw_line (renderer,
+                              &p1, &p2,
+                              &icon->line_color);
       p1.y = p2.y += icon->text->height;
     }
   }
diff --git a/objects/UML/component.c b/objects/UML/component.c
index e6f2391e..9c0a0f94 100644
--- a/objects/UML/component.c
+++ b/objects/UML/component.c
@@ -222,9 +222,8 @@ component_move(Component *cmp, Point *to)
 }
 
 static void
-component_draw(Component *cmp, DiaRenderer *renderer)
+component_draw (Component *cmp, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point p1, p2;
@@ -239,44 +238,50 @@ component_draw(Component *cmp, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, COMPONENT_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, COMPONENT_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   p1.x = x + COMPONENT_CWIDTH/2; p1.y = y;
   p2.x = x+w; p2.y = y+h;
 
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &cmp->fill_color,
-                          &cmp->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &cmp->fill_color,
+                          &cmp->line_color);
 
   p1.x= x; p1.y = y +(h - 3*COMPONENT_CHEIGHT)/2.0;
   p2.x = x+COMPONENT_CWIDTH; p2.y = p1.y + COMPONENT_CHEIGHT;
 
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &cmp->fill_color,
-                          &cmp->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &cmp->fill_color,
+                          &cmp->line_color);
 
   p1.y = p2.y + COMPONENT_CHEIGHT;
   p2.y = p1.y + COMPONENT_CHEIGHT;
 
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &cmp->fill_color,
-                          &cmp->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &cmp->fill_color,
+                          &cmp->line_color);
 
   if (cmp->st_stereotype != NULL &&
       cmp->st_stereotype[0] != '\0') {
     p1 = cmp->text->position;
     p1.y -= cmp->text->height;
-    renderer_ops->set_font(renderer, cmp->text->font, cmp->text->height);
-    renderer_ops->draw_string(renderer, cmp->st_stereotype, &p1,
-                              ALIGN_LEFT, &cmp->text->color);
+    dia_renderer_set_font (renderer, cmp->text->font, cmp->text->height);
+    dia_renderer_draw_string (renderer,
+                              cmp->st_stereotype,
+                              &p1,
+                              ALIGN_LEFT,
+                              &cmp->text->color);
   }
 
-  text_draw(cmp->text, renderer);
+  text_draw (cmp->text, renderer);
 }
 
 static void
diff --git a/objects/UML/component_feature.c b/objects/UML/component_feature.c
index 6114d2a0..b42c8fee 100644
--- a/objects/UML/component_feature.c
+++ b/objects/UML/component_feature.c
@@ -313,9 +313,8 @@ compfeat_move(Compfeat *compfeat, Point *to)
 }
 
 static void
-compfeat_draw(Compfeat *compfeat, DiaRenderer *renderer)
+compfeat_draw (Compfeat *compfeat, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *points;
   OrthConn *orth = &compfeat->orth;
   int n;
@@ -328,9 +327,9 @@ compfeat_draw(Compfeat *compfeat, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, compfeat->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, compfeat->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (compfeat->orth.orientation[orth->numorient - 1] == HORIZONTAL) {
     directions = (points[n - 1].x > points[n - 2].x)? DIR_EAST: DIR_WEST;
@@ -348,12 +347,12 @@ compfeat_draw(Compfeat *compfeat, DiaRenderer *renderer)
   endarrow.length = COMPPROP_DIAMETER;
   endarrow.width = COMPPROP_DIAMETER;
   endarrow.type = compprop_arrow[compfeat->role];
-  renderer_ops->draw_polyline_with_arrows(renderer, points, n,
-                                         compfeat->line_width,
-                                         &compfeat->line_color,
-                                         &startarrow, &endarrow);
+  dia_renderer_draw_polyline_with_arrows (renderer, points, n,
+                                          compfeat->line_width,
+                                          &compfeat->line_color,
+                                          &startarrow, &endarrow);
 
-  text_draw(compfeat->text, renderer);
+  text_draw (compfeat->text, renderer);
 }
 
 static DiaObject *
diff --git a/objects/UML/constraint.c b/objects/UML/constraint.c
index 7bd9a886..b727044e 100644
--- a/objects/UML/constraint.c
+++ b/objects/UML/constraint.c
@@ -246,9 +246,8 @@ constraint_move(Constraint *constraint, Point *to)
 }
 
 static void
-constraint_draw(Constraint *constraint, DiaRenderer *renderer)
+constraint_draw (Constraint *constraint, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints;
   Arrow arrow;
 
@@ -257,26 +256,30 @@ constraint_draw(Constraint *constraint, DiaRenderer *renderer)
 
   endpoints = &constraint->connection.endpoints[0];
 
-  renderer_ops->set_linewidth(renderer, constraint->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, CONSTRAINT_DASHLEN);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, constraint->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, CONSTRAINT_DASHLEN);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   arrow.type = ARROW_LINES;
   arrow.length = CONSTRAINT_ARROWLEN;
   arrow.width = CONSTRAINT_ARROWWIDTH;
 
-  renderer_ops->draw_line_with_arrows(renderer,
-                                      &endpoints[0], &endpoints[1],
-                                      constraint->line_width,
-                                      &constraint->line_color,
-                                      NULL, &arrow);
-
-  renderer_ops->set_font(renderer, constraint->font,
-                         constraint->font_height);
-  renderer_ops->draw_string(renderer,
-                            constraint->brtext,
-                            &constraint->text_pos, ALIGN_LEFT,
-                            &constraint->text_color);
+  dia_renderer_draw_line_with_arrows (renderer,
+                                      &endpoints[0],
+                                      &endpoints[1],
+                                      constraint->line_width,
+                                      &constraint->line_color,
+                                      NULL,
+                                      &arrow);
+
+  dia_renderer_set_font (renderer,
+                         constraint->font,
+                         constraint->font_height);
+  dia_renderer_draw_string (renderer,
+                            constraint->brtext,
+                            &constraint->text_pos,
+                            ALIGN_LEFT,
+                            &constraint->text_color);
 }
 
 static DiaObject *
diff --git a/objects/UML/dependency.c b/objects/UML/dependency.c
index 91f23381..3bc54e84 100644
--- a/objects/UML/dependency.c
+++ b/objects/UML/dependency.c
@@ -222,9 +222,8 @@ dependency_move(Dependency *dep, Point *to)
 }
 
 static void
-dependency_draw(Dependency *dep, DiaRenderer *renderer)
+dependency_draw (Dependency *dep, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &dep->orth;
   Point *points;
   int n;
@@ -234,40 +233,41 @@ dependency_draw(Dependency *dep, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, dep->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, DEPENDENCY_DASHLEN);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, dep->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, DEPENDENCY_DASHLEN);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   arrow.type = ARROW_LINES;
   arrow.length = DEPENDENCY_ARROWLEN;
   arrow.width = DEPENDENCY_ARROWWIDTH;
 
-  renderer_ops->draw_polyline_with_arrows(renderer,
-                                          points, n,
-                                          dep->line_width,
-                                          &dep->line_color,
-                                          NULL, &arrow);
+  dia_renderer_draw_polyline_with_arrows (renderer,
+                                          points,
+                                          n,
+                                          dep->line_width,
+                                          &dep->line_color,
+                                          NULL,
+                                          &arrow);
 
-  renderer_ops->set_font(renderer, dep->font, dep->font_height);
+  dia_renderer_set_font (renderer, dep->font, dep->font_height);
   pos = dep->text_pos;
 
   if (dep->st_stereotype != NULL && dep->st_stereotype[0] != '\0') {
-    renderer_ops->draw_string(renderer,
-                              dep->st_stereotype,
-                              &pos, dep->text_align,
-                              &dep->text_color);
+    dia_renderer_draw_string (renderer,
+                              dep->st_stereotype,
+                              &pos, dep->text_align,
+                              &dep->text_color);
 
     pos.y += dep->font_height;
   }
 
   if (dep->name != NULL && dep->name[0] != '\0') {
-    renderer_ops->draw_string(renderer,
-                              dep->name,
-                              &pos, dep->text_align,
-                              &dep->text_color);
+    dia_renderer_draw_string (renderer,
+                              dep->name,
+                              &pos, dep->text_align,
+                              &dep->text_color);
   }
-
 }
 
 static void
diff --git a/objects/UML/fork.c b/objects/UML/fork.c
index 4f5a1a56..8048160f 100644
--- a/objects/UML/fork.c
+++ b/objects/UML/fork.c
@@ -198,9 +198,8 @@ fork_move(Fork *branch, Point *to)
 }
 
 static void
-fork_draw(Fork *branch, DiaRenderer *renderer)
+fork_draw (Fork *branch, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real w, h;
   Point p1, p2;
@@ -212,18 +211,20 @@ fork_draw(Fork *branch, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, FORK_BORDERWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, FORK_BORDERWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   p1.x = elem->corner.x;
   p1.y = elem->corner.y;
   p2.x = elem->corner.x + w;
   p2.y = elem->corner.y + h;
 
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &branch->fill_color, NULL);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &branch->fill_color,
+                          NULL);
 }
 
 static void
diff --git a/objects/UML/generalization.c b/objects/UML/generalization.c
index f4bbd19e..76ff8800 100644
--- a/objects/UML/generalization.c
+++ b/objects/UML/generalization.c
@@ -216,9 +216,8 @@ generalization_move(Generalization *genlz, Point *to)
 }
 
 static void
-generalization_draw(Generalization *genlz, DiaRenderer *renderer)
+generalization_draw (Generalization *genlz, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &genlz->orth;
   Point *points;
   int n;
@@ -228,40 +227,42 @@ generalization_draw(Generalization *genlz, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, genlz->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, genlz->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   arrow.type = ARROW_HOLLOW_TRIANGLE;
   arrow.length = GENERALIZATION_TRIANGLESIZE;
   arrow.width = GENERALIZATION_TRIANGLESIZE;
 
-  renderer_ops->draw_polyline_with_arrows(renderer,
-                                          points, n,
-                                          genlz->line_width,
-                                          &genlz->line_color,
-                                          &arrow, NULL);
+  dia_renderer_draw_polyline_with_arrows (renderer,
+                                          points,
+                                          n,
+                                          genlz->line_width,
+                                          &genlz->line_color,
+                                          &arrow, NULL);
 
-  renderer_ops->set_font(renderer, genlz->font, genlz->font_height);
+  dia_renderer_set_font (renderer, genlz->font, genlz->font_height);
   pos = genlz->text_pos;
 
   if (genlz->st_stereotype != NULL && genlz->st_stereotype[0] != '\0') {
-    renderer_ops->draw_string(renderer,
-                              genlz->st_stereotype,
-                              &pos, genlz->text_align,
-                              &genlz->text_color);
+    dia_renderer_draw_string (renderer,
+                              genlz->st_stereotype,
+                              &pos,
+                              genlz->text_align,
+                              &genlz->text_color);
 
     pos.y += genlz->font_height;
   }
 
   if (genlz->name != NULL && genlz->name[0] != '\0') {
-    renderer_ops->draw_string(renderer,
-                              genlz->name,
-                              &pos, genlz->text_align,
-                              &genlz->text_color);
+    dia_renderer_draw_string (renderer,
+                              genlz->name,
+                              &pos,
+                              genlz->text_align,
+                              &genlz->text_color);
   }
-
 }
 
 static void
diff --git a/objects/UML/implements.c b/objects/UML/implements.c
index adb9f5cd..78676af4 100644
--- a/objects/UML/implements.c
+++ b/objects/UML/implements.c
@@ -257,9 +257,8 @@ implements_move(Implements *implements, Point *to)
 }
 
 static void
-implements_draw(Implements *implements, DiaRenderer *renderer)
+implements_draw (Implements *implements, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints;
 
   assert(implements != NULL);
@@ -267,25 +266,30 @@ implements_draw(Implements *implements, DiaRenderer *renderer)
 
   endpoints = &implements->connection.endpoints[0];
 
-  renderer_ops->set_linewidth(renderer, implements->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
-
-  renderer_ops->draw_line(renderer,
-                          &endpoints[0], &endpoints[1],
-                          &implements->line_color);
-  renderer_ops->draw_ellipse(renderer, &implements->circle_center,
-                             implements->circle_diameter,
-                             implements->circle_diameter,
-                             &color_white, &implements->line_color);
-
-
-  renderer_ops->set_font(renderer, implements->font, implements->font_height);
-  if (implements->text)
-    renderer_ops->draw_string(renderer,
-                              implements->text,
-                              &implements->text_pos, ALIGN_LEFT,
-                              &implements->text_color);
+  dia_renderer_set_linewidth (renderer, implements->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+
+  dia_renderer_draw_line (renderer,
+                          &endpoints[0],
+                          &endpoints[1],
+                          &implements->line_color);
+  dia_renderer_draw_ellipse (renderer,
+                             &implements->circle_center,
+                             implements->circle_diameter,
+                             implements->circle_diameter,
+                             &color_white,
+                             &implements->line_color);
+
+
+  dia_renderer_set_font (renderer, implements->font, implements->font_height);
+  if (implements->text) {
+    dia_renderer_draw_string (renderer,
+                              implements->text,
+                              &implements->text_pos,
+                              ALIGN_LEFT,
+                              &implements->text_color);
+  }
 }
 
 static DiaObject *
diff --git a/objects/UML/large_package.c b/objects/UML/large_package.c
index 8269ca00..f5d8d1e1 100644
--- a/objects/UML/large_package.c
+++ b/objects/UML/large_package.c
@@ -237,9 +237,8 @@ largepackage_move(LargePackage *pkg, Point *to)
 }
 
 static void
-largepackage_draw(LargePackage *pkg, DiaRenderer *renderer)
+largepackage_draw (LargePackage *pkg, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point p1, p2;
@@ -254,43 +253,53 @@ largepackage_draw(LargePackage *pkg, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, pkg->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, pkg->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
 
   p1.x = x; p1.y = y;
   p2.x = x+w; p2.y = y+h;
-  renderer_ops->draw_rect (renderer,
-                          &p1, &p2,
-                          &pkg->fill_color,
-                          &pkg->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &pkg->fill_color,
+                          &pkg->line_color);
 
   p1.x= x; p1.y = y - pkg->topheight;
   p2.x = x + pkg->topwidth; p2.y = y;
-  renderer_ops->draw_rect (renderer,
-                          &p1, &p2,
-                          &pkg->fill_color,
-                          &pkg->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &pkg->fill_color,
+                          &pkg->line_color);
 
-  renderer_ops->set_font(renderer, pkg->font, pkg->font_height);
+  dia_renderer_set_font (renderer, pkg->font, pkg->font_height);
 
   p1.x = x + 0.1;
   p1.y = y - pkg->font_height -
-      dia_font_descent(pkg->st_stereotype,
-                       pkg->font, pkg->font_height) - 0.1;
+      dia_font_descent (pkg->st_stereotype,
+                        pkg->font,
+                        pkg->font_height) - 0.1;
 
 
 
   if (pkg->st_stereotype && pkg->st_stereotype[0] != '\0') {
-    renderer_ops->draw_string(renderer, pkg->st_stereotype, &p1,
-                              ALIGN_LEFT, &pkg->text_color);
+    dia_renderer_draw_string (renderer,
+                              pkg->st_stereotype,
+                              &p1,
+                              ALIGN_LEFT,
+                              &pkg->text_color);
   }
   p1.y += pkg->font_height;
 
-  if (pkg->name)
-    renderer_ops->draw_string(renderer, pkg->name, &p1,
-                              ALIGN_LEFT, &pkg->text_color);
+  if (pkg->name) {
+    dia_renderer_draw_string (renderer,
+                              pkg->name,
+                              &p1,
+                              ALIGN_LEFT,
+                              &pkg->text_color);
+  }
 }
 
 static void
diff --git a/objects/UML/lifeline.c b/objects/UML/lifeline.c
index 357f5bc0..be2d9078 100644
--- a/objects/UML/lifeline.c
+++ b/objects/UML/lifeline.c
@@ -358,9 +358,8 @@ lifeline_move(Lifeline *lifeline, Point *to)
 }
 
 static void
-lifeline_draw(Lifeline *lifeline, DiaRenderer *renderer)
+lifeline_draw (Lifeline *lifeline, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints, p1, p2;
 
   assert(lifeline != NULL);
@@ -368,8 +367,8 @@ lifeline_draw(Lifeline *lifeline, DiaRenderer *renderer)
 
   endpoints = &lifeline->connection.endpoints[0];
 
-  renderer_ops->set_linewidth(renderer, LIFELINE_LINEWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, LIFELINE_DASHLEN);
+  dia_renderer_set_linewidth (renderer, LIFELINE_LINEWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, LIFELINE_DASHLEN);
 
   /* Ok, instead rendering one big line between two endpoints we just
      from endpoints to rtop and rbottom respectively.
@@ -379,16 +378,18 @@ lifeline_draw(Lifeline *lifeline, DiaRenderer *renderer)
   p1.x = p2.x = endpoints[0].x;
   p1.y = endpoints[0].y + lifeline->rtop;
   p2.y = endpoints[0].y + lifeline->rbot;
-  renderer_ops->draw_line(renderer,
-                          &endpoints[0], &p1,
-                          &lifeline->line_color);
-  renderer_ops->draw_line(renderer,
-                          &p2, &endpoints[1],
-                          &lifeline->line_color);
+  dia_renderer_draw_line (renderer,
+                          &endpoints[0],
+                          &p1,
+                          &lifeline->line_color);
+  dia_renderer_draw_line (renderer,
+                          &p2,
+                          &endpoints[1],
+                          &lifeline->line_color);
 
 
-  renderer_ops->set_linewidth(renderer, LIFELINE_BOXWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, LIFELINE_BOXWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   p1.x = endpoints[0].x - LIFELINE_WIDTH/2.0;
   p1.y = endpoints[0].y + lifeline->rtop;
@@ -396,27 +397,29 @@ lifeline_draw(Lifeline *lifeline, DiaRenderer *renderer)
   p2.y = endpoints[0].y + lifeline->rbot;
 
   if (lifeline->draw_focuscontrol) {
-      renderer_ops->draw_rect(renderer,
-                              &p1, &p2,
-                              &lifeline->fill_color,
-                              &lifeline->line_color);
+    dia_renderer_draw_rect (renderer,
+                            &p1,
+                            &p2,
+                            &lifeline->fill_color,
+                            &lifeline->line_color);
   }
 
   if (lifeline->draw_cross) {
-      renderer_ops->set_linewidth(renderer, LIFELINE_CROSSWIDTH);
-      p1.x = endpoints[1].x + LIFELINE_CROSSLEN;
-      p2.x = endpoints[1].x - LIFELINE_CROSSLEN;
-      p1.y = endpoints[1].y + LIFELINE_CROSSLEN;
-      p2.y = endpoints[1].y - LIFELINE_CROSSLEN;
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &lifeline->line_color);
-      p1.y = p2.y;
-      p2.y = endpoints[1].y + LIFELINE_CROSSLEN;
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &lifeline->line_color);
-
+    dia_renderer_set_linewidth (renderer, LIFELINE_CROSSWIDTH);
+    p1.x = endpoints[1].x + LIFELINE_CROSSLEN;
+    p2.x = endpoints[1].x - LIFELINE_CROSSLEN;
+    p1.y = endpoints[1].y + LIFELINE_CROSSLEN;
+    p2.y = endpoints[1].y - LIFELINE_CROSSLEN;
+    dia_renderer_draw_line (renderer,
+                            &p1,
+                            &p2,
+                            &lifeline->line_color);
+    p1.y = p2.y;
+    p2.y = endpoints[1].y + LIFELINE_CROSSLEN;
+    dia_renderer_draw_line (renderer,
+                            &p1,
+                            &p2,
+                            &lifeline->line_color);
   }
 }
 
diff --git a/objects/UML/message.c b/objects/UML/message.c
index 2e29ad80..ff61afee 100644
--- a/objects/UML/message.c
+++ b/objects/UML/message.c
@@ -276,9 +276,8 @@ message_move(Message *message, Point *to)
 }
 
 static void
-message_draw(Message *message, DiaRenderer *renderer)
+message_draw (Message *message, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints, p1, p2, px;
   Arrow arrow;
   int n1 = 1, n2 = 0;
@@ -288,75 +287,80 @@ message_draw(Message *message, DiaRenderer *renderer)
   assert(renderer != NULL);
 
   if (message->type==MESSAGE_SEND)
-      arrow.type = ARROW_HALF_HEAD;
+    arrow.type = ARROW_HALF_HEAD;
   else if (message->type==MESSAGE_SIMPLE)
-      arrow.type = ARROW_LINES;
+    arrow.type = ARROW_LINES;
   else
-      arrow.type = ARROW_FILLED_TRIANGLE;
+    arrow.type = ARROW_FILLED_TRIANGLE;
   arrow.length = MESSAGE_ARROWLEN;
   arrow.width = MESSAGE_ARROWWIDTH;
 
   endpoints = &message->connection.endpoints[0];
 
-  renderer_ops->set_linewidth(renderer, message->line_width);
+  dia_renderer_set_linewidth (renderer, message->line_width);
 
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (message->type==MESSAGE_RECURSIVE) {
-      n1 = 0;
-      n2 = 1;
+    n1 = 0;
+    n2 = 1;
   }
 
   if (message->type==MESSAGE_RETURN) {
-      renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, MESSAGE_DASHLEN);
-      n1 = 0;
-      n2 = 1;
+    dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, MESSAGE_DASHLEN);
+    n1 = 0;
+    n2 = 1;
   } else {
-      renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
   }
   p1 = endpoints[n1];
   p2 = endpoints[n2];
 
   if (message->type==MESSAGE_RECURSIVE) {
-      px.x = p2.x;
-      px.y = p1.y;
-      renderer_ops->draw_line(renderer,
-                              &p1, &px,
-                              &message->line_color);
-
-      renderer_ops->draw_line(renderer,
-                          &px, &p2,
-                          &message->line_color);
-      p1.y = p2.y;
+    px.x = p2.x;
+    px.y = p1.y;
+    dia_renderer_draw_line (renderer,
+                            &p1,
+                            &px,
+                            &message->line_color);
+
+    dia_renderer_draw_line (renderer,
+                            &px,
+                            &p2,
+                            &message->line_color);
+    p1.y = p2.y;
   }
 
-  renderer_ops->draw_line_with_arrows(renderer,
-                                      &p1, &p2,
-                                      message->line_width,
-                                      &message->line_color,
-                                      &arrow, NULL);
+  dia_renderer_draw_line_with_arrows (renderer,
+                                      &p1,
+                                      &p2,
+                                      message->line_width,
+                                      &message->line_color,
+                                      &arrow,
+                                      NULL);
 
-  renderer_ops->set_font(renderer, message->font,
-                         message->font_height);
+  dia_renderer_set_font (renderer,
+                         message->font,
+                         message->font_height);
 
   if (message->type==MESSAGE_CREATE)
-         mname = g_strdup_printf ("%s%s%s", UML_STEREOTYPE_START, "create", UML_STEREOTYPE_END);
+    mname = g_strdup_printf ("%s%s%s", UML_STEREOTYPE_START, "create", UML_STEREOTYPE_END);
   else if (message->type==MESSAGE_DESTROY)
-         mname = g_strdup_printf ("%s%s%s", UML_STEREOTYPE_START, "destroy", UML_STEREOTYPE_END);
+    mname = g_strdup_printf ("%s%s%s", UML_STEREOTYPE_START, "destroy", UML_STEREOTYPE_END);
   else
-         mname = message->text;
-
-  if (mname && strlen(mname) != 0)
-      renderer_ops->draw_string(renderer,
-                                mname, /*message->text,*/
-                                &message->text_pos, ALIGN_CENTER,
-                                &message->text_color);
-  if (message->type == MESSAGE_CREATE || message->type == MESSAGE_DESTROY)
-  {
-         g_free(mname);
+    mname = message->text;
+
+  if (mname && strlen (mname) != 0) {
+    dia_renderer_draw_string (renderer,
+                              mname, /*message->text,*/
+                              &message->text_pos,
+                              ALIGN_CENTER,
+                              &message->text_color);
   }
 
-
+  if (message->type == MESSAGE_CREATE || message->type == MESSAGE_DESTROY) {
+    g_free(mname);
+  }
 }
 
 static DiaObject *
diff --git a/objects/UML/node.c b/objects/UML/node.c
index 7af92729..0e42ed2a 100644
--- a/objects/UML/node.c
+++ b/objects/UML/node.c
@@ -223,9 +223,9 @@ node_move(Node *node, Point *to)
   return NULL;
 }
 
-static void node_draw(Node *node, DiaRenderer *renderer)
+static void
+node_draw (Node *node, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point points[7];
@@ -241,9 +241,9 @@ static void node_draw(Node *node, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, node->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, node->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   /* Draw outer box */
   points[0].x = x;                  points[0].y = y;
@@ -254,34 +254,33 @@ static void node_draw(Node *node, DiaRenderer *renderer)
   points[5].x = x;                  points[5].y = y + h;
   points[6].x = x;                  points[6].y = y;
 
-  renderer_ops->draw_polygon(renderer, points, 7, &node->fill_color, &node->line_color);
+  dia_renderer_draw_polygon (renderer, points, 7, &node->fill_color, &node->line_color);
 
   /* Draw interior lines */
   points[0].x = x;                  points[0].y = y;
   points[1].x = x + w;              points[1].y = y;
-  renderer_ops->draw_line(renderer, &points[0], &points[1], &node->line_color);
+  dia_renderer_draw_line (renderer, &points[0], &points[1], &node->line_color);
 
   points[0].x = x + w;              points[0].y = y;
   points[1].x = x + w + NODE_DEPTH; points[1].y = y - NODE_DEPTH;
-  renderer_ops->draw_line(renderer, &points[0], &points[1], &node->line_color);
+  dia_renderer_draw_line (renderer, &points[0], &points[1], &node->line_color);
 
   points[0].x = x + w;              points[0].y = y;
   points[1].x = x + w;              points[1].y = y + h;
-  renderer_ops->draw_line(renderer, &points[0], &points[1], &node->line_color);
+  dia_renderer_draw_line (renderer, &points[0], &points[1], &node->line_color);
 
   /* Draw text */
-  text_draw(node->name, renderer);
+  text_draw (node->name, renderer);
 
   /* Draw underlines (!) */
-  renderer_ops->set_linewidth(renderer, NODE_LINEWIDTH);
+  dia_renderer_set_linewidth (renderer, NODE_LINEWIDTH);
   points[0].x = node->name->position.x;
   points[0].y = points[1].y = node->name->position.y + node->name->descent;
-  for (i = 0; i < node->name->numlines; i++)
-    {
-      points[1].x = points[0].x + text_get_line_width(node->name, i);
-      renderer_ops->draw_line(renderer, points, points + 1, &node->name->color);
-      points[0].y = points[1].y += node->name->height;
-    }
+  for (i = 0; i < node->name->numlines; i++) {
+    points[1].x = points[0].x + text_get_line_width (node->name, i);
+    dia_renderer_draw_line (renderer, points, points + 1, &node->name->color);
+    points[0].y = points[1].y += node->name->height;
+  }
 }
 
 static void
diff --git a/objects/UML/note.c b/objects/UML/note.c
index 0b32c695..e29523d0 100644
--- a/objects/UML/note.c
+++ b/objects/UML/note.c
@@ -209,9 +209,8 @@ note_move(Note *note, Point *to)
 }
 
 static void
-note_draw(Note *note, DiaRenderer *renderer)
+note_draw (Note *note, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point poly[5];
@@ -226,9 +225,9 @@ note_draw(Note *note, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, note->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, note->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   poly[0].x = x;
   poly[0].y = y;
@@ -241,22 +240,24 @@ note_draw(Note *note, DiaRenderer *renderer)
   poly[4].x = x;
   poly[4].y = y+h;
 
-  renderer_ops->draw_polygon(renderer,
-                             poly, 5,
-                             &note->fill_color,
-                             &note->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             poly,
+                             5,
+                             &note->fill_color,
+                             &note->line_color);
 
   poly[0] = poly[1];
   poly[1].x = x + w - NOTE_CORNER;
   poly[1].y = y + NOTE_CORNER;
   poly[2] = poly[2];
 
-  renderer_ops->set_linewidth(renderer, note->line_width / 2);
-  renderer_ops->draw_polyline(renderer,
-                          poly, 3,
-                          &note->line_color);
+  dia_renderer_set_linewidth (renderer, note->line_width / 2);
+  dia_renderer_draw_polyline (renderer,
+                              poly,
+                              3,
+                              &note->line_color);
 
-  text_draw(note->text, renderer);
+  text_draw (note->text, renderer);
 }
 
 static void
diff --git a/objects/UML/object.c b/objects/UML/object.c
index b41d6d23..7a656740 100644
--- a/objects/UML/object.c
+++ b/objects/UML/object.c
@@ -270,9 +270,8 @@ objet_move(Objet *ob, Point *to)
 }
 
 static void
-objet_draw(Objet *ob, DiaRenderer *renderer)
+objet_draw (Objet *ob, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real bw, x, y, w, h;
   Point p1, p2;
@@ -290,78 +289,84 @@ objet_draw(Objet *ob, DiaRenderer *renderer)
 
   bw = (ob->is_active) ? OBJET_ACTIVEBORDERWIDTH: ob->line_width;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, bw);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, bw);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
 
   p1.x = x; p1.y = y;
   p2.x = x+w; p2.y = y+h;
 
   if (ob->is_multiple) {
-    p1.x += OBJET_MARGIN_M(ob);
-    p2.y -= OBJET_MARGIN_M(ob);
-    renderer_ops->draw_rect(renderer,
-                            &p1, &p2,
-                            &ob->fill_color,
-                            &ob->line_color);
-    p1.x -= OBJET_MARGIN_M(ob);
-    p1.y += OBJET_MARGIN_M(ob);
-    p2.x -= OBJET_MARGIN_M(ob);
-    p2.y += OBJET_MARGIN_M(ob);
+    p1.x += OBJET_MARGIN_M (ob);
+    p2.y -= OBJET_MARGIN_M (ob);
+    dia_renderer_draw_rect (renderer,
+                            &p1,
+                            &p2,
+                            &ob->fill_color,
+                            &ob->line_color);
+    p1.x -= OBJET_MARGIN_M (ob);
+    p1.y += OBJET_MARGIN_M (ob);
+    p2.x -= OBJET_MARGIN_M (ob);
+    p2.y += OBJET_MARGIN_M (ob);
   }
 
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &ob->fill_color,
-                          &ob->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &ob->fill_color,
+                          &ob->line_color);
 
 
-  text_draw(ob->text, renderer);
+  text_draw (ob->text, renderer);
 
-  renderer_ops->set_font(renderer, ob->text->font, ob->text->height);
+  dia_renderer_set_font (renderer, ob->text->font, ob->text->height);
 
   if ((ob->st_stereotype != NULL) && (ob->st_stereotype[0] != '\0')) {
-      renderer_ops->draw_string(renderer,
-                                ob->st_stereotype,
-                                &ob->st_pos, ALIGN_CENTER,
-                                &ob->text_attrs.color);
+    dia_renderer_draw_string (renderer,
+                              ob->st_stereotype,
+                              &ob->st_pos,
+                              ALIGN_CENTER,
+                              &ob->text_attrs.color);
   }
 
   if ((ob->exstate != NULL) && (ob->exstate[0] != '\0')) {
-      renderer_ops->draw_string(renderer,
-                                ob->exstate,
-                                &ob->ex_pos, ALIGN_CENTER,
-                                &ob->text_attrs.color);
+    dia_renderer_draw_string (renderer,
+                              ob->exstate,
+                              &ob->ex_pos,
+                              ALIGN_CENTER,
+                              &ob->text_attrs.color);
   }
 
   /* Is there a better way to underline? */
-  p1.x = x + (w - text_get_max_width(ob->text))/2;
-  p1.y = ob->text->position.y + text_get_descent(ob->text);
-  p2.x = p1.x + text_get_max_width(ob->text);
+  p1.x = x + (w - text_get_max_width (ob->text))/2;
+  p1.y = ob->text->position.y + text_get_descent (ob->text);
+  p2.x = p1.x + text_get_max_width (ob->text);
   p2.y = p1.y;
 
-  renderer_ops->set_linewidth(renderer, ob->line_width/2);
+  dia_renderer_set_linewidth (renderer, ob->line_width/2);
 
   for (i=0; i<ob->text->numlines; i++) {
-    p1.x = x + (w - text_get_line_width(ob->text, i))/2;
-    p2.x = p1.x + text_get_line_width(ob->text, i);
-    renderer_ops->draw_line(renderer,
-                            &p1, &p2,
-                            &ob->text_attrs.color);
+    p1.x = x + (w - text_get_line_width (ob->text, i))/2;
+    p2.x = p1.x + text_get_line_width (ob->text, i);
+    dia_renderer_draw_line (renderer,
+                            &p1,
+                            &p2,
+                            &ob->text_attrs.color);
     p1.y = p2.y += ob->text->height;
   }
 
   if (ob->show_attributes) {
-      p1.x = x; p2.x = x + w;
-      p1.y = p2.y = ob->attributes->position.y - ob->attributes->ascent - OBJET_MARGIN_Y(ob);
+    p1.x = x; p2.x = x + w;
+    p1.y = p2.y = ob->attributes->position.y - ob->attributes->ascent - OBJET_MARGIN_Y (ob);
 
-      renderer_ops->set_linewidth(renderer, bw);
-      renderer_ops->draw_line(renderer,
-                              &p1, &p2,
-                              &ob->line_color);
+    dia_renderer_set_linewidth (renderer, bw);
+    dia_renderer_draw_line (renderer,
+                            &p1,
+                            &p2,
+                            &ob->line_color);
 
-      text_draw(ob->attributes, renderer);
+    text_draw (ob->attributes, renderer);
   }
 }
 
diff --git a/objects/UML/realizes.c b/objects/UML/realizes.c
index 9d7c0cfd..74b134ac 100644
--- a/objects/UML/realizes.c
+++ b/objects/UML/realizes.c
@@ -215,9 +215,8 @@ realizes_move(Realizes *realize, Point *to)
 }
 
 static void
-realizes_draw(Realizes *realize, DiaRenderer *renderer)
+realizes_draw (Realizes *realize, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &realize->orth;
   Point *points;
   int n;
@@ -227,38 +226,42 @@ realizes_draw(Realizes *realize, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, realize->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, REALIZES_DASHLEN);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, realize->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, REALIZES_DASHLEN);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   arrow.type = ARROW_HOLLOW_TRIANGLE;
   arrow.width = REALIZES_TRIANGLESIZE;
   arrow.length = REALIZES_TRIANGLESIZE;
-  renderer_ops->draw_polyline_with_arrows(renderer, points, n,
-                                          realize->line_width,
-                                          &realize->line_color,
-                                          &arrow, NULL);
-
-  renderer_ops->set_font(renderer, realize->font, realize->font_height);
+  dia_renderer_draw_polyline_with_arrows (renderer,
+                                          points,
+                                          n,
+                                          realize->line_width,
+                                          &realize->line_color,
+                                          &arrow,
+                                          NULL);
+
+  dia_renderer_set_font (renderer, realize->font, realize->font_height);
   pos = realize->text_pos;
 
   if (realize->st_stereotype != NULL && realize->st_stereotype[0] != '\0') {
-    renderer_ops->draw_string(renderer,
-                              realize->st_stereotype,
-                              &pos, realize->text_align,
-                              &realize->text_color);
+    dia_renderer_draw_string (renderer,
+                              realize->st_stereotype,
+                              &pos,
+                              realize->text_align,
+                              &realize->text_color);
 
     pos.y += realize->font_height;
   }
 
   if (realize->name != NULL && realize->name[0] != '\0') {
-    renderer_ops->draw_string(renderer,
-                              realize->name,
-                              &pos, realize->text_align,
-                              &realize->text_color);
+    dia_renderer_draw_string (renderer,
+                              realize->name,
+                              &pos,
+                              realize->text_align,
+                              &realize->text_color);
   }
-
 }
 
 static void
diff --git a/objects/UML/small_package.c b/objects/UML/small_package.c
index 33b885d1..1a710142 100644
--- a/objects/UML/small_package.c
+++ b/objects/UML/small_package.c
@@ -231,9 +231,8 @@ smallpackage_move(SmallPackage *pkg, Point *to)
 }
 
 static void
-smallpackage_draw(SmallPackage *pkg, DiaRenderer *renderer)
+smallpackage_draw (SmallPackage *pkg, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point p1, p2;
@@ -248,35 +247,40 @@ smallpackage_draw(SmallPackage *pkg, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, pkg->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, pkg->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   p1.x = x; p1.y = y;
   p2.x = x+w; p2.y = y+h;
 
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &pkg->fill_color,
-                          &pkg->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &pkg->fill_color,
+                          &pkg->line_color);
 
   p1.x= x; p1.y = y-SMALLPACKAGE_TOPHEIGHT;
   p2.x = x+SMALLPACKAGE_TOPWIDTH; p2.y = y;
 
-  renderer_ops->draw_rect(renderer,
-                          &p1, &p2,
-                          &pkg->fill_color,
-                          &pkg->line_color);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &pkg->fill_color,
+                          &pkg->line_color);
 
   text_draw(pkg->text, renderer);
 
   if ((pkg->st_stereotype != NULL) && (pkg->st_stereotype[0] != '\0')) {
-    renderer_ops->set_font(renderer, pkg->text->font, pkg->text->height);
+    dia_renderer_set_font (renderer, pkg->text->font, pkg->text->height);
 
     p1 = pkg->text->position;
     p1.y -= pkg->text->height;
-    renderer_ops->draw_string(renderer, pkg->st_stereotype, &p1,
-                              ALIGN_LEFT, &pkg->text->color);
+    dia_renderer_draw_string (renderer,
+                              pkg->st_stereotype,
+                              &p1,
+                              ALIGN_LEFT,
+                              &pkg->text->color);
   }
 }
 
diff --git a/objects/UML/state.c b/objects/UML/state.c
index 49a81499..6f09a3d1 100644
--- a/objects/UML/state.c
+++ b/objects/UML/state.c
@@ -245,25 +245,23 @@ state_move(State *state, Point *to)
 }
 
 static void
-state_draw_action_string(State *state, DiaRenderer *renderer, StateAction action)
+state_draw_action_string (State *state, DiaRenderer *renderer, StateAction action)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pos;
-  gchar* action_text = state_get_action_text(state, action);
-  state_calc_action_text_pos(state, action, &pos);
-  renderer_ops->set_font(renderer, state->text->font, state->text->height);
-  renderer_ops->draw_string(renderer,
+  gchar* action_text = state_get_action_text (state, action);
+  state_calc_action_text_pos (state, action, &pos);
+  dia_renderer_set_font (renderer, state->text->font, state->text->height);
+  dia_renderer_draw_string (renderer,
                             action_text,
                             &pos,
                             ALIGN_LEFT,
                             &state->text->color);
-  g_free(action_text);
+  g_free (action_text);
 }
 
 static void
-state_draw(State *state, DiaRenderer *renderer)
+state_draw (State *state, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h, r;
   Point p1, p2, split_line_left, split_line_right;
@@ -279,58 +277,67 @@ state_draw(State *state, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, state->line_width);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, state->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   if (state->state_type!=STATE_NORMAL) {
-      p1.x = x + w/2;
-      p1.y = y + h/2;
-      if (state->state_type==STATE_END) {
-         r = STATE_ENDRATIO;
-         renderer_ops->draw_ellipse (renderer,
-                                     &p1,
-                                     r, r,
-                                     &state->fill_color, &state->line_color);
-      }
-      r = STATE_RATIO;
-      renderer_ops->draw_ellipse (renderer,
-                                 &p1,
-                                 r, r,
-                                 NULL, &state->line_color);
+    p1.x = x + w/2;
+    p1.y = y + h/2;
+    if (state->state_type==STATE_END) {
+      r = STATE_ENDRATIO;
+      dia_renderer_draw_ellipse (renderer,
+                                 &p1,
+                                 r,
+                                 r,
+                                 &state->fill_color,
+                                 &state->line_color);
+    }
+    r = STATE_RATIO;
+    dia_renderer_draw_ellipse (renderer,
+                               &p1,
+                               r,
+                               r,
+                               NULL,
+                               &state->line_color);
   } else {
-      p1.x = x;
-      p1.y = y;
-      p2.x = x + w;
-      p2.y = y + h;
-      renderer_ops->draw_rounded_rect(renderer, &p1, &p2,
-                                     &state->fill_color, &state->line_color,
-                                     0.5);
-
-      text_draw(state->text, renderer);
-      has_actions = FALSE;
-      if (state->entry_action && strlen(state->entry_action) != 0) {
-          state_draw_action_string(state, renderer, ENTRY_ACTION);
-          has_actions = TRUE;
-      }
-      if (state->do_action && strlen(state->do_action) != 0) {
-          state_draw_action_string(state, renderer, DO_ACTION);
-          has_actions = TRUE;
-      }
-      if (state->exit_action && strlen(state->exit_action) != 0) {
-          state_draw_action_string(state, renderer, EXIT_ACTION);
-          has_actions = TRUE;
-      }
-
-      if (has_actions) {
-        split_line_left.x = x;
-        split_line_right.x = x+w;
-        split_line_left.y = split_line_right.y
-                          = state->element.corner.y + STATE_MARGIN_Y +
-                            state->text->numlines*state->text->height;
-        renderer_ops->draw_line(renderer, &split_line_left, &split_line_right,
-                                &state->line_color);
-      }
+    p1.x = x;
+    p1.y = y;
+    p2.x = x + w;
+    p2.y = y + h;
+    dia_renderer_draw_rounded_rect (renderer,
+                                    &p1,
+                                    &p2,
+                                    &state->fill_color,
+                                    &state->line_color,
+                                    0.5);
+
+    text_draw (state->text, renderer);
+    has_actions = FALSE;
+    if (state->entry_action && strlen (state->entry_action) != 0) {
+      state_draw_action_string (state, renderer, ENTRY_ACTION);
+      has_actions = TRUE;
+    }
+    if (state->do_action && strlen (state->do_action) != 0) {
+      state_draw_action_string (state, renderer, DO_ACTION);
+      has_actions = TRUE;
+    }
+    if (state->exit_action && strlen (state->exit_action) != 0) {
+      state_draw_action_string (state, renderer, EXIT_ACTION);
+      has_actions = TRUE;
+    }
+
+    if (has_actions) {
+      split_line_left.x = x;
+      split_line_right.x = x+w;
+      split_line_left.y = split_line_right.y
+                        = state->element.corner.y + STATE_MARGIN_Y +
+                          state->text->numlines*state->text->height;
+      dia_renderer_draw_line (renderer,
+                              &split_line_left,
+                              &split_line_right,
+                              &state->line_color);
+    }
   }
 }
 
diff --git a/objects/UML/state_term.c b/objects/UML/state_term.c
index 7668e3b6..d525770b 100644
--- a/objects/UML/state_term.c
+++ b/objects/UML/state_term.c
@@ -192,9 +192,8 @@ state_move(State *state, Point *to)
 }
 
 static void
-state_draw(State *state, DiaRenderer *renderer)
+state_draw (State *state, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h, r;
   Point p1;
@@ -209,24 +208,28 @@ state_draw(State *state, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, STATE_LINEWIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0);
-
-   p1.x = x + w/2;
-   p1.y = y + h/2;
-   if (state->is_final==1) {
-      r = STATE_ENDRATIO;
-      renderer_ops->draw_ellipse (renderer,
-                                 &p1,
-                                 r, r,
-                                 &state->fill_color, &state->line_color);
-   }
-   r = STATE_RATIO;
-   renderer_ops->draw_ellipse (renderer,
-                              &p1,
-                              r, r,
-                              &state->line_color, NULL); /* line_color not a typo! */
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, STATE_LINEWIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0);
+
+  p1.x = x + w/2;
+  p1.y = y + h/2;
+  if (state->is_final==1) {
+    r = STATE_ENDRATIO;
+    dia_renderer_draw_ellipse (renderer,
+                                &p1,
+                                r,
+                                r,
+                                &state->fill_color,
+                                &state->line_color);
+  }
+  r = STATE_RATIO;
+  dia_renderer_draw_ellipse (renderer,
+                            &p1,
+                            r,
+                            r,
+                            &state->line_color,
+                            NULL); /* line_color not a typo! */
 }
 
 
diff --git a/objects/UML/transition.c b/objects/UML/transition.c
index 1886d283..50a38d83 100644
--- a/objects/UML/transition.c
+++ b/objects/UML/transition.c
@@ -329,9 +329,9 @@ static gchar* create_guard_text(Transition* transition)
   return temp_text;
 }
 
-static void transition_draw(Transition* transition, DiaRenderer* renderer)
+static void
+transition_draw (Transition* transition, DiaRenderer* renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS(renderer);
   Arrow arrow;
   Arrow *start_arrow;
   Arrow *end_arrow;
@@ -354,52 +354,51 @@ static void transition_draw(Transition* transition, DiaRenderer* renderer)
 
   /* Is it necessary to call set_linewidth? The draw_line_with_arrows() method
      got a linewidth parameter... */
-  renderer_ops->set_linewidth(renderer, TRANSITION_WIDTH);
+  dia_renderer_set_linewidth (renderer, TRANSITION_WIDTH);
   /* TODO, find out about the meaning of this... */
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   if (transition->direction_inverted) {
-      start_arrow = &arrow;
-      end_arrow = NULL;
-  }
-  else {
-      start_arrow = NULL;
-      end_arrow = & arrow;
+    start_arrow = &arrow;
+    end_arrow = NULL;
+  } else {
+    start_arrow = NULL;
+    end_arrow = & arrow;
   }
-  renderer_ops->draw_polyline_with_arrows(renderer, points, num_points,
+  dia_renderer_draw_polyline_with_arrows (renderer,
+                                          points,
+                                          num_points,
                                           TRANSITION_WIDTH,
                                           &transition->line_color,
                                           start_arrow, end_arrow);
 
 
-  renderer_ops->set_font(renderer, transition_font,
+  dia_renderer_set_font (renderer,
+                         transition_font,
                          TRANSITION_FONTHEIGHT);
 
   /* Draw the guard text */
-  if (transition->guard_text && strlen(transition->guard_text) != 0)
-  {
-    gchar *text = create_guard_text(transition);
-    renderer_ops->draw_string(renderer,
+  if (transition->guard_text && strlen (transition->guard_text) != 0) {
+    gchar *text = create_guard_text (transition);
+    dia_renderer_draw_string (renderer,
                               text,
                               &transition->guard_text_pos,
                               ALIGN_CENTER,
                               &transition->text_color);
-    g_free(text);
+    g_free (text);
   }
 
   /* Draw the trigger text */
-  if (transition->trigger_text && strlen(transition->trigger_text) != 0)
-  {
-    gchar *text = create_event_action_text(transition);
-    renderer_ops->draw_string(renderer,
+  if (transition->trigger_text && strlen (transition->trigger_text) != 0) {
+    gchar *text = create_event_action_text (transition);
+    dia_renderer_draw_string (renderer,
                               text,
                               &transition->trigger_text_pos,
                               ALIGN_CENTER,
                               &transition->text_color);
     g_free(text);
   }
-
 }
 
 static real
diff --git a/objects/UML/usecase.c b/objects/UML/usecase.c
index 135e86ef..fcad68f5 100644
--- a/objects/UML/usecase.c
+++ b/objects/UML/usecase.c
@@ -230,9 +230,8 @@ usecase_move(Usecase *usecase, Point *to)
 }
 
 static void
-usecase_draw(Usecase *usecase, DiaRenderer *renderer)
+usecase_draw (Usecase *usecase, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   Point c;
@@ -258,20 +257,22 @@ usecase_draw(Usecase *usecase, DiaRenderer *renderer)
   }
 
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, usecase->line_width);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, usecase->line_width);
 
   if (usecase->collaboration)
-    renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, 1.0);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_DASHED, 1.0);
   else
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
-  renderer_ops->draw_ellipse(renderer,
-                            &c,
-                            w, h,
-                            &usecase->fill_color, &usecase->line_color);
+  dia_renderer_draw_ellipse (renderer,
+                             &c,
+                             w,
+                             h,
+                             &usecase->fill_color,
+                             &usecase->line_color);
 
-  text_draw(usecase->text, renderer);
+  text_draw (usecase->text, renderer);
 }
 
 
diff --git a/objects/chronogram/chronoline.c b/objects/chronogram/chronoline.c
index 221da5ae..52e3c3c5 100644
--- a/objects/chronogram/chronoline.c
+++ b/objects/chronogram/chronoline.c
@@ -280,13 +280,14 @@ chronoline_move(Chronoline *chronoline, Point *to)
 }
 
 static void
-cld_onebit(Chronoline *chronoline,
-          DiaRenderer *renderer,
-          real x1,CLEventType s1,
-          real x2,CLEventType s2,
-          gboolean fill)
+cld_onebit (Chronoline  *chronoline,
+            DiaRenderer *renderer,
+            real         x1,
+            CLEventType  s1,
+            real         x2,
+            CLEventType  s2,
+            gboolean     fill)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pts[4];
   real y_down = chronoline->y_down;
   real y_up = chronoline->y_up;
@@ -300,27 +301,36 @@ cld_onebit(Chronoline *chronoline,
 
   if (fill) {
     if ((s1 == CLE_UNKNOWN) || (s2 == CLE_UNKNOWN)) {
-      renderer_ops->draw_polygon(renderer,pts,sizeof(pts)/sizeof(pts[0]),
-                                &chronoline->datagray, NULL);
+      dia_renderer_draw_polygon (renderer,
+                                 pts,
+                                 sizeof(pts)/sizeof(pts[0]),
+                                 &chronoline->datagray,
+                                 NULL);
     } else {
-      renderer_ops->draw_polygon(renderer,pts,sizeof(pts)/sizeof(pts[0]),
-                                &color_white, NULL);
+      dia_renderer_draw_polygon (renderer,
+                                 pts,
+                                 sizeof(pts)/sizeof(pts[0]),
+                                 &color_white,
+                                 NULL);
     }
   } else {
-    renderer_ops->draw_line(renderer,&pts[1],&pts[2],
-                            &chronoline->data_color);
+    dia_renderer_draw_line (renderer,
+                            &pts[1],
+                            &pts[2],
+                            &chronoline->data_color);
   }
 }
 
 
 static void
-cld_multibit(Chronoline *chronoline,
-            DiaRenderer *renderer,
-            real x1,CLEventType s1,
-            real x2,CLEventType s2,
-            gboolean fill)
+cld_multibit (Chronoline  *chronoline,
+              DiaRenderer *renderer,
+              real         x1,
+              CLEventType  s1,
+              real         x2,
+              CLEventType  s2,
+              gboolean     fill)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pts[4];
   real ymid = .5 * (chronoline->y_down + chronoline->y_up);
   real y_down = chronoline->y_down;
@@ -344,27 +354,37 @@ cld_multibit(Chronoline *chronoline,
 
   if (fill) {
     if ((s1 == CLE_UNKNOWN) || (s2 == CLE_UNKNOWN)) {
-      renderer_ops->draw_polygon(renderer,pts,sizeof(pts)/sizeof(pts[0]),
-                                &chronoline->datagray, NULL);
+      dia_renderer_draw_polygon (renderer,
+                                 pts,
+                                 sizeof(pts)/sizeof(pts[0]),
+                                 &chronoline->datagray,
+                                 NULL);
     } else {
-      renderer_ops->draw_polygon(renderer,pts,sizeof(pts)/sizeof(pts[0]),
-                                &color_white, NULL);
+      dia_renderer_draw_polygon (renderer,
+                                 pts,
+                                 sizeof(pts)/sizeof(pts[0]),
+                                 &color_white,
+                                 NULL);
     }
   } else {
-    renderer_ops->draw_line(renderer,&pts[1],&pts[2],
-                            &chronoline->data_color);
-    renderer_ops->draw_line(renderer,&pts[0],&pts[3],
-                            &chronoline->data_color);
+    dia_renderer_draw_line (renderer,
+                            &pts[1],
+                            &pts[2],
+                            &chronoline->data_color);
+    dia_renderer_draw_line (renderer,
+                            &pts[0],
+                            &pts[3],
+                            &chronoline->data_color);
   }
 }
 
 
 
 inline static void
-chronoline_draw_really(Chronoline *chronoline, DiaRenderer *renderer,
-                      gboolean fill)
+chronoline_draw_really (Chronoline  *chronoline,
+                        DiaRenderer *renderer,
+                        gboolean     fill)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem = &chronoline->element;
   real oldx,newx;
 
@@ -379,32 +399,34 @@ chronoline_draw_really(Chronoline *chronoline, DiaRenderer *renderer,
   oldx = elem->corner.x;
 
   lst = chronoline->evtlist;
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linewidth(renderer,chronoline->data_lwidth);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linewidth (renderer, chronoline->data_lwidth);
 
   while (lst) {
     evt = (CLEvent *)lst->data;
     g_assert(evt);
     if (evt->time >= start_time) {
       if (evt->time <= end_time) {
-       /* regular point */
-       newx = evt->x;
-
-       if (chronoline->multibit)
-         cld_multibit(chronoline,renderer,oldx,state,newx,evt->type,fill);
-       else
-         cld_onebit(chronoline,renderer,oldx,state,newx,evt->type,fill);
-       oldx = newx;
+        /* regular point */
+        newx = evt->x;
+
+        if (chronoline->multibit) {
+          cld_multibit(chronoline,renderer,oldx,state,newx,evt->type,fill);
+        } else {
+          cld_onebit(chronoline,renderer,oldx,state,newx,evt->type,fill);
+        }
+        oldx = newx;
       } else {
-       newx = elem->corner.x + elem->width;
-       if (!finished) {
-         if (chronoline->multibit)
-           cld_multibit(chronoline,renderer,oldx,state,newx,evt->type,fill);
-         else
-           cld_onebit(chronoline,renderer,oldx,state,newx,evt->type,fill);
-         finished = TRUE;
-       }
+        newx = elem->corner.x + elem->width;
+        if (!finished) {
+          if (chronoline->multibit) {
+            cld_multibit (chronoline,renderer,oldx,state,newx,evt->type,fill);
+          } else {
+            cld_onebit (chronoline,renderer,oldx,state,newx,evt->type,fill);
+          }
+          finished = TRUE;
+        }
       }
     }
     state = evt->type;
@@ -420,9 +442,8 @@ chronoline_draw_really(Chronoline *chronoline, DiaRenderer *renderer,
 }
 
 static void
-chronoline_draw(Chronoline *chronoline, DiaRenderer *renderer)
+chronoline_draw (Chronoline *chronoline, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   Point lr_corner;
   Point p1,p2,p3;
@@ -432,17 +453,17 @@ chronoline_draw(Chronoline *chronoline, DiaRenderer *renderer)
 
   elem = &chronoline->element;
 
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_DOTTED, 1.0);
-  renderer_ops->set_linewidth(renderer, chronoline->main_lwidth);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_DOTTED, 1.0);
+  dia_renderer_set_linewidth (renderer, chronoline->main_lwidth);
   p1.x = elem->corner.x + elem->width;
   p1.y = elem->corner.y;
-  renderer_ops->draw_line(renderer,&elem->corner,&p1,&chronoline->gray);
+  dia_renderer_draw_line (renderer,&elem->corner,&p1,&chronoline->gray);
 
-  chronoline_draw_really(chronoline,renderer,TRUE);
-  chronoline_draw_really(chronoline,renderer,FALSE);
+  chronoline_draw_really (chronoline,renderer,TRUE);
+  chronoline_draw_really (chronoline,renderer,FALSE);
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
 
   lr_corner.x = elem->corner.x + elem->width;
   lr_corner.y = elem->corner.y + elem->height;
@@ -451,21 +472,26 @@ chronoline_draw(Chronoline *chronoline, DiaRenderer *renderer)
   p2.x = lr_corner.x;
   p1.y = p2.y = chronoline->y_down;
 
-  renderer_ops->set_linewidth(renderer, chronoline->main_lwidth);
-  renderer_ops->draw_line(renderer,&p1,&p2,&chronoline->color);
+  dia_renderer_set_linewidth (renderer, chronoline->main_lwidth);
+  dia_renderer_draw_line (renderer,&p1,&p2,&chronoline->color);
   p2.x = p1.x = elem->corner.x;
   p1.y = chronoline->y_down;
   p2.y = chronoline->y_up;
-  renderer_ops->draw_line(renderer,&p1,&p2,&chronoline->color);
+  dia_renderer_draw_line (renderer,&p1,&p2,&chronoline->color);
 
-  renderer_ops->set_font(renderer, chronoline->font,
-                          chronoline->font_size);
+  dia_renderer_set_font (renderer,
+                         chronoline->font,
+                         chronoline->font_size);
   p3.y = lr_corner.y - chronoline->font_size
-      + dia_font_ascent(chronoline->name,
-                        chronoline->font,chronoline->font_size);
+      + dia_font_ascent (chronoline->name,
+                         chronoline->font,
+                         chronoline->font_size);
   p3.x = p1.x - chronoline->main_lwidth;
-  renderer_ops->draw_string(renderer,chronoline->name,&p3,ALIGN_RIGHT,
-                           &chronoline->font_color);
+  dia_renderer_draw_string (renderer,
+                            chronoline->name,
+                            &p3,
+                            ALIGN_RIGHT,
+                            &chronoline->font_color);
 }
 
 inline static void grayify(Color *col,Color *src)
diff --git a/objects/chronogram/chronoref.c b/objects/chronogram/chronoref.c
index 68069586..4c474107 100644
--- a/objects/chronogram/chronoref.c
+++ b/objects/chronogram/chronoref.c
@@ -261,7 +261,6 @@ chronoref_move(Chronoref *chronoref, Point *to)
 static void
 chronoref_draw(Chronoref *chronoref, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   Point lr_corner;
   real t;
@@ -271,8 +270,8 @@ chronoref_draw(Chronoref *chronoref, DiaRenderer *renderer)
 
   elem = &chronoref->element;
 
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
 
   lr_corner.x = elem->corner.x + elem->width;
@@ -280,43 +279,46 @@ chronoref_draw(Chronoref *chronoref, DiaRenderer *renderer)
 
   p1.y = p2.y = elem->corner.y;
 
-  renderer_ops->set_font(renderer, chronoref->font, chronoref->font_size);
+  dia_renderer_set_font (renderer, chronoref->font, chronoref->font_size);
   p3.y = p2.y + chronoref->majgrad_height +
-    dia_font_ascent("1",chronoref->font, chronoref->font_size);
+    dia_font_ascent ("1",chronoref->font, chronoref->font_size);
 
-  renderer_ops->set_linewidth(renderer, chronoref->light_lwidth);
+  dia_renderer_set_linewidth (renderer, chronoref->light_lwidth);
   if (chronoref->time_lstep > 0.0) {
     p2.y = p1.y + chronoref->mingrad_height;
     for (t = chronoref->firstmaj, p1.x = chronoref->firstmin_x;
-        p1.x <= lr_corner.x;
-        t += chronoref->time_lstep, p1.x += chronoref->mingrad) {
+         p1.x <= lr_corner.x;
+         t += chronoref->time_lstep, p1.x += chronoref->mingrad) {
       p2.x = p1.x;
 
-      renderer_ops->draw_line(renderer,&p1,&p2,&chronoref->color);
+      dia_renderer_draw_line (renderer,&p1,&p2,&chronoref->color);
     }
   }
 
-  renderer_ops->set_linewidth(renderer, chronoref->main_lwidth);
+  dia_renderer_set_linewidth (renderer, chronoref->main_lwidth);
   if (chronoref->time_step > 0.0) {
     p2.y = p1.y + chronoref->majgrad_height;
 
     for (t = chronoref->firstmaj, p1.x = chronoref->firstmaj_x;
-        p1.x <= lr_corner.x;
-        t += chronoref->time_step, p1.x += chronoref->majgrad) {
+         p1.x <= lr_corner.x;
+         t += chronoref->time_step, p1.x += chronoref->majgrad) {
       char time[10];
       p3.x = p2.x = p1.x;
 
-      renderer_ops->draw_line(renderer,&p1,&p2,&chronoref->color);
-      g_snprintf(time,sizeof(time),"%.*f",chronoref->spec,t);
-      renderer_ops->draw_string(renderer,time,&p3,ALIGN_CENTER,
-                                &chronoref->font_color);
+      dia_renderer_draw_line (renderer,&p1,&p2,&chronoref->color);
+      g_snprintf (time,sizeof(time),"%.*f",chronoref->spec,t);
+      dia_renderer_draw_string (renderer,
+                                time,
+                                &p3,
+                                ALIGN_CENTER,
+                                &chronoref->font_color);
     }
   }
   p1.x = elem->corner.x;
   p2.x = lr_corner.x;
   p1.y = p2.y = elem->corner.y;
 
-  renderer_ops->draw_line(renderer,&p1,&p2,&chronoref->color);
+  dia_renderer_draw_line (renderer,&p1,&p2,&chronoref->color);
 }
 
 static void
diff --git a/objects/custom/custom_object.c b/objects/custom/custom_object.c
index 8508a97c..8d13e52a 100644
--- a/objects/custom/custom_object.c
+++ b/objects/custom/custom_object.c
@@ -842,9 +842,8 @@ get_colour(Custom *custom, Color *colour, gint32 c, real opacity)
 }
 
 static void
-custom_draw(Custom *custom, DiaRenderer *renderer)
+custom_draw (Custom *custom, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   static GArray *arr = NULL, *barr = NULL;
   real cur_line = 1.0, cur_dash = 1.0;
   LineCaps cur_caps = LINECAPS_BUTT;
@@ -854,28 +853,36 @@ custom_draw(Custom *custom, DiaRenderer *renderer)
   assert(custom != NULL);
   assert(renderer != NULL);
 
-  if (!arr)
-    arr = g_array_new(FALSE, FALSE, sizeof(Point));
-  if (!barr)
-    barr = g_array_new(FALSE, FALSE, sizeof(BezPoint));
+  if (!arr) {
+    arr = g_array_new (FALSE, FALSE, sizeof(Point));
+  }
+  if (!barr) {
+    barr = g_array_new (FALSE, FALSE, sizeof(BezPoint));
+  }
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, custom->border_width);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linewidth (renderer, custom->border_width);
   cur_line = custom->border_width;
-  renderer_ops->set_linestyle(renderer, cur_style, custom->dashlength);
-  renderer_ops->set_linecaps(renderer, cur_caps);
-  renderer_ops->set_linejoin(renderer, cur_join);
+  dia_renderer_set_linestyle (renderer, cur_style, custom->dashlength);
+  dia_renderer_set_linecaps (renderer, cur_caps);
+  dia_renderer_set_linejoin (renderer, cur_join);
 
   /*
    * Because we do not know if any of these values are reused in the loop, we pass
    * them all by reference.
    * If anyone does know this, please correct/simplify.
    */
-  custom_draw_displaylist(custom->info->display_list, custom, renderer, arr, barr,
-                          &cur_line, &cur_dash, &cur_caps, &cur_join, &cur_style);
+  custom_draw_displaylist (custom->info->display_list,
+                           custom,
+                           renderer, arr, barr,
+                           &cur_line,
+                           &cur_dash,
+                           &cur_caps,
+                           &cur_join,
+                           &cur_style);
 
   if (custom->info->has_text) {
-    text_draw(custom->text, renderer);
+    text_draw (custom->text, renderer);
   }
 }
 
@@ -900,12 +907,19 @@ custom_draw_displaylist(GList *display_list, Custom *custom, DiaRenderer *render
 }
 
 static void
-custom_draw_element(GraphicElement* el, Custom *custom, DiaRenderer *renderer,
-                    GArray *arr, GArray *barr, real* cur_line, real* cur_dash,
-                    LineCaps* cur_caps, LineJoin* cur_join, LineStyle* cur_style,
-                    Color* fg, Color* bg)
+custom_draw_element (GraphicElement *el,
+                     Custom         *custom,
+                     DiaRenderer    *renderer,
+                     GArray         *arr,
+                     GArray         *barr,
+                     real           *cur_line,
+                     real           *cur_dash,
+                     LineCaps       *cur_caps,
+                     LineJoin       *cur_join,
+                     LineStyle      *cur_style,
+                     Color          *fg,
+                     Color          *bg)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point p1, p2;
   real width, height;
   real coord;
@@ -918,155 +932,197 @@ custom_draw_element(GraphicElement* el, Custom *custom, DiaRenderer *renderer,
    */
   if (fabs (el->any.s.line_width - (*cur_line)) > 0.001) {
     (*cur_line) = el->any.s.line_width;
-    renderer_ops->set_linewidth(renderer,
-                 custom->border_width*(*cur_line));
+    dia_renderer_set_linewidth (renderer,
+                                custom->border_width * (*cur_line));
   }
   if ((el->any.s.linecap == LINECAPS_DEFAULT && (*cur_caps) != LINECAPS_BUTT) ||
-    el->any.s.linecap != (*cur_caps)) {
-      (*cur_caps) = (el->any.s.linecap!=LINECAPS_DEFAULT) ?
-      el->any.s.linecap : LINECAPS_BUTT;
-      renderer_ops->set_linecaps(renderer, (*cur_caps));
-    }
+      el->any.s.linecap != (*cur_caps)) {
+    (*cur_caps) = (el->any.s.linecap!=LINECAPS_DEFAULT) ?
+                      el->any.s.linecap : LINECAPS_BUTT;
+    dia_renderer_set_linecaps (renderer, (*cur_caps));
+  }
   if ((el->any.s.linejoin==LINEJOIN_DEFAULT && (*cur_join)!=LINEJOIN_MITER) ||
       el->any.s.linejoin != (*cur_join)) {
     (*cur_join) = (el->any.s.linejoin!=LINEJOIN_DEFAULT) ?
-    el->any.s.linejoin : LINEJOIN_MITER;
-    renderer_ops->set_linejoin(renderer, (*cur_join));
+                      el->any.s.linejoin : LINEJOIN_MITER;
+    dia_renderer_set_linejoin (renderer, (*cur_join));
   }
   if ((el->any.s.linestyle == LINESTYLE_DEFAULT &&
       (*cur_style) != custom->line_style) || el->any.s.linestyle != (*cur_style)) {
     (*cur_style) = (el->any.s.linestyle!=LINESTYLE_DEFAULT) ?
-    el->any.s.linestyle : custom->line_style;
-    renderer_ops->set_linestyle(renderer, (*cur_style),
-                               custom->dashlength*(*cur_dash));
+                      el->any.s.linestyle : custom->line_style;
+    dia_renderer_set_linestyle (renderer, (*cur_style),
+                                custom->dashlength*(*cur_dash));
   }
   if (el->any.s.dashlength != (*cur_dash)) {
     (*cur_dash) = el->any.s.dashlength;
-    renderer_ops->set_linestyle(renderer, (*cur_style),
-                               custom->dashlength*(*cur_dash));
+    dia_renderer_set_linestyle (renderer,
+                                (*cur_style),
+                                custom->dashlength*(*cur_dash));
   }
 
   (*cur_line) = el->any.s.line_width;
-  get_colour(custom, fg, el->any.s.stroke, el->any.s.stroke_opacity);
-  get_colour(custom, bg, el->any.s.fill, el->any.s.fill_opacity);
+  get_colour (custom, fg, el->any.s.stroke, el->any.s.stroke_opacity);
+  get_colour (custom, bg, el->any.s.fill, el->any.s.fill_opacity);
   switch (el->type) {
-  case GE_LINE:
-    transform_coord(custom, &el->line.p1, &p1);
-    transform_coord(custom, &el->line.p2, &p2);
-    if (el->any.s.stroke != DIA_SVG_COLOUR_NONE)
-      renderer_ops->draw_line(renderer, &p1, &p2, fg);
-    break;
-  case GE_POLYLINE:
-    g_array_set_size(arr, el->polyline.npoints);
-    for (i = 0; i < el->polyline.npoints; i++)
-      transform_coord(custom, &el->polyline.points[i],
-                       &g_array_index(arr, Point, i));
-    if (el->any.s.stroke != DIA_SVG_COLOUR_NONE)
-      renderer_ops->draw_polyline(renderer,
-              (Point *)arr->data, el->polyline.npoints,
-                                   fg);
-    break;
-  case GE_POLYGON:
-    g_array_set_size(arr, el->polygon.npoints);
-    for (i = 0; i < el->polygon.npoints; i++)
-      transform_coord(custom, &el->polygon.points[i],
-                       &g_array_index(arr, Point, i));
-    renderer_ops->draw_polygon(renderer,
-                                  (Point *)arr->data, el->polygon.npoints,
-                                  (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE) ? bg : 
NULL,
-                                  (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL);
-    break;
-  case GE_RECT:
-    transform_coord(custom, &el->rect.corner1, &p1);
-    transform_coord(custom, &el->rect.corner2, &p2);
-    radius = custom_transform_length(custom, el->rect.corner_radius);
-    if (p1.x > p2.x) {
-      coord = p1.x;
-      p1.x = p2.x;
-      p2.x = coord;
-    }
-    if (p1.y > p2.y) {
-      coord = p1.y;
-      p1.y = p2.y;
-      p2.y = coord;
-    }
-    /* the renderer implementation will use simple rect with a small enough radius */
-    renderer_ops->draw_rounded_rect(renderer, &p1, &p2,
-                                   (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE) ? bg : 
NULL,
-                                   (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL,
-                                   radius);
-    break;
-  case GE_TEXT:
-    text_set_height (el->text.object, custom_transform_length (custom, el->text.s.font_height));
-    custom_reposition_text(custom, &el->text);
-    get_colour(custom, &el->text.object->color, el->any.s.fill, el->any.s.fill_opacity);
-    text_draw(el->text.object, renderer);
-    text_set_position(el->text.object, &el->text.anchor);
-    break;
-  case GE_ELLIPSE:
-    transform_coord(custom, &el->ellipse.center, &p1);
-    transform_size(custom, el->ellipse.width, el->ellipse.height, &width, &height);
-    renderer_ops->draw_ellipse (renderer, &p1, width, height,
-                               (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE) ? bg : 
NULL,
-                               (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL);
-    break;
-  case GE_IMAGE:
-    transform_coord(custom, &el->image.topleft, &p1);
-    /* to scale correctly also for sub-shape some extra hoops */
-    transform_size(custom, el->image.width, el->image.height, &width, &height);
-    renderer_ops->draw_image(renderer, &p1,
-                            width, height,
-                            el->image.image);
-    break;
-  case GE_PATH:
-    g_array_set_size(barr, el->path.npoints);
-    for (i = 0; i < el->path.npoints; i++)
-      switch (g_array_index(barr,BezPoint,i).type=el->path.points[i].type) {
-        case BEZ_CURVE_TO:
-            transform_coord(custom, &el->path.points[i].p3,
-              &g_array_index(barr, BezPoint, i).p3);
-            transform_coord(custom, &el->path.points[i].p2,
-              &g_array_index(barr, BezPoint, i).p2);
-        case BEZ_MOVE_TO:
-        case BEZ_LINE_TO:
-          transform_coord(custom, &el->path.points[i].p1,
-            &g_array_index(barr, BezPoint, i).p1);
-    }
-    if (el->any.s.stroke != DIA_SVG_COLOUR_NONE)
-      renderer_ops->draw_bezier(renderer, (BezPoint *)barr->data,
-                                 el->path.npoints, fg);
-    break;
-  case GE_SHAPE:
-    g_array_set_size(barr, el->path.npoints);
-    for (i = 0; i < el->path.npoints; i++)
-      switch (g_array_index(barr,BezPoint,i).type=el->path.points[i].type) {
-        case BEZ_CURVE_TO:
-          transform_coord(custom, &el->path.points[i].p3,
-                         &g_array_index(barr, BezPoint, i).p3);
-          transform_coord(custom, &el->path.points[i].p2,
-                         &g_array_index(barr, BezPoint, i).p2);
-        case BEZ_MOVE_TO:
-        case BEZ_LINE_TO:
-          transform_coord(custom, &el->path.points[i].p1,
-              &g_array_index(barr, BezPoint, i).p1);
-    }
-    if (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE)
-      renderer_ops->draw_beziergon(renderer,
-                                  (BezPoint *)barr->data, el->path.npoints,
-                                  bg, (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL);
-    else if (el->any.s.stroke != DIA_SVG_COLOUR_NONE)
-      renderer_ops->draw_bezier(renderer, (BezPoint *)barr->data,
-                                 el->path.npoints, fg);
-    break;
-  case GE_SUBSHAPE:
-    {
-      GraphicElementSubShape* subshape = (GraphicElementSubShape*)el;
-
-      custom->current_subshape = subshape;
-      custom_draw_displaylist(subshape->display_list, custom, renderer, arr, barr, cur_line, cur_dash, 
cur_caps, cur_join, cur_style);
-      custom->current_subshape = NULL;
-    }
-    break;
+    case GE_LINE:
+      transform_coord (custom, &el->line.p1, &p1);
+      transform_coord (custom, &el->line.p2, &p2);
+      if (el->any.s.stroke != DIA_SVG_COLOUR_NONE)
+        dia_renderer_draw_line (renderer, &p1, &p2, fg);
+      break;
+    case GE_POLYLINE:
+      g_array_set_size (arr, el->polyline.npoints);
+      for (i = 0; i < el->polyline.npoints; i++) {
+        transform_coord (custom,
+                         &el->polyline.points[i],
+                         &g_array_index (arr, Point, i));
+      }
+      if (el->any.s.stroke != DIA_SVG_COLOUR_NONE) {
+        dia_renderer_draw_polyline (renderer,
+                                    (Point *) arr->data,
+                                    el->polyline.npoints,
+                                    fg);
+      }
+      break;
+    case GE_POLYGON:
+      g_array_set_size (arr, el->polygon.npoints);
+      for (i = 0; i < el->polygon.npoints; i++) {
+        transform_coord (custom,
+                         &el->polygon.points[i],
+                         &g_array_index (arr, Point, i));
+      }
+      dia_renderer_draw_polygon (renderer,
+                                 (Point *)arr->data,
+                                 el->polygon.npoints,
+                                 (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE) ? bg : 
NULL,
+                                 (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL);
+      break;
+    case GE_RECT:
+      transform_coord (custom, &el->rect.corner1, &p1);
+      transform_coord (custom, &el->rect.corner2, &p2);
+      radius = custom_transform_length (custom, el->rect.corner_radius);
+      if (p1.x > p2.x) {
+        coord = p1.x;
+        p1.x = p2.x;
+        p2.x = coord;
+      }
+      if (p1.y > p2.y) {
+        coord = p1.y;
+        p1.y = p2.y;
+        p2.y = coord;
+      }
+      /* the renderer implementation will use simple rect with a small enough radius */
+      dia_renderer_draw_rounded_rect (renderer,
+                                      &p1,
+                                      &p2,
+                                      (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE) ? 
bg : NULL,
+                                      (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL,
+                                      radius);
+      break;
+    case GE_TEXT:
+      text_set_height (el->text.object,
+                       custom_transform_length (custom, el->text.s.font_height));
+      custom_reposition_text (custom, &el->text);
+      get_colour (custom,
+                  &el->text.object->color,
+                  el->any.s.fill,
+                  el->any.s.fill_opacity);
+      text_draw (el->text.object, renderer);
+      text_set_position (el->text.object, &el->text.anchor);
+      break;
+    case GE_ELLIPSE:
+      transform_coord (custom, &el->ellipse.center, &p1);
+      transform_size (custom,
+                      el->ellipse.width,
+                      el->ellipse.height,
+                      &width,
+                      &height);
+      dia_renderer_draw_ellipse (renderer,
+                                 &p1,
+                                 width,
+                                 height,
+                                 (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE) ? bg : 
NULL,
+                                 (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL);
+      break;
+    case GE_IMAGE:
+      transform_coord (custom, &el->image.topleft, &p1);
+      /* to scale correctly also for sub-shape some extra hoops */
+      transform_size (custom, el->image.width, el->image.height, &width, &height);
+      dia_renderer_draw_image (renderer,
+                               &p1,
+                               width,
+                               height,
+                               el->image.image);
+      break;
+    case GE_PATH:
+      g_array_set_size (barr, el->path.npoints);
+      for (i = 0; i < el->path.npoints; i++)
+        switch (g_array_index (barr,BezPoint,i).type=el->path.points[i].type) {
+          case BEZ_CURVE_TO:
+            transform_coord (custom,
+                             &el->path.points[i].p3,
+                             &g_array_index (barr, BezPoint, i).p3);
+            transform_coord (custom, &el->path.points[i].p2,
+                             &g_array_index (barr, BezPoint, i).p2);
+          case BEZ_MOVE_TO:
+          case BEZ_LINE_TO:
+            transform_coord (custom, &el->path.points[i].p1,
+                             &g_array_index (barr, BezPoint, i).p1);
+      }
+      if (el->any.s.stroke != DIA_SVG_COLOUR_NONE) {
+        dia_renderer_draw_bezier (renderer,
+                                  (BezPoint *) barr->data,
+                                  el->path.npoints,
+                                  fg);
+      }
+      break;
+    case GE_SHAPE:
+      g_array_set_size (barr, el->path.npoints);
+      for (i = 0; i < el->path.npoints; i++)
+        switch (g_array_index (barr,BezPoint,i).type=el->path.points[i].type) {
+          case BEZ_CURVE_TO:
+            transform_coord (custom,
+                             &el->path.points[i].p3,
+                             &g_array_index (barr, BezPoint, i).p3);
+            transform_coord (custom,
+                             &el->path.points[i].p2,
+                             &g_array_index (barr, BezPoint, i).p2);
+          case BEZ_MOVE_TO:
+          case BEZ_LINE_TO:
+            transform_coord (custom,
+                             &el->path.points[i].p1,
+                             &g_array_index (barr, BezPoint, i).p1);
+      }
+      if (custom->show_background && el->any.s.fill != DIA_SVG_COLOUR_NONE) {
+        dia_renderer_draw_beziergon(renderer,
+            (BezPoint *)barr->data, el->path.npoints,
+            bg, (el->any.s.stroke != DIA_SVG_COLOUR_NONE) ? fg : NULL);
+      } else if (el->any.s.stroke != DIA_SVG_COLOUR_NONE) {
+        dia_renderer_draw_bezier (renderer,
+                                  (BezPoint *) barr->data,
+                                  el->path.npoints,
+                                  fg);
+      }
+      break;
+    case GE_SUBSHAPE:
+      {
+        GraphicElementSubShape* subshape = (GraphicElementSubShape*)el;
+
+        custom->current_subshape = subshape;
+        custom_draw_displaylist (subshape->display_list,
+                                 custom,
+                                 renderer,
+                                 arr,
+                                 barr,
+                                 cur_line,
+                                 cur_dash,
+                                 cur_caps,
+                                 cur_join,
+                                 cur_style);
+        custom->current_subshape = NULL;
+      }
+      break;
   }
 }
 
diff --git a/objects/flowchart/box.c b/objects/flowchart/box.c
index f10663d3..b9071538 100644
--- a/objects/flowchart/box.c
+++ b/objects/flowchart/box.c
@@ -312,9 +312,8 @@ box_move(Box *box, Point *to)
 }
 
 static void
-box_draw(Box *box, DiaRenderer *renderer)
+box_draw (Box *box, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point lr_corner;
   Element *elem;
 
@@ -325,18 +324,22 @@ box_draw(Box *box, DiaRenderer *renderer)
   lr_corner.x = elem->corner.x + elem->width;
   lr_corner.y = elem->corner.y + elem->height;
 
-  if (box->show_background)
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  if (box->show_background) {
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  }
 
-  renderer_ops->set_linewidth(renderer, box->border_width);
-  renderer_ops->set_linestyle(renderer, box->line_style, box->dashlength);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, box->border_width);
+  dia_renderer_set_linestyle (renderer, box->line_style, box->dashlength);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
   /* Problem:  How do we make the fill with rounded corners?
    * It's solved in the base class ...
    */
-  renderer_ops->draw_rounded_rect (renderer, &elem->corner, &lr_corner,
-                                  &box->inner_color, &box->border_color,
-                                  box->corner_radius);
+  dia_renderer_draw_rounded_rect (renderer,
+                                  &elem->corner,
+                                  &lr_corner,
+                                  &box->inner_color,
+                                  &box->border_color,
+                                  box->corner_radius);
   text_draw(box->text, renderer);
 }
 
diff --git a/objects/flowchart/diamond.c b/objects/flowchart/diamond.c
index 5bedcd65..65c89d88 100644
--- a/objects/flowchart/diamond.c
+++ b/objects/flowchart/diamond.c
@@ -324,7 +324,6 @@ diamond_move(Diamond *diamond, Point *to)
 static void
 diamond_draw(Diamond *diamond, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pts[4];
   Element *elem;
 
@@ -341,19 +340,21 @@ diamond_draw(Diamond *diamond, DiaRenderer *renderer)
   pts[2].y += elem->height;
   pts[3].y += elem->height / 2.0;
 
-  if (diamond->show_background)
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  if (diamond->show_background) {
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  }
 
-  renderer_ops->set_linewidth(renderer, diamond->border_width);
-  renderer_ops->set_linestyle(renderer, diamond->line_style, diamond->dashlength);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, diamond->border_width);
+  dia_renderer_set_linestyle (renderer, diamond->line_style, diamond->dashlength);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  renderer_ops->draw_polygon (renderer,
-                             pts, 4,
-                             (diamond->show_background) ? &diamond->inner_color : NULL,
-                             &diamond->border_color);
+  dia_renderer_draw_polygon (renderer,
+                             pts,
+                             4,
+                             (diamond->show_background) ? &diamond->inner_color : NULL,
+                             &diamond->border_color);
 
-  text_draw(diamond->text, renderer);
+  text_draw (diamond->text, renderer);
 }
 
 static void
diff --git a/objects/flowchart/ellipse.c b/objects/flowchart/ellipse.c
index 8b3f7d97..c33ae9dd 100644
--- a/objects/flowchart/ellipse.c
+++ b/objects/flowchart/ellipse.c
@@ -317,9 +317,8 @@ ellipse_move(Ellipse *ellipse, Point *to)
 }
 
 static void
-ellipse_draw(Ellipse *ellipse, DiaRenderer *renderer)
+ellipse_draw (Ellipse *ellipse, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   Point center;
 
@@ -331,18 +330,21 @@ ellipse_draw(Ellipse *ellipse, DiaRenderer *renderer)
   center.x = elem->corner.x + elem->width/2;
   center.y = elem->corner.y + elem->height/2;
 
-  if (ellipse->show_background)
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linewidth(renderer, ellipse->border_width);
-  renderer_ops->set_linestyle(renderer, ellipse->line_style, ellipse->dashlength);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-
-  renderer_ops->draw_ellipse (renderer, &center,
-                             elem->width, elem->height,
-                             (ellipse->show_background) ? &ellipse->inner_color : NULL,
-                             &ellipse->border_color);
-
-  text_draw(ellipse->text, renderer);
+  if (ellipse->show_background) {
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  }
+  dia_renderer_set_linewidth (renderer, ellipse->border_width);
+  dia_renderer_set_linestyle (renderer, ellipse->line_style, ellipse->dashlength);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+
+  dia_renderer_draw_ellipse (renderer,
+                             &center,
+                             elem->width,
+                             elem->height,
+                             (ellipse->show_background) ? &ellipse->inner_color : NULL,
+                             &ellipse->border_color);
+
+  text_draw (ellipse->text, renderer);
 }
 
 
diff --git a/objects/flowchart/parallelogram.c b/objects/flowchart/parallelogram.c
index 4514eeaa..3e93bb36 100644
--- a/objects/flowchart/parallelogram.c
+++ b/objects/flowchart/parallelogram.c
@@ -324,9 +324,8 @@ pgram_move(Pgram *pgram, Point *to)
 }
 
 static void
-pgram_draw(Pgram *pgram, DiaRenderer *renderer)
+pgram_draw (Pgram *pgram, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point pts[4];
   Element *elem;
   real offs;
@@ -351,19 +350,21 @@ pgram_draw(Pgram *pgram, DiaRenderer *renderer)
     pts[3].x -= offs;
   }
 
-  if (pgram->show_background)
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+  if (pgram->show_background) {
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  }
 
-  renderer_ops->set_linewidth(renderer, pgram->border_width);
-  renderer_ops->set_linestyle(renderer, pgram->line_style, pgram->dashlength);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  dia_renderer_set_linewidth (renderer, pgram->border_width);
+  dia_renderer_set_linestyle (renderer, pgram->line_style, pgram->dashlength);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
-  renderer_ops->draw_polygon (renderer,
-                             pts, 4,
-                             (pgram->show_background) ? &pgram->inner_color : NULL,
-                             &pgram->border_color);
+  dia_renderer_draw_polygon (renderer,
+                             pts,
+                             4,
+                             (pgram->show_background) ? &pgram->inner_color : NULL,
+                             &pgram->border_color);
 
-  text_draw(pgram->text, renderer);
+  text_draw (pgram->text, renderer);
 }
 
 
diff --git a/objects/network/basestation.c b/objects/network/basestation.c
index 358d83ed..9b120538 100644
--- a/objects/network/basestation.c
+++ b/objects/network/basestation.c
@@ -222,9 +222,8 @@ basestation_move(Basestation *basestation, Point *to)
 }
 
 static void
-basestation_draw(Basestation *basestation, DiaRenderer *renderer)
+basestation_draw (Basestation *basestation, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Element *elem;
   real x, y, w, h;
   real r = BASESTATION_WIDTH/2.0;
@@ -241,10 +240,10 @@ basestation_draw(Basestation *basestation, DiaRenderer *renderer)
   w = elem->width;
   h = elem->height - r;
 
-  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_ROUND);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0);
-  renderer_ops->set_linewidth(renderer, BASESTATION_LINEWIDTH);
+  dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_ROUND);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0);
+  dia_renderer_set_linewidth (renderer, BASESTATION_LINEWIDTH);
 
   ct.x = x + w/2.0;
   ct.y = y + r/2.0;
@@ -256,38 +255,61 @@ basestation_draw(Basestation *basestation, DiaRenderer *renderer)
   points[1] = ct; points[1].x += r/4.0; points[1].y -= 3.0*r/4.0;
   points[2] = ct; points[2].x += r/4.0; points[2].y += 1.0;
   points[3] = ct; points[3].x -= r/4.0; points[3].y += 1.0;
-  renderer_ops->draw_polygon(renderer, points, 4,
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
                              &basestation->fill_colour,
                              &basestation->line_colour);
   /* bottom */
-  renderer_ops->draw_ellipse(renderer, &cb, r, r/2.0,
-                             &basestation->fill_colour, NULL);
-  renderer_ops->draw_arc(renderer, &cb, r, r/2.0, 180, 0,
+  dia_renderer_draw_ellipse (renderer,
+                             &cb,
+                             r,
+                             r/2.0,
+                             &basestation->fill_colour,
+                             NULL);
+  dia_renderer_draw_arc (renderer,
+                         &cb,
+                         r,
+                         r/2.0,
+                         180,
+                         0,
                          &basestation->line_colour);
   /* bar */
   p1 = ct;
   p1.x -= r/2.0;
   p2 = cb;
   p2.x += r/2.0;
-  renderer_ops->draw_rect(renderer, &p1, &p2,
-                          &basestation->fill_colour, NULL);
+  dia_renderer_draw_rect (renderer,
+                          &p1,
+                          &p2,
+                          &basestation->fill_colour,
+                          NULL);
   p2.x -= r;
-  renderer_ops->draw_line(renderer, &p1, &p2,
+  dia_renderer_draw_line (renderer,
+                          &p1,
+                          &p2,
                           &basestation->line_colour);
   p1.x += r;
   p2.x += r;
-  renderer_ops->draw_line(renderer, &p1, &p2,
+  dia_renderer_draw_line (renderer,
+                          &p1,
+                          &p2,
                           &basestation->line_colour);
   /* top */
-  renderer_ops->draw_ellipse(renderer, &ct, r, r/2.0,
-                            &basestation->fill_colour,
-                            &basestation->line_colour);
+  dia_renderer_draw_ellipse (renderer,
+                             &ct,
+                             r,
+                             r/2.0,
+                             &basestation->fill_colour,
+                             &basestation->line_colour);
   /* antenna 2 */
   points[0] = ct; points[0].x += r/4.0;   points[0].y -= 0;
   points[1] = ct; points[1].x += 3.0*r/4.0; points[1].y -= r/2.0;
   points[2] = ct; points[2].x += 3.0*r/4.0; points[2].y += 1.0 - r/2.0;
   points[3] = ct; points[3].x += r/4.0;   points[3].y += 1.0;
-  renderer_ops->draw_polygon(renderer, points, 4,
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
                              &basestation->fill_colour,
                              &basestation->line_colour);
   /* antenna 3 */
@@ -295,10 +317,12 @@ basestation_draw(Basestation *basestation, DiaRenderer *renderer)
   points[1] = ct; points[1].x -= 3.0*r/4.0; points[1].y -= r/2.0;
   points[2] = ct; points[2].x -= 3.0*r/4.0; points[2].y += 1.0 - r/2.0;
   points[3] = ct; points[3].x -= r/4.0;   points[3].y += 1.0;
-  renderer_ops->draw_polygon(renderer, points, 4,
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             4,
                              &basestation->fill_colour,
                              &basestation->line_colour);
-  text_draw(basestation->text, renderer);
+  text_draw (basestation->text, renderer);
 }
 
 static void
diff --git a/objects/network/bus.c b/objects/network/bus.c
index fb8ccd6b..19258d46 100644
--- a/objects/network/bus.c
+++ b/objects/network/bus.c
@@ -291,9 +291,8 @@ bus_move(Bus *bus, Point *to)
 }
 
 static void
-bus_draw(Bus *bus, DiaRenderer *renderer)
+bus_draw (Bus *bus, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints;
   int i;
 
@@ -302,19 +301,20 @@ bus_draw(Bus *bus, DiaRenderer *renderer)
 
   endpoints = &bus->real_ends[0];
 
-  renderer_ops->set_linewidth(renderer, LINE_WIDTH);
-  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, LINE_WIDTH);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-  renderer_ops->draw_line(renderer,
-                          &endpoints[0], &endpoints[1],
-                          &bus->line_color);
+  dia_renderer_draw_line (renderer,
+                          &endpoints[0],
+                          &endpoints[1],
+                          &bus->line_color);
 
-  for (i=0;i<bus->num_handles;i++) {
-    renderer_ops->draw_line(renderer,
-                            &bus->parallel_points[i],
-                            &bus->handles[i]->pos,
-                            &bus->line_color);
+  for (i = 0; i < bus->num_handles; i++) {
+    dia_renderer_draw_line (renderer,
+                            &bus->parallel_points[i],
+                            &bus->handles[i]->pos,
+                            &bus->line_color);
   }
 }
 
diff --git a/objects/network/radiocell.c b/objects/network/radiocell.c
index 90dc1c26..98e4e231 100644
--- a/objects/network/radiocell.c
+++ b/objects/network/radiocell.c
@@ -242,9 +242,8 @@ radiocell_move(RadioCell *radiocell, Point *to)
 }
 
 static void
-radiocell_draw(RadioCell *radiocell, DiaRenderer *renderer)
+radiocell_draw (RadioCell *radiocell, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   PolyShape *poly;
   Point *points;
   int n;
@@ -256,17 +255,18 @@ radiocell_draw(RadioCell *radiocell, DiaRenderer *renderer)
   points = &poly->points[0];
   n = poly->numpoints;
 
-  if (radiocell->show_background)
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linestyle(renderer, radiocell->line_style, radiocell->dashlength);
-  renderer_ops->set_linewidth(renderer, radiocell->line_width);
-  renderer_ops->draw_polygon(renderer, points, n,
-                            (radiocell->show_background) ? &radiocell->fill_colour : NULL,
-                            &radiocell->line_colour);
-
-  text_draw(radiocell->text, renderer);
+  if (radiocell->show_background) {
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
+  }
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, radiocell->line_style, radiocell->dashlength);
+  dia_renderer_set_linewidth (renderer, radiocell->line_width);
+  dia_renderer_draw_polygon (renderer, points, n,
+                             (radiocell->show_background) ? &radiocell->fill_colour : NULL,
+                             &radiocell->line_colour);
+
+  text_draw (radiocell->text, renderer);
 }
 
 static void
diff --git a/objects/network/wanlink.c b/objects/network/wanlink.c
index b503b6c3..54ff6e35 100644
--- a/objects/network/wanlink.c
+++ b/objects/network/wanlink.c
@@ -46,7 +46,7 @@ typedef struct _WanLink {
 
     Color line_color;
     Color fill_color;
-    
+
     real width;
     Point poly[WANLINK_POLY_LEN];
 } WanLink;
@@ -64,7 +64,7 @@ static DiaObject *wanlink_copy(WanLink *wanlink);
 static ObjectChange* wanlink_move(WanLink *wanlink, Point *to);
 static ObjectChange* wanlink_move_handle(WanLink *wanlink, Handle *handle,
                                         Point *to, ConnectionPoint *cp,
-                                        HandleMoveReason reason, 
+                                        HandleMoveReason reason,
                              ModifierKeys modifiers);
 
 static PropDescription *wanlink_describe_props(WanLink *wanlink);
@@ -180,9 +180,9 @@ wanlink_create(Point *startpoint,
   conn->endpoints[0] = *startpoint;
   conn->endpoints[1] = *startpoint;
   point_add(&conn->endpoints[1], &defaultlen);
- 
+
   obj = (DiaObject *) wanlink;
-  
+
   obj->type = &wanlink_type;
   obj->ops = &wanlink_ops;
 
@@ -190,7 +190,7 @@ wanlink_create(Point *startpoint,
 
   for (i = 0; i < WANLINK_POLY_LEN ; i++)
       wanlink->poly[i] = defaultpoly;
-  
+
   wanlink->width = FLASH_WIDTH;
   /* both colors where black at the time this was hardcoded ... */
   wanlink->line_color = color_black;
@@ -198,7 +198,7 @@ wanlink_create(Point *startpoint,
 
   wanlink->line_color = attributes_get_foreground();
   wanlink->fill_color = attributes_get_foreground();
-  
+
   wanlink_update_data(wanlink);
 
   *handle1 = obj->handles[0];
@@ -215,20 +215,21 @@ wanlink_destroy(WanLink *wanlink)
 }
 
 
-static void 
+static void
 wanlink_draw (WanLink *wanlink, DiaRenderer *renderer)
 {
-    DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-
-    assert (wanlink != NULL);
-    assert (renderer != NULL);
-
-    renderer_ops->set_linewidth(renderer, FLASH_LINE);
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-    renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
-
-    renderer_ops->draw_polygon (renderer, wanlink->poly,  WANLINK_POLY_LEN,
-                               &wanlink->fill_color, &wanlink->line_color);
+  assert (wanlink != NULL);
+  assert (renderer != NULL);
+
+  dia_renderer_set_linewidth (renderer, FLASH_LINE);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+
+  dia_renderer_draw_polygon (renderer,
+                             wanlink->poly,
+                             WANLINK_POLY_LEN,
+                             &wanlink->fill_color,
+                             &wanlink->line_color);
 }
 
 static real
@@ -249,12 +250,12 @@ wanlink_copy(WanLink *wanlink)
 {
   WanLink *newwanlink;
   Connection *conn, *newconn;
-  
+
   conn = &wanlink->connection;
-  
+
   newwanlink = g_malloc0(sizeof(WanLink));
   newconn = &newwanlink->connection;
-  
+
   connection_copy(conn, newconn);
 
   newwanlink->width = wanlink->width;
@@ -268,10 +269,10 @@ static ObjectChange*
 wanlink_move(WanLink *wanlink, Point *to)
 {
   Point delta;
-  Point *endpoints = &wanlink->connection.endpoints[0]; 
+  Point *endpoints = &wanlink->connection.endpoints[0];
   DiaObject *obj = (DiaObject *) wanlink;
   int i;
-    
+
   delta = *to;
   point_sub(&delta, &obj->position);
 
@@ -303,12 +304,12 @@ wanlink_save(WanLink *wanlink, ObjectNode obj_node,
             DiaContext *ctx)
 {
     AttributeNode attr;
-  
+
     connection_save((Connection *)wanlink, obj_node, ctx);
-    
+
     attr = new_attribute(obj_node, "width");
     data_add_real(attr, wanlink->width, ctx);
-    
+
     data_add_color( new_attribute(obj_node, "line_color"), &wanlink->line_color, ctx);
     data_add_color( new_attribute(obj_node, "fill_color"), &wanlink->fill_color, ctx);
 }
@@ -321,18 +322,18 @@ wanlink_load(ObjectNode obj_node, int version,DiaContext *ctx)
     DiaObject *obj;
     AttributeNode attr;
     DataNode data;
-    
+
     wanlink = g_malloc0(sizeof(WanLink));
 
     conn = &wanlink->connection;
     obj = (DiaObject *) wanlink;
-    
+
     obj->type = &wanlink_type;
     obj->ops = &wanlink_ops;
 
     connection_load(conn, obj_node, ctx);
     connection_init(conn, 2, 0);
-    
+
     attr = object_find_attribute(obj_node, "width");
     if (attr != NULL) {
        data = attribute_first_data(attr);
@@ -350,7 +351,7 @@ wanlink_load(ObjectNode obj_node, int version,DiaContext *ctx)
       data_color(attribute_first_data(attr), &wanlink->fill_color, ctx);
 
     wanlink_update_data (wanlink);
-    
+
     return obj;
 }
 
@@ -430,16 +431,16 @@ wanlink_update_data(WanLink *wanlink)
   Point origin;
   int i;
   Matrix m;
-  
+
 
   width = wanlink->width;
   width_2 = width / 2.0;
-  
+
   if (connpoint_is_autogap(conn->endpoint_handles[0].connected_to) ||
       connpoint_is_autogap(conn->endpoint_handles[1].connected_to)) {
     connection_adjust_for_autogap(conn);
   }
-  endpoints = &conn->endpoints[0]; 
+  endpoints = &conn->endpoints[0];
   obj->position = endpoints[0];
 
   v = endpoints[1];
@@ -471,7 +472,7 @@ wanlink_update_data(WanLink *wanlink)
   wanlink->poly[4].y = (len * 0.55);
   wanlink->poly[5].x = (width * 0.06) - width_2;
   wanlink->poly[5].y = (len * 0.55);
-  
+
   /* rotate */
   _identity_matrix (m);
   _rotate_matrix (m, angle);
@@ -480,11 +481,11 @@ wanlink_update_data(WanLink *wanlink)
   obj->bounding_box.left = origin.x;
   obj->bounding_box.bottom = conn->endpoints[1].y;
   obj->bounding_box.right = conn->endpoints[1].x;
-  for (i = 0; i <  WANLINK_POLY_LEN; i++) 
+  for (i = 0; i <  WANLINK_POLY_LEN; i++)
   {
       Point new_pt;
-      
-      _transform_point (m, &wanlink->poly[i], 
+
+      _transform_point (m, &wanlink->poly[i],
                        &new_pt);
       point_add (&new_pt, &origin);
       wanlink->poly[i] = new_pt;
diff --git a/objects/standard/arc.c b/objects/standard/arc.c
index e158fb25..aed9fd49 100644
--- a/objects/standard/arc.c
+++ b/objects/standard/arc.c
@@ -569,10 +569,10 @@ calculate_arc_object_edge(Arc *arc, real ang_start, real ang_end, DiaObject *obj
   arc_get_point_at_angle(arc,target,mid2);
   return ;
 }
+
 static void
-arc_draw(Arc *arc, DiaRenderer *renderer)
+arc_draw (Arc *arc, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point *endpoints;
   Point gaptmp[3];
   ConnectionPoint *start_cp, *end_cp;
@@ -589,37 +589,38 @@ arc_draw(Arc *arc, DiaRenderer *renderer)
 
   TRACE(printf("drawing arc:\n start:%f°:%f,%f \tend:%f°:%f,%f\n",arc->angle1,endpoints[0].x,endpoints[0].y, 
arc->angle2,endpoints[1].x,endpoints[1].y));
 
-  if (connpoint_is_autogap(start_cp)) {
-     TRACE(printf("computing start intersection\ncurve_distance: %f\n",arc->curve_distance));
+  if (connpoint_is_autogap (start_cp)) {
+     TRACE (printf ("computing start intersection\ncurve_distance: %f\n", arc->curve_distance));
      if (arc->curve_distance < 0)
-             calculate_arc_object_edge(arc, arc->angle1, arc->angle2, start_cp->object, &gaptmp[0], FALSE);
+        calculate_arc_object_edge (arc, arc->angle1, arc->angle2, start_cp->object, &gaptmp[0], FALSE);
      else
-             calculate_arc_object_edge(arc, arc->angle2, arc->angle1, start_cp->object, &gaptmp[0], TRUE);
+        calculate_arc_object_edge (arc, arc->angle2, arc->angle1, start_cp->object, &gaptmp[0], TRUE);
   }
-  if (connpoint_is_autogap(end_cp)) {
-     TRACE(printf("computing end intersection\ncurve_distance: %f\n",arc->curve_distance));
-     if (arc->curve_distance < 0)
-             calculate_arc_object_edge(arc, arc->angle2, arc->angle1, end_cp->object, &gaptmp[1], TRUE);
-     else
-             calculate_arc_object_edge(arc, arc->angle1, arc->angle2, end_cp->object, &gaptmp[1], FALSE);
+  if (connpoint_is_autogap (end_cp)) {
+    TRACE(printf("computing end intersection\ncurve_distance: %f\n",arc->curve_distance));
+    if (arc->curve_distance < 0)
+      calculate_arc_object_edge (arc, arc->angle2, arc->angle1, end_cp->object, &gaptmp[1], TRUE);
+    else
+      calculate_arc_object_edge (arc, arc->angle1, arc->angle2, end_cp->object, &gaptmp[1], FALSE);
   }
 
   /* compute new middle_point */
-  arc_compute_midpoint(arc, &gaptmp[0], &gaptmp[1], &gaptmp[2]);
+  arc_compute_midpoint (arc, &gaptmp[0], &gaptmp[1], &gaptmp[2]);
 
-  renderer_ops->set_linewidth(renderer, arc->line_width);
-  renderer_ops->set_linestyle(renderer, arc->line_style, arc->dashlength);
-  renderer_ops->set_linecaps(renderer, arc->line_caps);
+  dia_renderer_set_linewidth (renderer, arc->line_width);
+  dia_renderer_set_linestyle (renderer, arc->line_style, arc->dashlength);
+  dia_renderer_set_linecaps (renderer, arc->line_caps);
 
   /* Special case when almost line: */
   if (arc_is_line (arc)) {
-          TRACE(printf("drawing like a line\n"));
-    renderer_ops->draw_line_with_arrows(renderer,
-                                        &gaptmp[0], &gaptmp[1],
-                                        arc->line_width,
-                                        &arc->arc_color,
-                                        &arc->start_arrow,
-                                        &arc->end_arrow);
+    TRACE (printf ("drawing like a line\n"));
+    dia_renderer_draw_line_with_arrows (renderer,
+                                        &gaptmp[0],
+                                        &gaptmp[1],
+                                        arc->line_width,
+                                        &arc->arc_color,
+                                        &arc->start_arrow,
+                                        &arc->end_arrow);
     return;
   }
 
@@ -635,22 +636,22 @@ arc_draw(Arc *arc, DiaRenderer *renderer)
     } else if (arc->curve_distance < 0.0 && angle2 > angle1) {
       angle2 -= 360.0;
     }
-    renderer_ops->draw_arc (renderer,
-                            &arc->center_handle.pos,
-                            arc->radius*2.0,
-                            arc->radius*2.0,
-                            angle1,
-                            angle2,
-                            &arc->arc_color);
+    dia_renderer_draw_arc (renderer,
+                           &arc->center_handle.pos,
+                           arc->radius*2.0,
+                           arc->radius*2.0,
+                           angle1,
+                           angle2,
+                           &arc->arc_color);
   } else {
-    renderer_ops->draw_arc_with_arrows (renderer,
-                                        &gaptmp[0],
-                                        &gaptmp[1],
-                                        &gaptmp[2],
-                                        arc->line_width,
-                                        &arc->arc_color,
-                                        &arc->start_arrow,
-                                        &arc->end_arrow);
+    dia_renderer_draw_arc_with_arrows (renderer,
+                                       &gaptmp[0],
+                                       &gaptmp[1],
+                                       &gaptmp[2],
+                                       arc->line_width,
+                                       &arc->arc_color,
+                                       &arc->start_arrow,
+                                       &arc->end_arrow);
   }
 
   if (DIA_IS_INTERACTIVE_RENDERER (renderer) &&
@@ -658,13 +659,13 @@ arc_draw(Arc *arc, DiaRenderer *renderer)
     /* draw the central angle */
     Color line_color = { 0.0, 0.0, 0.6, 1.0 };
 
-    renderer_ops->set_linewidth (renderer, 0);
-    renderer_ops->set_linestyle (renderer, LINESTYLE_DOTTED, 1);
-    renderer_ops->set_linejoin (renderer, LINEJOIN_MITER);
-    renderer_ops->set_linecaps (renderer, LINECAPS_BUTT);
+    dia_renderer_set_linewidth (renderer, 0);
+    dia_renderer_set_linestyle (renderer, LINESTYLE_DOTTED, 1);
+    dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+    dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
-    renderer_ops->draw_line (renderer, &endpoints[0], &arc->center, &line_color);
-    renderer_ops->draw_line (renderer, &endpoints[1], &arc->center, &line_color);
+    dia_renderer_draw_line (renderer, &endpoints[0], &arc->center, &line_color);
+    dia_renderer_draw_line (renderer, &endpoints[1], &arc->center, &line_color);
   }
 }
 
diff --git a/objects/standard/bezier.c b/objects/standard/bezier.c
index 3c9d0006..b319b17f 100644
--- a/objects/standard/bezier.c
+++ b/objects/standard/bezier.c
@@ -359,44 +359,45 @@ compute_gap_points(Bezierline *bezierline, Point *gap_points)
         /* adds the absolute end gap  according to the slope at the last point */
         point_add_scaled(&gap_points[2], &vec_end, bezierline->absolute_end_gap);
         point_add_scaled(&gap_points[3], &vec_end, bezierline->absolute_end_gap);
-
-
 }
+
 static void
-bezierline_draw(Bezierline *bezierline, DiaRenderer *renderer)
+bezierline_draw (Bezierline *bezierline, DiaRenderer *renderer)
 {
   Point gap_points[4]; /* two first and two last bez points */
-
   BezierConn *bez = &bezierline->bez;
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
 
-  renderer_ops->set_linewidth(renderer, bezierline->line_width);
-  renderer_ops->set_linestyle(renderer, bezierline->line_style, bezierline->dashlength);
-  renderer_ops->set_linejoin(renderer, bezierline->line_join);
-  renderer_ops->set_linecaps(renderer, bezierline->line_caps);
+  dia_renderer_set_linewidth (renderer, bezierline->line_width);
+  dia_renderer_set_linestyle (renderer, bezierline->line_style, bezierline->dashlength);
+  dia_renderer_set_linejoin (renderer, bezierline->line_join);
+  dia_renderer_set_linecaps (renderer, bezierline->line_caps);
 
-  if (connpoint_is_autogap(bez->object.handles[0]->connected_to) ||
-      connpoint_is_autogap(bez->object.handles[3*(bez->bezier.num_points-1)]->connected_to) ||
+  if (connpoint_is_autogap (bez->object.handles[0]->connected_to) ||
+      connpoint_is_autogap (bez->object.handles[3*(bez->bezier.num_points-1)]->connected_to) ||
       bezierline->absolute_start_gap || bezierline->absolute_end_gap) {
 
-    compute_gap_points(bezierline,gap_points);
-    exchange_bez_gap_points(bez,gap_points);
-    renderer_ops->draw_bezier_with_arrows(renderer, bez->bezier.points, bez->bezier.num_points,
-                                        bezierline->line_width,
-                                        &bezierline->line_color,
-                                        &bezierline->start_arrow,
-                                        &bezierline->end_arrow);
-    exchange_bez_gap_points(bez,gap_points);
+    compute_gap_points (bezierline,gap_points);
+    exchange_bez_gap_points (bez,gap_points);
+    dia_renderer_draw_bezier_with_arrows (renderer,
+                                          bez->bezier.points,
+                                          bez->bezier.num_points,
+                                          bezierline->line_width,
+                                          &bezierline->line_color,
+                                          &bezierline->start_arrow,
+                                          &bezierline->end_arrow);
+    exchange_bez_gap_points (bez,gap_points);
   } else {
-    renderer_ops->draw_bezier_with_arrows(renderer, bez->bezier.points, bez->bezier.num_points,
-                                         bezierline->line_width,
-                                         &bezierline->line_color,
-                                         &bezierline->start_arrow,
-                                         &bezierline->end_arrow);
+    dia_renderer_draw_bezier_with_arrows (renderer,
+                                          bez->bezier.points,
+                                          bez->bezier.num_points,
+                                          bezierline->line_width,
+                                          &bezierline->line_color,
+                                          &bezierline->start_arrow,
+                                          &bezierline->end_arrow);
   }
 
 #if 0
-  renderer_ops->draw_bezier(renderer, bez->bezier.points, bez->bezier.num_points,
+  dia_renderer_draw_bezier(renderer, bez->bezier.points, bez->bezier.num_points,
                             &bezierline->line_color);
 
   if (bezierline->start_arrow.type != ARROW_NONE) {
@@ -422,8 +423,10 @@ bezierline_draw(Bezierline *bezierline, DiaRenderer *renderer)
    * only checking while selected.  But we'll do that if needed.
    */
   if (DIA_IS_INTERACTIVE_RENDERER (renderer) &&
-      dia_object_is_selected(&bezierline->bez.object)) {
-    bezier_draw_control_lines(bezierline->bez.bezier.num_points, bezierline->bez.bezier.points, renderer);
+      dia_object_is_selected (&bezierline->bez.object)) {
+    bezier_draw_control_lines (bezierline->bez.bezier.num_points,
+                               bezierline->bez.bezier.points,
+                               renderer);
   }
 }
 
diff --git a/objects/standard/beziergon.c b/objects/standard/beziergon.c
index e2830289..da4bfdb0 100644
--- a/objects/standard/beziergon.c
+++ b/objects/standard/beziergon.c
@@ -210,10 +210,8 @@ beziergon_move(Beziergon *beziergon, Point *to)
 }
 
 static void
-beziergon_draw(Beziergon *beziergon, DiaRenderer *renderer)
+beziergon_draw (Beziergon *beziergon, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-
   BezierShape *bez = &beziergon->bezier;
   BezPoint *points;
   int n;
@@ -221,23 +219,25 @@ beziergon_draw(Beziergon *beziergon, DiaRenderer *renderer)
   points = &bez->bezier.points[0];
   n = bez->bezier.num_points;
 
-  renderer_ops->set_linewidth(renderer, beziergon->line_width);
-  renderer_ops->set_linestyle(renderer, beziergon->line_style, beziergon->dashlength);
-  renderer_ops->set_linejoin(renderer, beziergon->line_join);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, beziergon->line_width);
+  dia_renderer_set_linestyle (renderer, beziergon->line_style, beziergon->dashlength);
+  dia_renderer_set_linejoin (renderer, beziergon->line_join);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (beziergon->show_background) {
     Color fill = beziergon->inner_color;
     if (beziergon->pattern) {
       dia_pattern_get_fallback_color (beziergon->pattern, &fill);
-      if (renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-        renderer_ops->set_pattern (renderer, beziergon->pattern);
+      if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+        dia_renderer_set_pattern (renderer, beziergon->pattern);
+      }
+    }
+    dia_renderer_draw_beziergon (renderer, points, n, &fill, &beziergon->line_color);
+    if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+      dia_renderer_set_pattern (renderer, NULL);
     }
-    renderer_ops->draw_beziergon(renderer, points, n, &fill, &beziergon->line_color);
-    if (renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-      renderer_ops->set_pattern (renderer, NULL);
   } else { /* still to be closed */
-    renderer_ops->draw_beziergon(renderer, points, n, NULL, &beziergon->line_color);
+    dia_renderer_draw_beziergon (renderer, points, n, NULL, &beziergon->line_color);
   }
   /* these lines should only be displayed when object is selected.
    * Unfortunately the draw function is not aware of the selected
diff --git a/objects/standard/box.c b/objects/standard/box.c
index 4b2b0906..6d2d5982 100644
--- a/objects/standard/box.c
+++ b/objects/standard/box.c
@@ -332,11 +332,10 @@ box_move(Box *box, Point *to)
 }
 
 static void
-box_draw(Box *box, DiaRenderer *renderer)
+box_draw (Box *box, DiaRenderer *renderer)
 {
   Point lr_corner;
   Element *elem;
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
 
   assert(box != NULL);
   assert(renderer != NULL);
@@ -346,44 +345,55 @@ box_draw(Box *box, DiaRenderer *renderer)
   lr_corner.x = elem->corner.x + elem->width;
   lr_corner.y = elem->corner.y + elem->height;
 
-  renderer_ops->set_linewidth(renderer, box->border_width);
-  renderer_ops->set_linestyle(renderer, box->line_style, box->dashlength);
-  if (box->corner_radius > 0)
-    renderer_ops->set_linejoin(renderer, LINEJOIN_ROUND);
-  else
-    renderer_ops->set_linejoin(renderer, box->line_join);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, box->border_width);
+  dia_renderer_set_linestyle (renderer, box->line_style, box->dashlength);
+  if (box->corner_radius > 0) {
+    dia_renderer_set_linejoin (renderer, LINEJOIN_ROUND);
+  } else {
+    dia_renderer_set_linejoin (renderer, box->line_join);
+  }
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (box->show_background) {
     Color fill = box->inner_color;
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
     if (box->pattern) {
       dia_pattern_get_fallback_color (box->pattern, &fill);
-      if (renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-        renderer_ops->set_pattern (renderer, box->pattern);
+      if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+        dia_renderer_set_pattern (renderer, box->pattern);
+      }
     }
     if (box->angle == 0) {
-      renderer_ops->draw_rounded_rect (renderer,
-                                      &elem->corner, &lr_corner,
-                                      &fill, &box->border_color,
-                                      box->corner_radius);
+      dia_renderer_draw_rounded_rect (renderer,
+                                      &elem->corner,
+                                      &lr_corner,
+                                      &fill,
+                                      &box->border_color,
+                                      box->corner_radius);
     } else {
       Point poly[4];
       _box_get_poly (box, poly);
-      renderer_ops->draw_polygon (renderer, poly, 4, &fill, &box->border_color);
+      dia_renderer_draw_polygon (renderer, poly, 4, &fill, &box->border_color);
+    }
+    if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+      dia_renderer_set_pattern (renderer, NULL);
     }
-    if (renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-      renderer_ops->set_pattern (renderer, NULL);
   } else {
     if (box->angle == 0) {
-      renderer_ops->draw_rounded_rect (renderer,
-                                      &elem->corner, &lr_corner,
-                                      NULL, &box->border_color,
-                                      box->corner_radius);
+      dia_renderer_draw_rounded_rect (renderer,
+                                      &elem->corner,
+                                      &lr_corner,
+                                      NULL,
+                                      &box->border_color,
+                                      box->corner_radius);
     } else {
       Point poly[4];
       _box_get_poly (box, poly);
-      renderer_ops->draw_polygon (renderer, poly, 4, &box->inner_color, &box->border_color);
+      dia_renderer_draw_polygon (renderer,
+                                 poly,
+                                 4,
+                                 &box->inner_color,
+                                 &box->border_color);
     }
   }
 }
diff --git a/objects/standard/ellipse.c b/objects/standard/ellipse.c
index 01a24d20..1b970610 100644
--- a/objects/standard/ellipse.c
+++ b/objects/standard/ellipse.c
@@ -325,9 +325,8 @@ ellipse_move(Ellipse *ellipse, Point *to)
 }
 
 static void
-ellipse_draw(Ellipse *ellipse, DiaRenderer *renderer)
+ellipse_draw (Ellipse *ellipse, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point center;
   Element *elem;
   GArray *path = NULL;
@@ -340,43 +339,57 @@ ellipse_draw(Ellipse *ellipse, DiaRenderer *renderer)
   center.x = elem->corner.x + elem->width/2;
   center.y = elem->corner.y + elem->height/2;
 
-  if (ellipse->angle != 0)
+  if (ellipse->angle != 0) {
     path = _ellipse_to_path (ellipse, &center);
+  }
 
-  renderer_ops->set_linewidth(renderer, ellipse->border_width);
-  renderer_ops->set_linestyle(renderer, ellipse->line_style, ellipse->dashlength);
+  dia_renderer_set_linewidth (renderer, ellipse->border_width);
+  dia_renderer_set_linestyle (renderer, ellipse->line_style, ellipse->dashlength);
   if (ellipse->show_background) {
     Color fill = ellipse->inner_color;
-    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
+    dia_renderer_set_fillstyle (renderer, FILLSTYLE_SOLID);
     if (ellipse->pattern) {
       dia_pattern_get_fallback_color (ellipse->pattern, &fill);
-      if (renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-        renderer_ops->set_pattern (renderer, ellipse->pattern);
+      if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+        dia_renderer_set_pattern (renderer, ellipse->pattern);
+      }
+    }
+    if (!path) {
+      dia_renderer_draw_ellipse (renderer,
+                                 &center,
+                                 elem->width,
+                                 elem->height,
+                                 &fill,
+                                 &ellipse->border_color);
+    } else {
+      dia_renderer_draw_beziergon (renderer,
+                                   &g_array_index (path, BezPoint, 0),
+                                   path->len,
+                                   &fill, &ellipse->border_color);
+    }
+    if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+      dia_renderer_set_pattern (renderer, NULL);
     }
-    if (!path)
-      renderer_ops->draw_ellipse (renderer,
-                                 &center,
-                                 elem->width, elem->height,
-                                 &fill, &ellipse->border_color);
-    else
-      renderer_ops->draw_beziergon (renderer,
-                                   &g_array_index (path, BezPoint, 0), path->len,
-                                   &fill, &ellipse->border_color);
-    if (renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-      renderer_ops->set_pattern (renderer, NULL);
   } else {
-    if (!path)
-      renderer_ops->draw_ellipse (renderer,
-                                 &center,
-                                 elem->width, elem->height,
-                                 NULL, &ellipse->border_color);
-    else
-      renderer_ops->draw_beziergon (renderer,
-                                   &g_array_index (path, BezPoint, 0), path->len,
-                                   NULL, &ellipse->border_color);
+    if (!path) {
+      dia_renderer_draw_ellipse (renderer,
+                                 &center,
+                                 elem->width,
+                                 elem->height,
+                                 NULL,
+                                 &ellipse->border_color);
+    } else {
+      dia_renderer_draw_beziergon (renderer,
+                                   &g_array_index (path, BezPoint, 0),
+                                   path->len,
+                                   NULL,
+                                   &ellipse->border_color);
+    }
   }
-  if (path)
+
+  if (path) {
     g_array_free (path, TRUE);
+  }
 }
 
 static void
diff --git a/objects/standard/image.c b/objects/standard/image.c
index 761ba146..fab612e6 100644
--- a/objects/standard/image.c
+++ b/objects/standard/image.c
@@ -435,9 +435,8 @@ image_move(Image *image, Point *to)
 }
 
 static void
-image_draw(Image *image, DiaRenderer *renderer)
+image_draw (Image *image, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   Point ul_corner, lr_corner;
   Element *elem;
 
@@ -453,35 +452,48 @@ image_draw(Image *image, DiaRenderer *renderer)
   ul_corner.y = elem->corner.y - image->border_width/2;
 
   if (image->draw_border) {
-    renderer_ops->set_linewidth(renderer, image->border_width);
-    renderer_ops->set_linestyle(renderer, image->line_style, image->dashlength);
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+    dia_renderer_set_linewidth (renderer, image->border_width);
+    dia_renderer_set_linestyle (renderer, image->line_style, image->dashlength);
+    dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
 
     if (image->angle != 0.0) {
       Point poly[4];
       element_get_poly (elem, image->angle, poly);
       /* need to grow the poly, XXX: done here by growing the border width */
-      renderer_ops->set_linewidth(renderer, image->border_width * 2);
-      renderer_ops->draw_polygon (renderer, poly, 4, NULL, &image->border_color);
+      dia_renderer_set_linewidth (renderer, image->border_width * 2);
+      dia_renderer_draw_polygon (renderer, poly, 4, NULL, &image->border_color);
     } else {
-      renderer_ops->draw_rect (renderer,
-                              &ul_corner, &lr_corner,
-                              NULL, &image->border_color);
+      dia_renderer_draw_rect (renderer,
+                              &ul_corner,
+                              &lr_corner,
+                              NULL,
+                              &image->border_color);
     }
   }
   /* Draw the image */
   if (image->image) {
-    if (image->angle == 0.0)
-      renderer_ops->draw_image (renderer, &elem->corner, elem->width,
-                               elem->height, image->image);
-    else
-      renderer_ops->draw_rotated_image (renderer, &elem->corner, elem->width,
-                                       elem->height, image->angle, image->image);
+    if (image->angle == 0.0) {
+      dia_renderer_draw_image (renderer,
+                               &elem->corner,
+                               elem->width,
+                               elem->height,
+                               image->image);
+    } else {
+      dia_renderer_draw_rotated_image (renderer,
+                                       &elem->corner,
+                                       elem->width,
+                                       elem->height,
+                                       image->angle,
+                                       image->image);
+    }
   } else {
-    DiaImage *broken = dia_image_get_broken();
-    renderer_ops->draw_image (renderer, &elem->corner, elem->width,
-                             elem->height, broken);
-    dia_image_unref(broken);
+    DiaImage *broken = dia_image_get_broken ();
+    dia_renderer_draw_image (renderer,
+                             &elem->corner,
+                             elem->width,
+                             elem->height,
+                             broken);
+    dia_image_unref (broken);
   }
 }
 
diff --git a/objects/standard/line.c b/objects/standard/line.c
index 85799268..82cc15a2 100644
--- a/objects/standard/line.c
+++ b/objects/standard/line.c
@@ -444,37 +444,35 @@ line_move(Line *line, Point *to)
 }
 
 static void
-line_draw(Line *line, DiaRenderer *renderer)
+line_draw (Line *line, DiaRenderer *renderer)
 {
   Point gap_endpoints[2];
 
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
-
   assert(line != NULL);
   assert(renderer != NULL);
 
-  renderer_ops->set_linewidth(renderer, line->line_width);
-  renderer_ops->set_linestyle(renderer, line->line_style, line->dashlength);
-  renderer_ops->set_linecaps(renderer, line->line_caps);
+  dia_renderer_set_linewidth (renderer, line->line_width);
+  dia_renderer_set_linestyle (renderer, line->line_style, line->dashlength);
+  dia_renderer_set_linecaps (renderer, line->line_caps);
 
   if (line->absolute_start_gap || line->absolute_end_gap ) {
-    line_adjust_for_absolute_gap(line, gap_endpoints);
-
-    renderer_ops->draw_line_with_arrows(renderer,
-                                       &gap_endpoints[0], &gap_endpoints[1],
-                                       line->line_width,
-                                       &line->line_color,
-                                       &line->start_arrow,
-                                       &line->end_arrow);
+    line_adjust_for_absolute_gap (line, gap_endpoints);
+
+    dia_renderer_draw_line_with_arrows (renderer,
+                                        &gap_endpoints[0],
+                                        &gap_endpoints[1],
+                                        line->line_width,
+                                        &line->line_color,
+                                        &line->start_arrow,
+                                        &line->end_arrow);
   } else {
-        renderer_ops->draw_line_with_arrows(renderer,
-                                           &line->connection.endpoints[0],
-                                           &line->connection.endpoints[1],
-                                           line->line_width,
-                                           &line->line_color,
-                                           &line->start_arrow,
-                                           &line->end_arrow);
-
+    dia_renderer_draw_line_with_arrows (renderer,
+                                        &line->connection.endpoints[0],
+                                        &line->connection.endpoints[1],
+                                        line->line_width,
+                                        &line->line_color,
+                                        &line->start_arrow,
+                                        &line->end_arrow);
   }
 }
 
diff --git a/objects/standard/outline.c b/objects/standard/outline.c
index 9dba74e8..85364058 100644
--- a/objects/standard/outline.c
+++ b/objects/standard/outline.c
@@ -332,7 +332,7 @@ outline_update_data (Outline *outline)
  * \memberof Outline
  */
 static void
-outline_draw(Outline *outline, DiaRenderer *renderer)
+outline_draw (Outline *outline, DiaRenderer *renderer)
 {
   DiaObject *obj = &outline->object;
   int i, n = 0, total;
@@ -342,10 +342,11 @@ outline_draw(Outline *outline, DiaRenderer *renderer)
 
   if (!outline->path)
     return;
-  DIA_RENDERER_GET_CLASS (renderer)->set_linewidth (renderer, outline->line_width);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linejoin(renderer, LINEJOIN_MITER);
-  DIA_RENDERER_GET_CLASS (renderer)->set_linecaps(renderer, LINECAPS_ROUND);
+
+  dia_renderer_set_linewidth (renderer, outline->line_width);
+  dia_renderer_set_linestyle (renderer, LINESTYLE_SOLID, 0.0);
+  dia_renderer_set_linejoin (renderer, LINEJOIN_MITER);
+  dia_renderer_set_linecaps (renderer, LINECAPS_ROUND);
 
   /* the cairo text path is position independent, Dia's bezier are not */
   x = obj->position.x;
@@ -395,16 +396,19 @@ outline_draw(Outline *outline, DiaRenderer *renderer)
   if (pts[n-1].type == BEZ_MOVE_TO)
     --total; /* remove a potential last move which would otherwise be rendered as a dot */
 
-  if (DIA_RENDERER_GET_CLASS (renderer)->is_capable_to(renderer, RENDER_HOLES)) {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_beziergon(renderer, pts, total,
-                           outline->show_background ? &outline->fill_color : NULL,
-                           &outline->line_color);
+  if (dia_renderer_is_capable_of (renderer, RENDER_HOLES)) {
+    dia_renderer_draw_beziergon (renderer,
+                                 pts,
+                                 total,
+                                 outline->show_background ? &outline->fill_color : NULL,
+                                 &outline->line_color);
     return; /* that was easy ;) */
   }
   /* otherwise split the path data into piece which can be handled by Dia's standard bezier rendering */
-  if (outline->show_background)
-    bezier_render_fill (renderer, pts, total, &outline->fill_color);
-  bezier_render_stroke (renderer, pts, total, &outline->line_color);
+  if (outline->show_background) {
+    dia_renderer_bezier_fill (renderer, pts, total, &outline->fill_color);
+  }
+  dia_renderer_bezier_stroke (renderer, pts, total, &outline->line_color);
 }
 /*!
  * \brief Optionally deliver an object specific menu
diff --git a/objects/standard/polygon.c b/objects/standard/polygon.c
index f03fe53b..9bf4df9f 100644
--- a/objects/standard/polygon.c
+++ b/objects/standard/polygon.c
@@ -211,9 +211,8 @@ polygon_move(Polygon *polygon, Point *to)
 }
 
 static void
-polygon_draw(Polygon *polygon, DiaRenderer *renderer)
+polygon_draw (Polygon *polygon, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   PolyShape *poly = &polygon->poly;
   Point *points;
   int n;
@@ -222,25 +221,29 @@ polygon_draw(Polygon *polygon, DiaRenderer *renderer)
   points = &poly->points[0];
   n = poly->numpoints;
 
-  renderer_ops->set_linewidth(renderer, polygon->line_width);
-  renderer_ops->set_linestyle(renderer, polygon->line_style, polygon->dashlength);
-  renderer_ops->set_linejoin(renderer, polygon->line_join);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  dia_renderer_set_linewidth (renderer, polygon->line_width);
+  dia_renderer_set_linestyle (renderer, polygon->line_style, polygon->dashlength);
+  dia_renderer_set_linejoin (renderer, polygon->line_join);
+  dia_renderer_set_linecaps (renderer, LINECAPS_BUTT);
 
   if (polygon->show_background) {
     fill = polygon->inner_color;
     if (polygon->pattern) {
       dia_pattern_get_fallback_color (polygon->pattern, &fill);
-      if (renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-        renderer_ops->set_pattern (renderer, polygon->pattern);
+      if (dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+        dia_renderer_set_pattern (renderer, polygon->pattern);
+      }
     }
   }
-  renderer_ops->draw_polygon (renderer, points, n,
-                             (polygon->show_background) ? &fill : NULL,
-                             &polygon->line_color);
+  dia_renderer_draw_polygon (renderer,
+                             points,
+                             n,
+                             (polygon->show_background) ? &fill : NULL,
+                             &polygon->line_color);
   if (polygon->show_background && polygon->pattern &&
-      renderer_ops->is_capable_to(renderer, RENDER_PATTERN))
-    renderer_ops->set_pattern (renderer, NULL); /* reset*/
+      dia_renderer_is_capable_of (renderer, RENDER_PATTERN)) {
+    dia_renderer_set_pattern (renderer, NULL); /* reset*/
+  }
 }
 
 static DiaObject *
diff --git a/objects/standard/polyline.c b/objects/standard/polyline.c
index b9ba8599..01c4db95 100644
--- a/objects/standard/polyline.c
+++ b/objects/standard/polyline.c
@@ -279,28 +279,28 @@ static void
 polyline_draw(Polyline *polyline, DiaRenderer *renderer)
 {
   Point gap_endpoints[2];
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   PolyConn *poly = &polyline->poly;
   Point *points;
   int n;
 
   points = &poly->points[0];
   n = poly->numpoints;
-  renderer_ops->set_linewidth(renderer, polyline->line_width);
-  renderer_ops->set_linestyle(renderer, polyline->line_style, polyline->dashlength);
-  renderer_ops->set_linejoin(renderer, polyline->line_join);
-  renderer_ops->set_linecaps(renderer, polyline->line_caps);
-
-  polyline_calculate_gap_endpoints(polyline, gap_endpoints);
-  polyline_exchange_gap_points(polyline, gap_endpoints);
-  renderer_ops->draw_rounded_polyline_with_arrows(renderer,
-                                                 points, n,
-                                                 polyline->line_width,
-                                                 &polyline->line_color,
-                                                 &polyline->start_arrow,
-                                                 &polyline->end_arrow,
-                                                 polyline->corner_radius);
-  polyline_exchange_gap_points(polyline, gap_endpoints);
+  dia_renderer_set_linewidth (renderer, polyline->line_width);
+  dia_renderer_set_linestyle (renderer, polyline->line_style, polyline->dashlength);
+  dia_renderer_set_linejoin (renderer, polyline->line_join);
+  dia_renderer_set_linecaps (renderer, polyline->line_caps);
+
+  polyline_calculate_gap_endpoints (polyline, gap_endpoints);
+  polyline_exchange_gap_points (polyline, gap_endpoints);
+  dia_renderer_draw_rounded_polyline_with_arrows (renderer,
+                                                  points,
+                                                  n,
+                                                  polyline->line_width,
+                                                  &polyline->line_color,
+                                                  &polyline->start_arrow,
+                                                  &polyline->end_arrow,
+                                                  polyline->corner_radius);
+  polyline_exchange_gap_points (polyline, gap_endpoints);
 }
 
 /** user_data is a struct polyline_create_data, containing an array of
diff --git a/objects/standard/textobj.c b/objects/standard/textobj.c
index 120965de..f7d5bff1 100644
--- a/objects/standard/textobj.c
+++ b/objects/standard/textobj.c
@@ -296,27 +296,28 @@ textobj_draw(Textobj *textobj, DiaRenderer *renderer)
     lr.x = box.right + textobj->margin;
     lr.y = box.bottom + textobj->margin;
     if (textobj->text_angle == 0) {
-      DIA_RENDERER_GET_CLASS (renderer)->draw_rect (renderer, &ul, &lr, &textobj->fill_color, NULL);
+      dia_renderer_draw_rect (renderer, &ul, &lr, &textobj->fill_color, NULL);
     } else {
       Point poly[4];
 
       _textobj_get_poly (textobj, poly);
-      DIA_RENDERER_GET_CLASS (renderer)->draw_polygon (renderer, poly, 4, &textobj->fill_color, NULL);
+      dia_renderer_draw_polygon (renderer, poly, 4, &textobj->fill_color, NULL);
     }
   }
   if (textobj->text_angle == 0) {
-    text_draw(textobj->text, renderer);
+    text_draw (textobj->text, renderer);
   } else {
-    DIA_RENDERER_GET_CLASS (renderer)->draw_rotated_text (renderer, textobj->text,
-                                                         &textobj->text_handle.pos, textobj->text_angle);
+    dia_renderer_draw_rotated_text (renderer,
+                                    textobj->text,
+                                    &textobj->text_handle.pos,
+                                    textobj->text_angle);
     /* XXX: interactive case not working correctly */
     if (DIA_IS_INTERACTIVE_RENDERER (renderer) &&
-        dia_object_is_selected(&textobj->object) &&
+        dia_object_is_selected (&textobj->object) &&
         textobj->text->focus.has_focus) {
       /* editing is not rotated */
-      text_draw(textobj->text, renderer);
+      text_draw (textobj->text, renderer);
     }
-
   }
 }
 
diff --git a/objects/standard/zigzagline.c b/objects/standard/zigzagline.c
index 7cbd9038..78651910 100644
--- a/objects/standard/zigzagline.c
+++ b/objects/standard/zigzagline.c
@@ -202,9 +202,8 @@ zigzagline_move(Zigzagline *zigzagline, Point *to)
 }
 
 static void
-zigzagline_draw(Zigzagline *zigzagline, DiaRenderer *renderer)
+zigzagline_draw (Zigzagline *zigzagline, DiaRenderer *renderer)
 {
-  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
   OrthConn *orth = &zigzagline->orth;
   Point *points;
   int n;
@@ -212,19 +211,19 @@ zigzagline_draw(Zigzagline *zigzagline, DiaRenderer *renderer)
   points = &orth->points[0];
   n = orth->numpoints;
 
-  renderer_ops->set_linewidth(renderer, zigzagline->line_width);
-  renderer_ops->set_linestyle(renderer, zigzagline->line_style, zigzagline->dashlength);
-  renderer_ops->set_linejoin(renderer, zigzagline->line_join);
-  renderer_ops->set_linecaps(renderer, zigzagline->line_caps);
-
-  renderer_ops->draw_rounded_polyline_with_arrows(renderer,
-                                                 points, n,
-                                                 zigzagline->line_width,
-                                                 &zigzagline->line_color,
-                                                 &zigzagline->start_arrow,
-                                                 &zigzagline->end_arrow,
-                                                 zigzagline->corner_radius);
-
+  dia_renderer_set_linewidth (renderer, zigzagline->line_width);
+  dia_renderer_set_linestyle (renderer, zigzagline->line_style, zigzagline->dashlength);
+  dia_renderer_set_linejoin (renderer, zigzagline->line_join);
+  dia_renderer_set_linecaps (renderer, zigzagline->line_caps);
+
+  dia_renderer_draw_rounded_polyline_with_arrows (renderer,
+                                                  points,
+                                                  n,
+                                                  zigzagline->line_width,
+                                                  &zigzagline->line_color,
+                                                  &zigzagline->start_arrow,
+                                                  &zigzagline->end_arrow,
+                                                  zigzagline->corner_radius);
 }
 
 static DiaObject *
diff --git a/plug-ins/cgm/cgm.c b/plug-ins/cgm/cgm.c
index ae5c8e27..304990b2 100644
--- a/plug-ins/cgm/cgm.c
+++ b/plug-ins/cgm/cgm.c
@@ -48,6 +48,14 @@
 #define CGM_IS_RENDERER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CGM_TYPE_RENDERER))
 #define CGM_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CGM_TYPE_RENDERER, CgmRendererClass))
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 /* Noise reduction for
  * return value of 'fwrite', declared with attribute warn_unused_result
  * discussion: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509
@@ -670,16 +678,16 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
 }
 
 static void
-set_font(DiaRenderer *self, DiaFont *font, real height)
+set_font (DiaRenderer *self, DiaFont *font, real height)
 {
-    CgmRenderer *renderer = CGM_RENDERER(self);
-    DiaFont *oldfont = renderer->font;
-
-    renderer->font = dia_font_ref(font);
-    if (oldfont != NULL)
-       dia_font_unref(oldfont);
-    renderer->tcurrent.font_num = FONT_NUM(font);
-    renderer->tcurrent.font_height = height;
+  CgmRenderer *renderer = CGM_RENDERER(self);
+  DiaFont *oldfont = renderer->font;
+
+  renderer->font = dia_font_ref(font);
+  if (oldfont != NULL)
+    dia_font_unref(oldfont);
+  renderer->tcurrent.font_num = FONT_NUM (font);
+  renderer->tcurrent.font_height = height;
 }
 
 static void
@@ -1239,49 +1247,103 @@ cgm_renderer_get_type (void)
   return object_type;
 }
 
+static void
+cgm_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  CgmRenderer *self = CGM_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                g_value_get_object (value),
+                self->tcurrent.font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+cgm_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  CgmRenderer *self = CGM_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->tcurrent.font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 cgm_renderer_finalize (GObject *object)
 {
+  CgmRenderer *self = CGM_RENDERER (object);
+
+  g_clear_object (&self->font);
+
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
 cgm_renderer_class_init (CgmRendererClass *klass)
 {
-    GObjectClass *object_class = G_OBJECT_CLASS (klass);
-    DiaRendererClass *renderer_class = DIA_RENDERER_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  DiaRendererClass *renderer_class = DIA_RENDERER_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
 
-    parent_class = g_type_class_peek_parent (klass);
+  object_class->set_property = cgm_renderer_set_property;
+  object_class->get_property = cgm_renderer_get_property;
+  object_class->finalize = cgm_renderer_finalize;
 
-    object_class->finalize = cgm_renderer_finalize;
+  renderer_class->begin_render = begin_render;
+  renderer_class->end_render = end_render;
 
-    renderer_class->begin_render = begin_render;
-    renderer_class->end_render = end_render;
+  renderer_class->set_linewidth = set_linewidth;
+  renderer_class->set_linecaps = set_linecaps;
+  renderer_class->set_linejoin = set_linejoin;
+  renderer_class->set_linestyle = set_linestyle;
+  renderer_class->set_fillstyle = set_fillstyle;
 
-    renderer_class->set_linewidth = set_linewidth;
-    renderer_class->set_linecaps = set_linecaps;
-    renderer_class->set_linejoin = set_linejoin;
-    renderer_class->set_linestyle = set_linestyle;
-    renderer_class->set_fillstyle = set_fillstyle;
-    renderer_class->set_font = set_font;
+  renderer_class->draw_line = draw_line;
+  renderer_class->draw_polyline = draw_polyline;
 
-    renderer_class->draw_line = draw_line;
-    renderer_class->draw_polyline = draw_polyline;
+  renderer_class->draw_polygon = draw_polygon;
 
-    renderer_class->draw_polygon = draw_polygon;
+  renderer_class->draw_rect = draw_rect;
 
-    renderer_class->draw_rect = draw_rect;
+  renderer_class->draw_arc = draw_arc;
+  renderer_class->fill_arc = fill_arc;
+  renderer_class->draw_ellipse = draw_ellipse;
 
-    renderer_class->draw_arc = draw_arc;
-    renderer_class->fill_arc = fill_arc;
-    renderer_class->draw_ellipse = draw_ellipse;
+  renderer_class->draw_bezier = draw_bezier;
+  renderer_class->draw_beziergon = draw_beziergon;
 
-    renderer_class->draw_bezier = draw_bezier;
-    renderer_class->draw_beziergon = draw_beziergon;
+  renderer_class->draw_string = draw_string;
 
-    renderer_class->draw_string = draw_string;
+  renderer_class->draw_image = draw_image;
 
-    renderer_class->draw_image = draw_image;
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 
diff --git a/plug-ins/drs/dia-render-script-import.c b/plug-ins/drs/dia-render-script-import.c
index 829ddbbc..2218976a 100644
--- a/plug-ins/drs/dia-render-script-import.c
+++ b/plug-ins/drs/dia-render-script-import.c
@@ -261,95 +261,113 @@ static DiaObject *
 _render_object (xmlNodePtr render, DiaContext *ctx)
 {
   DiaRenderer *ir = g_object_new (DIA_TYPE_IMPORT_RENDERER, NULL);
-  DiaRendererClass *ops = DIA_RENDERER_GET_CLASS (ir);
   DiaObject *o;
   xmlNodePtr node;
 
-  g_return_val_if_fail (ops != NULL, NULL);
-
   for (node = render->children; node; node = node->next) {
-    if (xmlStrcmp (node->name, (const xmlChar *)"set-linewidth") == 0)
-      ops->set_linewidth (ir, _parse_real (node, "width"));
-    else if (xmlStrcmp (node->name, (const xmlChar *)"set-linestyle") == 0)
-      ops->set_linestyle (ir, _parse_linestyle (node, "mode"), _parse_real (node, "dash-length"));
-    else if (xmlStrcmp (node->name, (const xmlChar *)"set-linecaps") == 0)
-      ops->set_linecaps (ir, _parse_linecaps (node, "mode"));
-    else if (xmlStrcmp (node->name, (const xmlChar *)"set-linejoin") == 0)
-      ops->set_linejoin (ir, _parse_linejoin (node, "mode"));
-    else if (xmlStrcmp (node->name, (const xmlChar *)"set-fillstyle") == 0)
-      ops->set_fillstyle (ir, _parse_fillstyle (node, "mode"));
+    if (xmlStrcmp (node->name, (const xmlChar *) "set-linewidth") == 0) {
+      dia_renderer_set_linewidth (ir, _parse_real (node, "width"));
+    } else if (xmlStrcmp (node->name, (const xmlChar *) "set-linestyle") == 0) {
+      dia_renderer_set_linestyle (ir,
+                                  _parse_linestyle (node, "mode"),
+                                  _parse_real (node, "dash-length"));
+    } else if (xmlStrcmp (node->name, (const xmlChar *) "set-linecaps") == 0) {
+      dia_renderer_set_linecaps (ir, _parse_linecaps (node, "mode"));
+    } else if (xmlStrcmp (node->name, (const xmlChar *) "set-linejoin") == 0) {
+      dia_renderer_set_linejoin (ir, _parse_linejoin (node, "mode"));
+    } else if (xmlStrcmp (node->name, (const xmlChar *) "set-fillstyle") == 0) {
+      dia_renderer_set_fillstyle (ir, _parse_fillstyle (node, "mode"));
     /* ToDo: set-linejoin, set-fillstyle */
-    else if (xmlStrcmp (node->name, (const xmlChar *)"set-font") == 0) {
+    } else if (xmlStrcmp (node->name, (const xmlChar *) "set-font") == 0) {
       DiaFont *font = _parse_font (node);
-      ops->set_font (ir, font, _parse_real (node, "height"));
+      dia_renderer_set_font (ir, font, _parse_real (node, "height"));
       dia_font_unref (font);
     } else {
       Color *stroke = _parse_color (node, "stroke");
       Color *fill = _parse_color (node, "fill");
 
       if (xmlStrcmp (node->name, (const xmlChar *)"line") == 0) {
-       Point p1 = _parse_point (node, "start");
-       Point p2 = _parse_point (node, "end");
-       if (stroke)
-         ops->draw_line (ir, &p1, &p2, stroke);
-      } else if (   xmlStrcmp (node->name, (const xmlChar *)"polyline") == 0
-                || xmlStrcmp (node->name, (const xmlChar *)"rounded-polyline") == 0) {
-       GArray *path = _parse_points (node, "points");
-       real r = _parse_real (node,"r");
-       if (path) {
-         if (stroke)
-           ops->draw_rounded_polyline (ir, &g_array_index(path,Point,0), path->len, stroke, r);
-         g_array_free (path, TRUE);
-       }
-      } else if (   xmlStrcmp (node->name, (const xmlChar *)"polygon") == 0) {
-       GArray *path = _parse_points (node, "points");
-       if (path) {
-         if (fill || stroke)
-           ops->draw_polygon (ir, &g_array_index(path,Point,0), path->len, fill, stroke);
-         g_array_free (path, TRUE);
-       }
+        Point p1 = _parse_point (node, "start");
+        Point p2 = _parse_point (node, "end");
+        if (stroke) {
+          dia_renderer_draw_line (ir, &p1, &p2, stroke);
+        }
+      } else if (   xmlStrcmp (node->name, (const xmlChar *) "polyline") == 0
+                 || xmlStrcmp (node->name, (const xmlChar *) "rounded-polyline") == 0) {
+        GArray *path = _parse_points (node, "points");
+        real r = _parse_real (node,"r");
+        if (path) {
+          if (stroke) {
+            dia_renderer_draw_rounded_polyline (ir, &g_array_index (path,Point,0), path->len, stroke, r);
+          }
+          g_array_free (path, TRUE);
+        }
+      } else if (   xmlStrcmp (node->name, (const xmlChar *) "polygon") == 0) {
+        GArray *path = _parse_points (node, "points");
+        if (path) {
+          if (fill || stroke) {
+            dia_renderer_draw_polygon (ir, &g_array_index (path,Point,0), path->len, fill, stroke);
+          }
+          g_array_free (path, TRUE);
+        }
       } else if (xmlStrcmp (node->name, (const xmlChar *)"arc") == 0) {
-       Point center = _parse_point (node, "center");
-       if (fill)
-         ops->fill_arc (ir, &center, _parse_real (node, "width"), _parse_real (node, "height"),
-                        _parse_real (node, "angle1"),  _parse_real (node, "angle2"), fill);
-       if (stroke)
-         ops->draw_arc (ir, &center, _parse_real (node, "width"), _parse_real (node, "height"),
-                        _parse_real (node, "angle1"),  _parse_real (node, "angle2"), stroke);
-      } else if (xmlStrcmp (node->name, (const xmlChar *)"ellipse") == 0) {
-       Point center = _parse_point (node, "center");
-       ops->draw_ellipse (ir, &center,
-                          _parse_real (node, "width"),
-                          _parse_real (node, "height"),
-                          fill, stroke);
-      } else if (xmlStrcmp (node->name, (const xmlChar *)"bezier") == 0) {
-       GArray *path = _parse_bezpoints (node, "bezpoints");
-       if (path) {
-         if (fill && stroke)
-           ops->draw_beziergon (ir, &g_array_index(path,BezPoint,0), path->len, fill, stroke);
-         else if (fill)
-           ops->draw_beziergon (ir, &g_array_index(path,BezPoint,0), path->len, fill, NULL);
-         else if (stroke)
-           ops->draw_bezier (ir, &g_array_index(path,BezPoint,0), path->len, stroke);
-         g_array_free (path, TRUE);
-       }
-      } else if (   xmlStrcmp (node->name, (const xmlChar *)"rect") == 0
-                || xmlStrcmp (node->name, (const xmlChar *)"rounded-rect") == 0) {
-       Point ul = _parse_point (node, "lefttop");
-       Point lr = _parse_point (node, "rightbottom");
-       real r = _parse_real (node,"r");
-       if (fill || stroke)
-         ops->draw_rounded_rect (ir, &ul, &lr, fill, stroke, r);
-      } else if (   xmlStrcmp (node->name, (const xmlChar *)"string") == 0) {
-       Point pos = _parse_point (node, "pos");
-       Alignment align = _parse_alignment (node, "alignment");
-       xmlChar *text = xmlNodeGetContent(node);
-       if (text) {
-         ops->draw_string (ir, (const char*)text, &pos, align, fill);
-         xmlFree (text);
-       }
+        Point center = _parse_point (node, "center");
+        if (fill) {
+          dia_renderer_fill_arc (ir,
+                                 &center,
+                                 _parse_real (node, "width"),
+                                 _parse_real (node, "height"),
+                                 _parse_real (node, "angle1"),
+                                 _parse_real (node, "angle2"),
+                                 fill);
+        }
+        if (stroke) {
+          dia_renderer_draw_arc (ir,
+                                 &center,
+                                 _parse_real (node, "width"),
+                                 _parse_real (node, "height"),
+                                 _parse_real (node, "angle1"),
+                                 _parse_real (node, "angle2"),
+                                 stroke);
+        }
+      } else if (xmlStrcmp (node->name, (const xmlChar *) "ellipse") == 0) {
+        Point center = _parse_point (node, "center");
+        dia_renderer_draw_ellipse (ir,
+                                   &center,
+                                   _parse_real (node, "width"),
+                                   _parse_real (node, "height"),
+                                   fill,
+                                   stroke);
+      } else if (xmlStrcmp (node->name, (const xmlChar *) "bezier") == 0) {
+        GArray *path = _parse_bezpoints (node, "bezpoints");
+        if (path) {
+          if (fill && stroke) {
+            dia_renderer_draw_beziergon (ir, &g_array_index (path,BezPoint,0), path->len, fill, stroke);
+          } else if (fill) {
+            dia_renderer_draw_beziergon (ir, &g_array_index (path,BezPoint,0), path->len, fill, NULL);
+          } else if (stroke) {
+            dia_renderer_draw_bezier (ir, &g_array_index (path,BezPoint,0), path->len, stroke);
+          }
+          g_array_free (path, TRUE);
+        }
+      } else if (   xmlStrcmp (node->name, (const xmlChar *) "rect") == 0
+                 || xmlStrcmp (node->name, (const xmlChar *) "rounded-rect") == 0) {
+        Point ul = _parse_point (node, "lefttop");
+        Point lr = _parse_point (node, "rightbottom");
+        real r = _parse_real (node,"r");
+        if (fill || stroke) {
+          dia_renderer_draw_rounded_rect (ir, &ul, &lr, fill, stroke, r);
+        }
+      } else if (   xmlStrcmp (node->name, (const xmlChar *) "string") == 0) {
+        Point pos = _parse_point (node, "pos");
+        Alignment align = _parse_alignment (node, "alignment");
+        xmlChar *text = xmlNodeGetContent (node);
+        if (text) {
+          dia_renderer_draw_string (ir, (const char*) text, &pos, align, fill);
+          xmlFree (text);
+        }
       } else if (node->type == XML_ELEMENT_NODE) {
-       g_warning ("%s not handled", node->name);
+        g_warning ("%s not handled", node->name);
       }
       g_free (fill);
       g_free (stroke);
@@ -363,9 +381,11 @@ _render_object (xmlNodePtr render, DiaContext *ctx)
 static xmlNodePtr
 find_child_named (xmlNodePtr node, const char *name)
 {
-  for (node = node->children; node; node = node->next)
-    if (xmlStrcmp (node->name, (const xmlChar *)name) == 0)
+  for (node = node->children; node; node = node->next) {
+    if (xmlStrcmp (node->name, (const xmlChar *)name) == 0) {
       return node;
+    }
+  }
   return NULL;
 }
 
diff --git a/plug-ins/drs/dia-render-script-renderer.c b/plug-ins/drs/dia-render-script-renderer.c
index 44a95526..3462dad2 100644
--- a/plug-ins/drs/dia-render-script-renderer.c
+++ b/plug-ins/drs/dia-render-script-renderer.c
@@ -42,13 +42,91 @@
 
 G_DEFINE_TYPE (DrsRenderer, drs_renderer, DIA_TYPE_RENDERER);
 
-/* constructor */
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 static void
-drs_renderer_init (DrsRenderer *renderer)
+_node_set_real (xmlNodePtr node, const char *name, real v)
 {
-  renderer->parents = g_queue_new ();
-  renderer->save_props = FALSE;
-  renderer->matrices = g_queue_new ();
+  gchar value[G_ASCII_DTOSTR_BUF_SIZE];
+
+  g_ascii_formatd (value, sizeof (value), "%g", v);
+  xmlSetProp (node, (const xmlChar *) name, (xmlChar *) value);
+}
+
+static void
+set_font (DiaRenderer *self, DiaFont *font, real height)
+{
+  DrsRenderer *renderer = DRS_RENDERER (self);
+  xmlNodePtr node;
+  const PangoFontDescription *pfd = dia_font_get_description (font);
+  char *desc = pango_font_description_to_string (pfd);
+
+  g_clear_object (&renderer->font);
+  renderer->font = font;
+  renderer->font_height = height;
+
+  node =  xmlNewChild (renderer->root, NULL, (const xmlChar *) "set-font", NULL);
+  xmlSetProp (node, (const xmlChar *) "description", (xmlChar *) desc);
+
+  xmlSetProp (node, (const xmlChar *) "family", (xmlChar *) dia_font_get_family (font));
+  xmlSetProp (node, (const xmlChar *) "weight", (xmlChar *) dia_font_get_weight_string (font));
+  xmlSetProp (node, (const xmlChar *) "slant", (xmlChar *) dia_font_get_slant_string (font));
+  _node_set_real (node, "size", dia_font_get_size (font));
+  _node_set_real (node, "height", height);
+
+  g_free (desc);
+}
+
+static void
+drs_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  DrsRenderer *self = DRS_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+drs_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  DrsRenderer *self = DRS_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
 }
 
 /* destructor */
@@ -57,18 +135,20 @@ drs_renderer_finalize (GObject *object)
 {
   DrsRenderer *renderer = DRS_RENDERER (object);
 
+  g_clear_object (&renderer->font);
+
   g_queue_free (renderer->parents);
   g_queue_free (renderer->matrices);
   if (renderer->ctx)
     dia_context_release (renderer->ctx);
 
-  G_OBJECT_CLASS (drs_renderer_parent_class)->finalize (object);  
+  G_OBJECT_CLASS (drs_renderer_parent_class)->finalize (object);
 }
 
-/* 
- * renderer methods 
- */ 
-static void 
+/*
+ * renderer methods
+ */
+static void
 draw_object(DiaRenderer *self,
             DiaObject   *object,
            DiaMatrix   *matrix)
@@ -119,23 +199,23 @@ draw_object(DiaRenderer *self,
       DiaMatrix *m = g_queue_peek_tail (renderer->matrices);
 
       if (IS_GROUP (object)) {
-       /* reimplementation of group_draw to use this draw_object method */
-       GList *list;
-       DiaObject *obj;
+        /* reimplementation of group_draw to use this draw_object method */
+        GList *list;
+        DiaObject *obj;
 
-       list = group_objects (object);
-       while (list != NULL) {
-         obj = (DiaObject *) list->data;
+        list = group_objects (object);
+        while (list != NULL) {
+          obj = (DiaObject *) list->data;
 
-         DIA_RENDERER_GET_CLASS(self)->draw_object(self, obj, m);
-         list = g_list_next(list);
-       }
+          dia_renderer_draw_object (self, obj, m);
+          list = g_list_next (list);
+        }
       } else {
-       /* just the leaf */
-       DIA_RENDERER_GET_CLASS(renderer->transformer)->draw_object(renderer->transformer, object, m);
+        /* just the leaf */
+        dia_renderer_draw_object (renderer->transformer, object, m);
       }
     } else {
-      object->ops->draw(object, DIA_RENDERER (renderer));
+      dia_object_draw (object, DIA_RENDERER (renderer));
     }
     renderer->root = g_queue_pop_tail (renderer->parents);
   }
@@ -157,7 +237,7 @@ begin_render(DiaRenderer *self, const Rectangle *update)
   xmlNodePtr node;
 
   renderer->root = node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"diagram", NULL);
-#if 0  
+#if 0
   _node_set_color (node, "bg_color", &data->bg_color);
 #endif
 }
@@ -181,21 +261,14 @@ static void
 _node_set_color (xmlNodePtr node, const char *name, const Color *color)
 {
   gchar *value;
-  
+
   value = g_strdup_printf ("#%02x%02x%02x%02x",
                           (int)(255*color->red), (int)(255*color->green),
                           (int)(255*color->blue), (int)(255*color->alpha));
   xmlSetProp(node, (const xmlChar *)name, (xmlChar *)value);
   g_free (value);
 }
-static void
-_node_set_real (xmlNodePtr node, const char *name, real v)
-{
-  gchar value[G_ASCII_DTOSTR_BUF_SIZE];
 
-  g_ascii_formatd (value, sizeof(value), "%g", v);
-  xmlSetProp (node, (const xmlChar *)name, (xmlChar *)value);
-}
 static void
 _string_append_point (GString *str, Point *pt, gboolean first)
 {
@@ -227,7 +300,7 @@ _node_set_points (xmlNodePtr node, Point *points, int num_points)
   int i;
 
   str = g_string_new (NULL);
-  
+
   for (i = 0; i < num_points; ++i)
     _string_append_point (str, &points[i], i == 0);
   xmlSetProp(node, (const xmlChar *)"points", (xmlChar *) str->str);
@@ -241,7 +314,7 @@ _node_set_bezpoints (xmlNodePtr node, BezPoint *points, int num_points)
   int i;
 
   str = g_string_new (NULL);
-  
+
   for (i = 0; i < num_points; ++i) {
     BezPoint *bpt = &points[i];
     if (i != 0)
@@ -273,7 +346,7 @@ _node_set_bezpoints (xmlNodePtr node, BezPoint *points, int num_points)
 
 static void
 set_linewidth(DiaRenderer *self, real width)
-{  
+{
   DrsRenderer *renderer = DRS_RENDERER (self);
   xmlNodePtr node;
 
@@ -302,7 +375,7 @@ set_linecaps(DiaRenderer *self, LineCaps mode)
   /* intentionally no default to let 'good' compilers warn about new constants*/
   }
   node =  xmlNewChild(renderer->root, NULL, (const xmlChar *)"set-linecaps", NULL);
-  xmlSetProp(node, (const xmlChar *)"mode", 
+  xmlSetProp(node, (const xmlChar *)"mode",
              value ? (xmlChar *)value : (xmlChar *)"?");
 }
 
@@ -327,7 +400,7 @@ set_linejoin(DiaRenderer *self, LineJoin mode)
   /* intentionally no default to let 'good' compilers warn about new constants*/
   }
   node =  xmlNewChild(renderer->root, NULL, (const xmlChar *)"set-linejoin", NULL);
-  xmlSetProp(node, (const xmlChar *)"mode", 
+  xmlSetProp(node, (const xmlChar *)"mode",
              value ? (xmlChar *)value : (xmlChar *)"?");
 }
 
@@ -359,7 +432,7 @@ set_linestyle(DiaRenderer *self, LineStyle mode, real dash_length)
   /* intentionally no default to let 'good' compilers warn about new constants*/
   }
   node =  xmlNewChild(renderer->root, NULL, (const xmlChar *)"set-linestyle", NULL);
-  xmlSetProp(node, (const xmlChar *)"mode", 
+  xmlSetProp(node, (const xmlChar *)"mode",
              value ? (xmlChar *)value : (xmlChar *)"?");
   if (mode != LINESTYLE_SOLID)
     _node_set_real (node, "dash-length", dash_length);
@@ -379,33 +452,13 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
   /* intentionally no default to let 'good' compilers warn about new constants*/
   }
   node =  xmlNewChild(renderer->root, NULL, (const xmlChar *)"set-fillstyle", NULL);
-  xmlSetProp(node, (const xmlChar *)"mode", 
+  xmlSetProp(node, (const xmlChar *)"mode",
              value ? (xmlChar *)value : (xmlChar *)"?");
 }
 
 static void
-set_font(DiaRenderer *self, DiaFont *font, real height)
-{
-  DrsRenderer *renderer = DRS_RENDERER (self);
-  xmlNodePtr node;
-  const PangoFontDescription *pfd = dia_font_get_description (font);
-  char *desc = pango_font_description_to_string (pfd);
-
-  node =  xmlNewChild(renderer->root, NULL, (const xmlChar *)"set-font", NULL);
-  xmlSetProp(node, (const xmlChar *)"description", (xmlChar *)desc);
-  
-  xmlSetProp(node, (const xmlChar *)"family", (xmlChar *)dia_font_get_family (font));
-  xmlSetProp(node, (const xmlChar *)"weight", (xmlChar *)dia_font_get_weight_string (font));
-  xmlSetProp(node, (const xmlChar *)"slant", (xmlChar *)dia_font_get_slant_string (font));
-  _node_set_real (node, "size", dia_font_get_size (font));
-  _node_set_real (node, "height", height);
-
-  g_free(desc);
-}
-
-static void
-draw_line(DiaRenderer *self, 
-          Point *start, Point *end, 
+draw_line(DiaRenderer *self,
+          Point *start, Point *end,
           Color *color)
 {
   DrsRenderer *renderer = DRS_RENDERER (self);
@@ -418,8 +471,8 @@ draw_line(DiaRenderer *self,
 }
 
 static void
-draw_polyline(DiaRenderer *self, 
-              Point *points, int num_points, 
+draw_polyline(DiaRenderer *self,
+              Point *points, int num_points,
               Color *color)
 {
   DrsRenderer *renderer = DRS_RENDERER (self);
@@ -431,16 +484,16 @@ draw_polyline(DiaRenderer *self,
 }
 
 static void
-draw_polygon (DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polygon (DiaRenderer *self,
+             Point *points, int num_points,
              Color *fill, Color *stroke)
 {
   DrsRenderer *renderer = DRS_RENDERER (self);
   xmlNodePtr node;
-  
+
   g_return_if_fail(1 < num_points);
 
-  node = xmlNewChild(renderer->root, NULL, 
+  node = xmlNewChild(renderer->root, NULL,
                      (const xmlChar *)"polygon", NULL);
   _node_set_points (node, points, num_points);
   if (fill)
@@ -450,7 +503,7 @@ draw_polygon (DiaRenderer *self,
 }
 
 static void
-_rounded_rect(DiaRenderer *self, 
+_rounded_rect(DiaRenderer *self,
               Point *lefttop, Point *rightbottom,
               Color *fill, Color *stroke, real *rounding)
 {
@@ -458,10 +511,10 @@ _rounded_rect(DiaRenderer *self,
   xmlNodePtr node;
 
   if (rounding)
-    node = xmlNewChild(renderer->root, NULL, 
+    node = xmlNewChild(renderer->root, NULL,
                        (const xmlChar *)"rounded-rect", NULL);
   else
-    node = xmlNewChild(renderer->root, NULL, 
+    node = xmlNewChild(renderer->root, NULL,
                        (const xmlChar *)"rect", NULL);
 
   _node_set_point (node, "lefttop", lefttop);
@@ -474,7 +527,7 @@ _rounded_rect(DiaRenderer *self,
     _node_set_color (node, "stroke", stroke);
 }
 static void
-draw_rect(DiaRenderer *self, 
+draw_rect(DiaRenderer *self,
           Point *lefttop, Point *rightbottom,
           Color *fill, Color *stroke)
 {
@@ -482,7 +535,7 @@ draw_rect(DiaRenderer *self,
 }
 
 static void
-draw_rounded_rect(DiaRenderer *self, 
+draw_rounded_rect(DiaRenderer *self,
                   Point *lefttop, Point *rightbottom,
                   Color *fill, Color *stroke, real rounding)
 {
@@ -490,7 +543,7 @@ draw_rounded_rect(DiaRenderer *self,
 }
 
 static void
-_arc(DiaRenderer *self, 
+_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -499,7 +552,7 @@ _arc(DiaRenderer *self,
 {
   DrsRenderer *renderer = DRS_RENDERER (self);
   xmlNodePtr node;
-  
+
   node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"arc", NULL);
   _node_set_point (node, "center", center);
   _node_set_real (node, "width", width);
@@ -512,7 +565,7 @@ _arc(DiaRenderer *self,
     _node_set_color (node, "stroke", color);
 }
 static void
-draw_arc(DiaRenderer *self, 
+draw_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -521,7 +574,7 @@ draw_arc(DiaRenderer *self,
   _arc (self, center, width, height, angle1, angle2, color, FALSE);
 }
 static void
-fill_arc(DiaRenderer *self, 
+fill_arc(DiaRenderer *self,
          Point *center,
          real width, real height,
          real angle1, real angle2,
@@ -531,15 +584,15 @@ fill_arc(DiaRenderer *self,
 }
 
 static void
-draw_ellipse(DiaRenderer *self, 
+draw_ellipse(DiaRenderer *self,
              Point *center,
              real width, real height,
              Color *fill, Color *stroke)
 {
   DrsRenderer *renderer = DRS_RENDERER (self);
   xmlNodePtr node;
-  
-  node = xmlNewChild(renderer->root, NULL, 
+
+  node = xmlNewChild(renderer->root, NULL,
                      (const xmlChar *)"ellipse", NULL);
   _node_set_point (node, "center", center);
   _node_set_real (node, "width", width);
@@ -551,7 +604,7 @@ draw_ellipse(DiaRenderer *self,
 }
 
 static void
-_bezier(DiaRenderer *self, 
+_bezier(DiaRenderer *self,
        BezPoint *points,
        int numpoints,
        Color *fill,
@@ -559,8 +612,8 @@ _bezier(DiaRenderer *self,
 {
   DrsRenderer *renderer = DRS_RENDERER (self);
   xmlNodePtr node;
-  
-  node = xmlNewChild (renderer->root, NULL, 
+
+  node = xmlNewChild (renderer->root, NULL,
                       (const xmlChar *)"bezier", NULL);
   _node_set_bezpoints (node, points, numpoints);
   if (fill)
@@ -569,7 +622,7 @@ _bezier(DiaRenderer *self,
     _node_set_color (node, "stroke", stroke);
 }
 static void
-draw_bezier(DiaRenderer *self, 
+draw_bezier(DiaRenderer *self,
             BezPoint *points,
             int numpoints,
             Color *color)
@@ -577,7 +630,7 @@ draw_bezier(DiaRenderer *self,
   _bezier (self, points, numpoints, NULL, color);
 }
 static void
-draw_beziergon (DiaRenderer *self, 
+draw_beziergon (DiaRenderer *self,
                BezPoint *points,
                int numpoints,
                Color *fill,
@@ -591,14 +644,14 @@ draw_beziergon (DiaRenderer *self,
   }
 }
 
-static void 
+static void
 draw_rounded_polyline (DiaRenderer *self,
                        Point *points, int num_points,
                        Color *color, real radius )
 {
   DrsRenderer *renderer = DRS_RENDERER (self);
   xmlNodePtr node;
-  
+
   node = xmlNewChild (renderer->root, NULL, (const xmlChar *)"rounded-polyline", NULL);
   _node_set_points (node, points, num_points);
   _node_set_color (node, "stroke", color);
@@ -614,7 +667,7 @@ draw_string(DiaRenderer *self,
   DrsRenderer *renderer = DRS_RENDERER (self);
   xmlNodePtr node;
   gchar *align = NULL;
-  
+
   node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"string", NULL);
   _node_set_point (node, "pos", pos);
   _node_set_color (node, "fill", color);
@@ -665,6 +718,8 @@ drs_renderer_class_init (DrsRendererClass *klass)
 
   drs_renderer_parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = drs_renderer_set_property;
+  object_class->get_property = drs_renderer_get_property;
   object_class->finalize = drs_renderer_finalize;
 
   /* renderer members */
@@ -679,8 +734,6 @@ drs_renderer_class_init (DrsRendererClass *klass)
   renderer_class->set_linestyle  = set_linestyle;
   renderer_class->set_fillstyle  = set_fillstyle;
 
-  renderer_class->set_font  = set_font;
-
   renderer_class->draw_line    = draw_line;
   renderer_class->draw_polygon = draw_polygon;
   renderer_class->draw_arc     = draw_arc;
@@ -707,4 +760,16 @@ drs_renderer_class_init (DrsRendererClass *klass)
 #endif
   /* other */
   renderer_class->is_capable_to = is_capable_to;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
+}
+
+/* constructor */
+static void
+drs_renderer_init (DrsRenderer *renderer)
+{
+  renderer->parents = g_queue_new ();
+  renderer->save_props = FALSE;
+  renderer->matrices = g_queue_new ();
 }
diff --git a/plug-ins/drs/dia-render-script-renderer.h b/plug-ins/drs/dia-render-script-renderer.h
index 041d7c24..7134f931 100644
--- a/plug-ins/drs/dia-render-script-renderer.h
+++ b/plug-ins/drs/dia-render-script-renderer.h
@@ -60,6 +60,9 @@ struct _DrsRenderer
   DiaRenderer *transformer;
   /* initially NULL, only to be used during export_data */
   DiaContext *ctx;
+
+  DiaFont *font;
+  double font_height;
 };
 
 struct _DrsRendererClass
diff --git a/plug-ins/drs/dia-render-script.c b/plug-ins/drs/dia-render-script.c
index 566f4fdc..ec415119 100644
--- a/plug-ins/drs/dia-render-script.c
+++ b/plug-ins/drs/dia-render-script.c
@@ -24,9 +24,9 @@
  * - scale: overall scaling of the 'object diagram' done on the renderer level
  * - tweaking renderer parameters otherwise not in the UI, e.g. LineCaps
  *
- * The format is similar to Windows MetaFile.i.e a serialization of function calls together 
+ * The format is similar to Windows MetaFile.i.e a serialization of function calls together
  * with their parameters.
- * An XML representation as well as some binary variant could be provided. 
+ * An XML representation as well as some binary variant could be provided.
  *
  * <diagram>
  *   <meta />
@@ -45,7 +45,7 @@
  *   </layer>
  * </diagram>
  */
- 
+
 #include <config.h>
 
 #include <stdlib.h>
@@ -72,7 +72,6 @@ drs_render_layer (DiaRenderer *self, Layer *layer, gboolean active)
   xmlNodePtr node;
   GList *list;
   DiaObject *obj;
-  DiaRendererClass *renderer_class = DIA_RENDERER_GET_CLASS(renderer);
 
   g_queue_push_tail (renderer->parents, renderer->root);
   renderer->root = node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"layer", NULL);
@@ -85,8 +84,8 @@ drs_render_layer (DiaRenderer *self, Layer *layer, gboolean active)
   list = layer->objects;
   while (list!=NULL) {
     obj = (DiaObject *) list->data;
-    renderer_class->draw_object(self, obj, NULL);
-    list = g_list_next(list);
+    dia_renderer_draw_object (self, obj, NULL);
+    list = g_list_next (list);
   }
 
   renderer->root = g_queue_pop_tail (renderer->parents);
@@ -97,13 +96,13 @@ static void
 drs_data_render (DiagramData *data, DiaRenderer *renderer)
 {
   int i;
-  
-  DIA_RENDERER_GET_CLASS(renderer)->begin_render(renderer, NULL);
-  for (i=0; i<data->layers->len; i++) {
-    Layer *layer = (Layer *) g_ptr_array_index(data->layers, i);
+
+  dia_renderer_begin_render (renderer, NULL);
+  for (i=0; i < data->layers->len; i++) {
+    Layer *layer = (Layer *) g_ptr_array_index (data->layers, i);
     drs_render_layer (renderer, layer, layer == data->active_layer);
   }
-  DIA_RENDERER_GET_CLASS(renderer)->end_render(renderer);
+  dia_renderer_end_render (renderer);
 }
 
 /* dia export funtion */
@@ -115,13 +114,13 @@ export_data(DiagramData *data, DiaContext *ctx,
   DrsRenderer *renderer;
   xmlDtdPtr dtd;
   xmlDocPtr doc;
-  
+
   /* write check - almost same code in every renderer */
   {
     FILE *file = g_fopen(filename, "w");
 
     if (!file) {
-      dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s."), 
+      dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s."),
                                          dia_context_get_filename(ctx));
       return FALSE;
     }
@@ -143,7 +142,7 @@ export_data(DiagramData *data, DiaContext *ctx,
   xmlAddChild((xmlNodePtr) doc, (xmlNodePtr) dtd);
   renderer->root = xmlNewDocNode(doc, NULL, (const xmlChar *)"drs", NULL);
   xmlAddSibling(doc->children, (xmlNodePtr) renderer->root);
-  
+
   drs_data_render(data, DIA_RENDERER(renderer));
 
   xmlSetDocCompressMode(doc, 1);
diff --git a/plug-ins/dxf/dxf-export.c b/plug-ins/dxf/dxf-export.c
index 3bb882d7..de3e3946 100644
--- a/plug-ins/dxf/dxf-export.c
+++ b/plug-ins/dxf/dxf-export.c
@@ -45,6 +45,14 @@
 #define DXF_IS_RENDERER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DXF_TYPE_RENDERER))
 #define DXF_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DXF_TYPE_RENDERER, DxfRendererClass))
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 GType dxf_renderer_get_type (void) G_GNUC_CONST;
 
 typedef struct _DxfRenderer DxfRenderer;
@@ -99,22 +107,21 @@ typedef struct _TextAttrdxf
 
 struct _DxfRenderer
 {
-    DiaRenderer parent_instance;
-
-    FILE *file;
+  DiaRenderer parent_instance;
 
-    DiaFont *font;
+  FILE *file;
 
-    real y0, y1;
+  DiaFont *font;
 
-    LineAttrdxf  lcurrent, linfile;
+  real y0, y1;
 
-    FillEdgeAttrdxf fcurrent, finfile;
+  LineAttrdxf  lcurrent, linfile;
 
-    TextAttrdxf    tcurrent, tinfile;
+  FillEdgeAttrdxf fcurrent, finfile;
 
-    char *layername;
+  TextAttrdxf    tcurrent, tinfile;
 
+  char *layername;
 };
 
 static void dxf_renderer_class_init (DxfRendererClass *klass);
@@ -149,9 +156,69 @@ dxf_renderer_get_type (void)
   return object_type;
 }
 
+static void
+set_font (DiaRenderer *self, DiaFont *font, real height)
+{
+  DxfRenderer *renderer = DXF_RENDERER (self);
+
+  g_clear_object (&renderer->font);
+  renderer->font = g_object_ref (font);
+  renderer->tcurrent.font_height = height;
+}
+
+static void
+dxf_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  DxfRenderer *self = DXF_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->tcurrent.font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+dxf_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  DxfRenderer *self = DXF_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->tcurrent.font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 dxf_renderer_finalize (GObject *object)
 {
+  DxfRenderer *self = DXF_RENDERER (object);
+
+  g_clear_object (&self->font);
+
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
@@ -227,14 +294,6 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
 {
 }
 
-static void
-set_font(DiaRenderer *self, DiaFont *font, real height)
-{
-    DxfRenderer *renderer = DXF_RENDERER(self);
-
-    renderer->tcurrent.font_height = height;
-}
-
 static int
 dxf_color (const Color *color)
 {
@@ -470,6 +529,8 @@ dxf_renderer_class_init (DxfRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = dxf_renderer_set_property;
+  object_class->get_property = dxf_renderer_get_property;
   object_class->finalize = dxf_renderer_finalize;
 
   renderer_class->begin_render = begin_render;
@@ -480,7 +541,6 @@ dxf_renderer_class_init (DxfRendererClass *klass)
   renderer_class->set_linejoin = set_linejoin;
   renderer_class->set_linestyle = set_linestyle;
   renderer_class->set_fillstyle = set_fillstyle;
-  renderer_class->set_font = set_font;
 
   renderer_class->draw_line = draw_line;
   renderer_class->draw_polygon = draw_polygon;
@@ -494,6 +554,9 @@ dxf_renderer_class_init (DxfRendererClass *klass)
   renderer_class->draw_string = draw_string;
 
   renderer_class->draw_image = draw_image;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 static gboolean
@@ -550,17 +613,17 @@ export_dxf(DiagramData *data, DiaContext *ctx,
 
     init_attributes(renderer);
 
-    DIA_RENDERER_GET_CLASS(renderer)->begin_render(DIA_RENDERER(renderer), NULL);
+    dia_renderer_begin_render (DIA_RENDERER (renderer), NULL);
 
     for (i=0; i<data->layers->len; i++) {
-        layer = (Layer *) g_ptr_array_index(data->layers, i);
-           renderer->layername = layer->name;
-        layer_render(layer, DIA_RENDERER(renderer), NULL, NULL, data, 0);
+        layer = (Layer *) g_ptr_array_index (data->layers, i);
+        renderer->layername = layer->name;
+        layer_render (layer, DIA_RENDERER (renderer), NULL, NULL, data, 0);
     }
 
-    DIA_RENDERER_GET_CLASS(renderer)->end_render(DIA_RENDERER(renderer));
+    dia_renderer_end_render (DIA_RENDERER (renderer));
 
-    g_object_unref(renderer);
+    g_object_unref (renderer);
 
     return TRUE;
 }
diff --git a/plug-ins/hpgl/hpgl.c b/plug-ins/hpgl/hpgl.c
index 6ee85f84..1732ad7c 100644
--- a/plug-ins/hpgl/hpgl.c
+++ b/plug-ins/hpgl/hpgl.c
@@ -58,6 +58,14 @@
 #define HPGL_IS_RENDERER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HPGL_TYPE_RENDERER))
 #define HPGL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), HPGL_TYPE_RENDERER, 
HpglRendererClass))
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 GType hpgl_renderer_get_type (void) G_GNUC_CONST;
 
 typedef struct _HpglRenderer HpglRenderer;
@@ -78,6 +86,8 @@ struct _HpglRenderer
     int   has_it;
   } pen[HPGL_MAX_PENS];
   int last_pen;
+
+  DiaFont *font;
   real font_height;
 
   Point size;  /* extent size */
@@ -278,12 +288,15 @@ set_fillstyle(DiaRenderer *object, FillStyle mode)
 }
 
 static void
-set_font(DiaRenderer *object, DiaFont *font, real height)
+set_font (DiaRenderer *object, DiaFont *font, real height)
 {
-    HpglRenderer *renderer = HPGL_RENDERER (object);
+  HpglRenderer *renderer = HPGL_RENDERER (object);
 
-    DIAG_NOTE(g_message("set_font %f", height));
-    renderer->font_height = height;
+  DIAG_NOTE (g_message ("set_font %f", height));
+
+  g_clear_object (&renderer->font);
+  renderer->font = g_object_ref (font);
+  renderer->font_height = height;
 }
 
 /* Need to translate coord system:
@@ -604,9 +617,59 @@ hpgl_renderer_get_type (void)
   return object_type;
 }
 
+static void
+hpgl_renderer_set_property (GObject      *object,
+                            guint         property_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+{
+  HpglRenderer *self = HPGL_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+hpgl_renderer_get_property (GObject    *object,
+                            guint       property_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  HpglRenderer *self = HPGL_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 hpgl_renderer_finalize (GObject *object)
 {
+  HpglRenderer *self = HPGL_RENDERER (object);
+
+  g_clear_object (&self->font);
+
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
@@ -618,6 +681,8 @@ hpgl_renderer_class_init (HpglRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->get_property = hpgl_renderer_get_property;
+  object_class->set_property = hpgl_renderer_set_property;
   object_class->finalize = hpgl_renderer_finalize;
 
   /* renderer members */
@@ -630,8 +695,6 @@ hpgl_renderer_class_init (HpglRendererClass *klass)
   renderer_class->set_linestyle  = set_linestyle;
   renderer_class->set_fillstyle  = set_fillstyle;
 
-  renderer_class->set_font  = set_font;
-
   renderer_class->draw_line    = draw_line;
   renderer_class->draw_polygon = draw_polygon;
   renderer_class->draw_arc     = draw_arc;
@@ -644,6 +707,9 @@ hpgl_renderer_class_init (HpglRendererClass *klass)
   /* medium level functions */
   renderer_class->draw_rect = draw_rect;
   renderer_class->draw_polyline  = draw_polyline;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 /* plug-in interface : export function */
diff --git a/plug-ins/metapost/render_metapost.c b/plug-ins/metapost/render_metapost.c
index 63a0b787..7d211446 100644
--- a/plug-ins/metapost/render_metapost.c
+++ b/plug-ins/metapost/render_metapost.c
@@ -63,13 +63,13 @@ typedef struct _font_lookup_entry {
         /* Dia's name for the font. */
 
     char            *mp_name;
-        /* Second argument for the \usefont command in the embedded TeX 
+        /* Second argument for the \usefont command in the embedded TeX
          * we'll pass to MetaPost. */
 
     real            size_mult;
         /* Converts from a Dia font size to a MetaPost font "scaling factor".
          * If x is the size of your Dia font, then the size of your MetaPost
-         * font will be (x * size_mult) / (10 pts), and you'll have to use 
+         * font will be (x * size_mult) / (10 pts), and you'll have to use
          * (x * size_mult) as the "scale" argument to the label() command. */
 
 } _font_lookup_entry;
@@ -86,7 +86,7 @@ typedef struct _font_lookup_entry {
 /* TODO: Make the fonts in this table map more closely. */
 static _font_lookup_entry FONT_LOOKUP_TABLE[] =
 {
-    /* Since Dia doesn't usually have a "computer modern" font, we map Century 
+    /* Since Dia doesn't usually have a "computer modern" font, we map Century
      * Schoolbook to that font. */
     {"century schoolbook l", DEFAULT_MP_FONT, DEFAULT_SIZE_MULT},
 
@@ -107,16 +107,16 @@ static _font_lookup_entry FONT_LOOKUP_TABLE[] =
 /* An entry in the font weight lookup table. */
 typedef struct _weight_lookup_entry {
     DiaFontStyle    weight;
-        /* Mask your style with DIA_FONT_STYLE_GET_WEIGHT() and compare 
+        /* Mask your style with DIA_FONT_STYLE_GET_WEIGHT() and compare
          * to this... */
 
     char            *mp_weight;
-        /* Third argument for the \usefont command in the embedded TeX 
+        /* Third argument for the \usefont command in the embedded TeX
          * we'll pass to MetaPost. */
 } _weight_lookup_entry;
 
 #define STYLE_TERMINATOR ((DiaFontStyle)0xffffffff)
-static _weight_lookup_entry WEIGHT_LOOKUP_TABLE[] = 
+static _weight_lookup_entry WEIGHT_LOOKUP_TABLE[] =
 {
     {DIA_FONT_ULTRALIGHT,       "m"},
     {DIA_FONT_LIGHT,            "m"},
@@ -136,7 +136,7 @@ typedef struct _slant_lookup_entry {
     char            *mp_slant;
 } _slant_lookup_entry;
 
-static _slant_lookup_entry SLANT_LOOKUP_TABLE[] = 
+static _slant_lookup_entry SLANT_LOOKUP_TABLE[] =
 {
     {DIA_FONT_NORMAL,   "n"},
     {DIA_FONT_OBLIQUE,  "sl"},
@@ -145,6 +145,12 @@ static _slant_lookup_entry SLANT_LOOKUP_TABLE[] =
         /* Terminator */
 };
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
 
 
 static void end_draw_op(MetapostRenderer *renderer);
@@ -165,7 +171,7 @@ end_draw_op(MetapostRenderer *renderer)
             g_ascii_formatd(d1_buf, sizeof(d1_buf), "%5.4f", (gdouble) renderer->line_width) );
 
     if (!color_equals(&renderer->color, &color_black))
-        fprintf(renderer->file, "\n    withcolor (%s, %s, %s)", 
+        fprintf(renderer->file, "\n    withcolor (%s, %s, %s)",
                 g_ascii_formatd(d1_buf, sizeof(d1_buf), "%5.4f", (gdouble) renderer->color.red),
                 g_ascii_formatd(d2_buf, sizeof(d2_buf), "%5.4f", (gdouble) renderer->color.green),
                 g_ascii_formatd(d3_buf, sizeof(d3_buf), "%5.4f", (gdouble) renderer->color.blue) );
@@ -174,15 +180,15 @@ end_draw_op(MetapostRenderer *renderer)
     fprintf(renderer->file, ";\n");
 }
 
-static void 
+static void
 set_line_color(MetapostRenderer *renderer,Color *color)
 {
     gchar red_buf[DTOSTR_BUF_SIZE];
     gchar green_buf[DTOSTR_BUF_SIZE];
     gchar blue_buf[DTOSTR_BUF_SIZE];
-    
+
     renderer->color = *color;
-    fprintf(renderer->file, "%% set_line_color %s, %s, %s\n", 
+    fprintf(renderer->file, "%% set_line_color %s, %s, %s\n",
             mp_dtostr(red_buf, (gdouble)color->red),
            mp_dtostr(green_buf, (gdouble)color->green),
            mp_dtostr(blue_buf, (gdouble)color->blue) );
@@ -197,7 +203,7 @@ static void
 end_render(DiaRenderer *self)
 {
     MetapostRenderer *renderer = METAPOST_RENDERER (self);
-  
+
     fprintf(renderer->file,"endfig;\n");
     fprintf(renderer->file,"end;\n");
     fclose(renderer->file);
@@ -216,7 +222,7 @@ end_render(DiaRenderer *self)
  *
  * \memberof _MetapostRenderer
  */
-static gboolean 
+static gboolean
 is_capable_to (DiaRenderer *renderer, RenderCapability cap)
 {
   if (RENDER_HOLES == cap)
@@ -248,7 +254,7 @@ set_linecaps(DiaRenderer *self, LineCaps mode)
 
     if(mode == renderer->saved_line_cap)
        return;
-  
+
     switch(mode) {
     case LINECAPS_DEFAULT:
     case LINECAPS_BUTT:
@@ -294,7 +300,7 @@ set_linejoin(DiaRenderer *self, LineJoin mode)
     renderer->saved_line_join = mode;
 }
 
-static void 
+static void
 set_linestyle(DiaRenderer *self, LineStyle mode, real dash_length)
 {
     MetapostRenderer *renderer = METAPOST_RENDERER (self);
@@ -321,7 +327,7 @@ draw_with_linestyle(MetapostRenderer *renderer)
        break;
     case LINESTYLE_DASHED:
        mp_dtostr(dash_length_buf, renderer->dash_length);
-       fprintf(renderer->file, "\n    dashed dashpattern (on %sx off %sx)", 
+       fprintf(renderer->file, "\n    dashed dashpattern (on %sx off %sx)",
                dash_length_buf, dash_length_buf);
        break;
     case LINESTYLE_DASH_DOT:
@@ -330,7 +336,7 @@ draw_with_linestyle(MetapostRenderer *renderer)
        mp_dtostr(dash_length_buf, renderer->dash_length);
        mp_dtostr(dot_lenght_buf, renderer->dot_length);
        mp_dtostr(hole_width_buf, hole_width);
-       
+
        fprintf(renderer->file, "\n    dashed dashpattern (on %sx off %sx on %sx off %sx)",
                dash_length_buf, hole_width_buf,
                dot_lenght_buf, hole_width_buf);
@@ -352,7 +358,7 @@ draw_with_linestyle(MetapostRenderer *renderer)
        mp_dtostr(dot_lenght_buf, renderer->dot_length);
        mp_dtostr(hole_width_buf, hole_width);
 
-       fprintf(renderer->file, "\n    dashed dashpattern (on %sx off %sx)", 
+       fprintf(renderer->file, "\n    dashed dashpattern (on %sx off %sx)",
                dot_lenght_buf, hole_width_buf);
        break;
     }
@@ -389,8 +395,8 @@ set_font(DiaRenderer *self, DiaFont *font, real height)
         dia_font_name = "sans";
     } else if (DIA_FONT_STYLE_GET_FAMILY(dia_font_style) == DIA_FONT_SERIF) {
         dia_font_name = "serif";
-    } else if (DIA_FONT_STYLE_GET_FAMILY(dia_font_style) 
-            == DIA_FONT_MONOSPACE) 
+    } else if (DIA_FONT_STYLE_GET_FAMILY(dia_font_style)
+            == DIA_FONT_MONOSPACE)
     {
         dia_font_name = "monospace";
     }
@@ -405,7 +411,7 @@ set_font(DiaRenderer *self, DiaFont *font, real height)
      * table. */
     for (i = 0; FONT_LOOKUP_TABLE[i].dia_name != NULL; i++) {
         if (0 == strncmp(FONT_LOOKUP_TABLE[i].dia_name, dia_font_name,
-                            MAX_FONT_NAME_LEN)) 
+                            MAX_FONT_NAME_LEN))
         {
             /* Found a match. */
             renderer->mp_font = FONT_LOOKUP_TABLE[i].mp_name;
@@ -417,13 +423,13 @@ set_font(DiaRenderer *self, DiaFont *font, real height)
 
     /* Do the same for the weight and size. */
     for (i = 0; WEIGHT_LOOKUP_TABLE[i].weight != STYLE_TERMINATOR; i++) {
-        if (DIA_FONT_STYLE_GET_WEIGHT(dia_font_style) 
+        if (DIA_FONT_STYLE_GET_WEIGHT(dia_font_style)
                 == WEIGHT_LOOKUP_TABLE[i].weight) {
             renderer->mp_weight = WEIGHT_LOOKUP_TABLE[i].mp_weight;
         }
     }
     for (i = 0; SLANT_LOOKUP_TABLE[i].slant != STYLE_TERMINATOR; i++) {
-        if (DIA_FONT_STYLE_GET_SLANT(dia_font_style) 
+        if (DIA_FONT_STYLE_GET_SLANT(dia_font_style)
                 == SLANT_LOOKUP_TABLE[i].slant) {
             renderer->mp_slant = SLANT_LOOKUP_TABLE[i].mp_slant;
         }
@@ -435,8 +441,8 @@ set_font(DiaRenderer *self, DiaFont *font, real height)
 }
 
 static void
-draw_line(DiaRenderer *self, 
-         Point *start, Point *end, 
+draw_line(DiaRenderer *self,
+         Point *start, Point *end,
          Color *line_color)
 {
     MetapostRenderer *renderer = METAPOST_RENDERER (self);
@@ -454,18 +460,18 @@ draw_line(DiaRenderer *self,
 }
 
 static void
-draw_polyline(DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polyline(DiaRenderer *self,
+             Point *points, int num_points,
              Color *line_color)
 {
     MetapostRenderer *renderer = METAPOST_RENDERER (self);
     int i;
     gchar px_buf[DTOSTR_BUF_SIZE];
     gchar py_buf[DTOSTR_BUF_SIZE];
-    
+
     set_line_color(renderer,line_color);
-  
-    fprintf(renderer->file, 
+
+    fprintf(renderer->file,
            "  draw (%sx,%sy)",
            mp_dtostr(px_buf, points[0].x),
            mp_dtostr(py_buf, points[0].y) );
@@ -479,8 +485,8 @@ draw_polyline(DiaRenderer *self,
 }
 
 static void
-draw_polygon(DiaRenderer *self, 
-            Point *points, int num_points, 
+draw_polygon(DiaRenderer *self,
+            Point *points, int num_points,
             Color *fill, Color *stroke)
 {
     MetapostRenderer *renderer = METAPOST_RENDERER (self);
@@ -494,8 +500,8 @@ draw_polygon(DiaRenderer *self,
     fprintf(renderer->file, "%% draw_polygon\n");
     if (stroke)
        set_line_color(renderer,stroke);
-    
-    fprintf(renderer->file, 
+
+    fprintf(renderer->file,
            "  path p;\n"
            "  p = (%sx,%sy)",
            mp_dtostr(px_buf, points[0].x),
@@ -522,7 +528,7 @@ draw_polygon(DiaRenderer *self,
 }
 
 static void
-metapost_arc(MetapostRenderer *renderer, 
+metapost_arc(MetapostRenderer *renderer,
             Point *center,
             real width, real height,
             real angle1, real angle2,
@@ -567,7 +573,7 @@ metapost_arc(MetapostRenderer *renderer,
 }
 
 static void
-draw_arc(DiaRenderer *self, 
+draw_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -579,19 +585,19 @@ draw_arc(DiaRenderer *self,
 }
 
 static void
-fill_arc(DiaRenderer *self, 
+fill_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
         Color *color)
-{ 
+{
     MetapostRenderer *renderer = METAPOST_RENDERER (self);
 
     metapost_arc(renderer,center,width,height,angle1,angle2,color,1);
 }
 
 static void
-draw_ellipse(DiaRenderer *self, 
+draw_ellipse(DiaRenderer *self,
             Point *center,
             real width, real height,
             Color *fill, Color *stroke)
@@ -606,7 +612,7 @@ draw_ellipse(DiaRenderer *self,
     if (stroke)
        set_line_color(renderer,stroke);
 
-    fprintf(renderer->file, 
+    fprintf(renderer->file,
            "  path p;\n"
            "  p = (%sx,%sy)..",
            mp_dtostr(d1_buf, (gdouble) center->x+width/2.0),
@@ -635,7 +641,7 @@ draw_ellipse(DiaRenderer *self,
 }
 
 static void
-draw_bezier(DiaRenderer *self, 
+draw_bezier(DiaRenderer *self,
            BezPoint *points,
            int numpoints, /* numpoints = 4+3*n, n=>0 */
            Color *color)
@@ -657,7 +663,7 @@ draw_bezier(DiaRenderer *self,
     fprintf(renderer->file, "  draw (%sx,%sy)",
            mp_dtostr(p1x_buf, (gdouble) points[0].p1.x),
            mp_dtostr(p1y_buf, (gdouble) points[0].p1.y) );
-  
+
     for (i = 1; i < numpoints; i++)
        switch (points[i].type) {
        case BEZ_MOVE_TO:
@@ -682,7 +688,7 @@ draw_bezier(DiaRenderer *self,
 }
 
 static void
-draw_beziergon (DiaRenderer *self, 
+draw_beziergon (DiaRenderer *self,
                BezPoint *points,
                int numpoints,
                Color *fill,
@@ -796,25 +802,25 @@ draw_string(DiaRenderer *self,
            mp_dtostr(py_buf, pos->y) );
 
     if (!color_equals(&renderer->color, &color_black))
-        fprintf(renderer->file, "\n    withcolor (%s, %s, %s)", 
-                g_ascii_formatd(red_buf, sizeof(red_buf), "%5.4f", (gdouble) renderer->color.red), 
+        fprintf(renderer->file, "\n    withcolor (%s, %s, %s)",
+                g_ascii_formatd(red_buf, sizeof(red_buf), "%5.4f", (gdouble) renderer->color.red),
                 g_ascii_formatd(green_buf, sizeof(green_buf), "%5.4f", (gdouble) renderer->color.green),
                 g_ascii_formatd(blue_buf, sizeof(blue_buf), "%5.4f", (gdouble) renderer->color.blue) );
 
     fprintf(renderer->file,";\n");
 }
 
-static void 
-draw_text (DiaRenderer *self, 
+static void
+draw_text (DiaRenderer *self,
           Text *text)
 {
   Point pos;
   int i;
   pos = text->position;
-  
+
 
   set_font(self, text->font, text->height);
-  
+
   for (i=0;i<text->numlines;i++) {
     TextLine *text_line = text->lines[i];
 
@@ -912,7 +918,7 @@ draw_image(DiaRenderer *self,
             fprintf(renderer->file, "\n");
         }
     }
-    
+
     g_free(mask_data);
     g_free(rgb_data);
 }
@@ -947,14 +953,62 @@ metapost_renderer_get_type (void)
                                             "MetapostRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
+static void
+metapost_renderer_set_property (GObject      *object,
+                                guint         property_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  MetapostRenderer *self = METAPOST_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+metapost_renderer_get_property (GObject    *object,
+                                guint       property_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  MetapostRenderer *self = METAPOST_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 metapost_renderer_finalize (GObject *object)
-{ 
-/*  MetapostRenderer *metapost_renderer = METAPOST_RENDERER (object); */
+{
+  MetapostRenderer *metapost_renderer = METAPOST_RENDERER (object);
+
+  g_clear_object (&metapost_renderer->font);
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
@@ -967,6 +1021,8 @@ metapost_renderer_class_init (MetapostRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->get_property = metapost_renderer_get_property;
+  object_class->set_property = metapost_renderer_set_property;
   object_class->finalize = metapost_renderer_finalize;
 
   renderer_class->begin_render = begin_render;
@@ -977,11 +1033,10 @@ metapost_renderer_class_init (MetapostRendererClass *klass)
   renderer_class->set_linejoin = set_linejoin;
   renderer_class->set_linestyle = set_linestyle;
   renderer_class->set_fillstyle = set_fillstyle;
-  renderer_class->set_font = set_font;
-  
+
   renderer_class->draw_line = draw_line;
   renderer_class->draw_polyline = draw_polyline;
-  
+
   renderer_class->draw_polygon = draw_polygon;
 
   renderer_class->draw_arc = draw_arc;
@@ -996,6 +1051,9 @@ metapost_renderer_class_init (MetapostRendererClass *klass)
   renderer_class->draw_text = draw_text;
 
   renderer_class->draw_image = draw_image;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 /* --- export filter interface --- */
@@ -1015,11 +1073,11 @@ export_metapost(DiagramData *data, DiaContext *ctx,
     gchar d4_buf[DTOSTR_BUF_SIZE];
 
     Color initial_color;
- 
+
     file = g_fopen(filename, "wb");
 
     if (file == NULL) {
-       dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"), 
+       dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"),
                                            dia_context_get_filename(ctx));
        return FALSE;
     }
@@ -1032,12 +1090,12 @@ export_metapost(DiagramData *data, DiaContext *ctx,
     renderer->dash_length = 1.0;
     renderer->dot_length = 0.2;
     renderer->saved_line_style = LINESTYLE_SOLID;
-  
+
     time_now  = time(NULL);
     extent = &data->extents;
-  
+
     name = g_get_user_name();
-  
+
     fprintf(file,
            "%% Metapost TeX macro\n"
            "%% Title: %s\n"
@@ -1071,8 +1129,8 @@ export_metapost(DiagramData *data, DiaContext *ctx,
                        "vardef rjust primary P =\n"
                        "  P shifted -(xpart (lrcorner P - llcorner P), 0)\n"
                        "enddef;\n");
-       
- 
+
+
     fprintf(renderer->file,"  %% picture(%s,%s)(%s,%s)\n",
            mp_dtostr(d1_buf, extent->left * data->paper.scaling),
            mp_dtostr(d2_buf, -extent->bottom * data->paper.scaling),
@@ -1085,7 +1143,7 @@ export_metapost(DiagramData *data, DiaContext *ctx,
        /* Create a variable for Text Scaling  't' */
     fprintf(renderer->file,"  t = %s;\n\n",
            mp_dtostr(d1_buf, data->paper.scaling));
-   
+
     initial_color.red=0.;
     initial_color.green=0.;
     initial_color.blue=0.;
diff --git a/plug-ins/metapost/render_metapost.h b/plug-ins/metapost/render_metapost.h
index 7758d8fc..22d4dc6a 100644
--- a/plug-ins/metapost/render_metapost.h
+++ b/plug-ins/metapost/render_metapost.h
@@ -48,7 +48,7 @@ struct _MetapostRenderer
   DiaRenderer parent_instance;
 
   FILE *file;
-    
+
   LineStyle saved_line_style;
   LineCaps  saved_line_cap;
   LineJoin  saved_line_join;
@@ -64,6 +64,9 @@ struct _MetapostRenderer
   char *mp_slant;
   real mp_font_height;
 
+  DiaFont *font;
+  double font_height;
+
   DiaContext *ctx;
 };
 
diff --git a/plug-ins/pgf/render_pgf.c b/plug-ins/pgf/render_pgf.c
index 3b95cb05..4c6af9ec 100644
--- a/plug-ins/pgf/render_pgf.c
+++ b/plug-ins/pgf/render_pgf.c
@@ -86,40 +86,40 @@ static void set_linejoin(DiaRenderer *self, LineJoin mode);
 static void set_linestyle(DiaRenderer *self, LineStyle mode, real dash_length);
 static void set_fillstyle(DiaRenderer *self, FillStyle mode);
 static void set_font(DiaRenderer *self, DiaFont *font, real height);
-static void draw_line(DiaRenderer *self, 
-                     Point *start, Point *end, 
+static void draw_line(DiaRenderer *self,
+                     Point *start, Point *end,
                      Color *line_color);
-static void draw_polyline(DiaRenderer *self, 
-                         Point *points, int num_points, 
+static void draw_polyline(DiaRenderer *self,
+                         Point *points, int num_points,
                          Color *line_color);
 static void draw_rounded_polyline (DiaRenderer *self,
                         Point *points, int num_points,
                         Color *color, real radius);
-static void draw_polygon(DiaRenderer *self, 
-                        Point *points, int num_points, 
+static void draw_polygon(DiaRenderer *self,
+                        Point *points, int num_points,
                         Color *fill, Color *stroke);
-static void draw_rounded_rect(DiaRenderer *self, 
+static void draw_rounded_rect(DiaRenderer *self,
                              Point *ul_corner, Point *lr_corner,
                              Color *fill, Color *stroke, real radius);
-static void draw_arc(DiaRenderer *self, 
+static void draw_arc(DiaRenderer *self,
                     Point *center,
                     real width, real height,
                     real angle1, real angle2,
                     Color *color);
-static void fill_arc(DiaRenderer *self, 
+static void fill_arc(DiaRenderer *self,
                     Point *center,
                     real width, real height,
                     real angle1, real angle2,
                     Color *color);
-static void draw_ellipse(DiaRenderer *self, 
+static void draw_ellipse(DiaRenderer *self,
                         Point *center,
                         real width, real height,
                         Color *fill, Color *stroke);
-static void draw_bezier(DiaRenderer *self, 
+static void draw_bezier(DiaRenderer *self,
                        BezPoint *points,
                        int numpoints,
                        Color *color);
-static void draw_beziergon(DiaRenderer *self, 
+static void draw_beziergon(DiaRenderer *self,
                           BezPoint *points,
                           int numpoints,
                           Color *fill,
@@ -132,8 +132,8 @@ static void draw_image(DiaRenderer *self,
                       Point *point,
                       real width, real height,
                       DiaImage *image);
-  
-static void draw_line_with_arrows(DiaRenderer *renderer, Point *start, Point *end, 
+
+static void draw_line_with_arrows(DiaRenderer *renderer, Point *start, Point *end,
                                   real line_width, Color *line_color,
                                   Arrow *start_arrow, Arrow *end_arrow);
 static void draw_arc_with_arrows(DiaRenderer *renderer, Point *start, Point *end, Point *midpoint,
@@ -142,34 +142,40 @@ static void draw_arc_with_arrows(DiaRenderer *renderer, Point *start, Point *end
 static void draw_polyline_with_arrows(DiaRenderer *renderer, Point *points, int num_points,
                                      real line_width, Color *color,
                                      Arrow *start_arrow, Arrow *end_arrow);
-static void draw_rounded_polyline_with_arrows(DiaRenderer *renderer, 
-                                     Point *points, int num_points, real line_width, Color *color, 
+static void draw_rounded_polyline_with_arrows(DiaRenderer *renderer,
+                                     Point *points, int num_points, real line_width, Color *color,
                                     Arrow *start_arrow, Arrow *end_arrow, real radius);
 static void draw_bezier_with_arrows(DiaRenderer *renderer, BezPoint *points, int num_points,
                                    real line_width, Color *color,
                                    Arrow *start_arrow, Arrow *end_arrow);
 
 /*store the higher level arrow functions for arrows not (yet) implemented in this PGF macro*/
-void (*orig_draw_line_with_arrows)  (DiaRenderer *renderer, Point *start, Point *end, 
+void (*orig_draw_line_with_arrows)  (DiaRenderer *renderer, Point *start, Point *end,
                                   real line_width, Color *line_color,
                                   Arrow *start_arrow, Arrow *end_arrow);
-  
+
 void (*orig_draw_arc_with_arrows)  (DiaRenderer *renderer, Point *start, Point *end, Point *midpoint,
                                  real line_width, Color *color,
                                  Arrow *start_arrow, Arrow *end_arrow);
-  
+
 void (*orig_draw_polyline_with_arrows) (DiaRenderer *renderer, Point *points, int num_points,
                                      real line_width, Color *color,
                                      Arrow *start_arrow, Arrow *end_arrow);
-  
-void (*orig_draw_rounded_polyline_with_arrows) (DiaRenderer *renderer, 
-                                     Point *points, int num_points, real line_width, Color *color, 
+
+void (*orig_draw_rounded_polyline_with_arrows) (DiaRenderer *renderer,
+                                     Point *points, int num_points, real line_width, Color *color,
                                     Arrow *start_arrow, Arrow *end_arrow, real radius);
 
 void (*orig_draw_bezier_with_arrows) (DiaRenderer *renderer, BezPoint *points, int num_points,
                                    real line_width, Color *color,
                                    Arrow *start_arrow, Arrow *end_arrow);
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
 
 
 /*!
@@ -181,7 +187,7 @@ void (*orig_draw_bezier_with_arrows) (DiaRenderer *renderer, BezPoint *points, i
  *
  * \memberof _PgfRenderer
  */
-static gboolean 
+static gboolean
 is_capable_to (DiaRenderer *renderer, RenderCapability cap)
 {
   if (RENDER_HOLES == cap)
@@ -223,13 +229,63 @@ pgf_renderer_get_type (void)
                                             "PGFRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
+static void
+pgf_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  PgfRenderer *self = PGF_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+pgf_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  PgfRenderer *self = PGF_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 pgf_renderer_finalize (GObject *object)
 {
+  PgfRenderer *self = PGF_RENDERER (object);
+
+  g_clear_object (&self->font);
+
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
@@ -241,6 +297,8 @@ pgf_renderer_class_init (PgfRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = pgf_renderer_set_property;
+  object_class->get_property = pgf_renderer_get_property;
   object_class->finalize = pgf_renderer_finalize;
 
   renderer_class->begin_render = begin_render;
@@ -252,17 +310,16 @@ pgf_renderer_class_init (PgfRendererClass *klass)
   renderer_class->set_linejoin = set_linejoin;
   renderer_class->set_linestyle = set_linestyle;
   renderer_class->set_fillstyle = set_fillstyle;
-  renderer_class->set_font = set_font;
-  
+
   renderer_class->draw_line = draw_line;
   renderer_class->draw_polyline = draw_polyline;
 
   /*problem: the round angles behave slightly differently under PGF:
        the radius measure is not the radius, but the length cut off at the angle
        from each segment of the polyline
-       however, to keep the inherited round corner generation, this command can be commented out*/  
+       however, to keep the inherited round corner generation, this command can be commented out*/
   renderer_class->draw_rounded_polyline = draw_rounded_polyline;
-  
+
   renderer_class->draw_polygon = draw_polygon;
 
   renderer_class->draw_rounded_rect = draw_rounded_rect;
@@ -286,14 +343,17 @@ pgf_renderer_class_init (PgfRendererClass *klass)
   renderer_class->draw_rounded_polyline_with_arrows = draw_rounded_polyline_with_arrows;
   orig_draw_bezier_with_arrows = renderer_class->draw_bezier_with_arrows;
   renderer_class->draw_bezier_with_arrows = draw_bezier_with_arrows;
-  
+
   renderer_class->draw_string = draw_string;
 
   renderer_class->draw_image = draw_image;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 
-static void 
+static void
 set_line_color(PgfRenderer *renderer,Color *color)
 {
     gchar red_buf[DTOSTR_BUF_SIZE];
@@ -309,7 +369,7 @@ set_line_color(PgfRenderer *renderer,Color *color)
            pgf_dtostr(red_buf, (gdouble) color->alpha));
 }
 
-static void 
+static void
 set_fill_color(PgfRenderer *renderer,Color *color)
 {
     gchar red_buf[DTOSTR_BUF_SIZE];
@@ -334,7 +394,7 @@ static void
 end_render(DiaRenderer *self)
 {
     PgfRenderer *renderer = PGF_RENDERER(self);
-  
+
     fprintf(renderer->file,"\\end{tikzpicture}\n");
     fclose(renderer->file);
 }
@@ -354,7 +414,7 @@ static void
 set_linecaps(DiaRenderer *self, LineCaps mode)
 {
     PgfRenderer *renderer = PGF_RENDERER(self);
-  
+
     switch(mode) {
     case LINECAPS_BUTT:
        fprintf(renderer->file, "\\pgfsetbuttcap\n");
@@ -376,7 +436,7 @@ set_linejoin(DiaRenderer *self, LineJoin mode)
 {
     PgfRenderer *renderer = PGF_RENDERER(self);
     /* int ps_mode; */
-  
+
     switch(mode) {
     case LINEJOIN_DEFAULT:
     case LINEJOIN_MITER:
@@ -416,7 +476,7 @@ set_linestyle(DiaRenderer *self, LineStyle mode, real dash_length)
        break;
     case LINESTYLE_DASHED:
        pgf_dtostr(dash_length_buf, dash_length);
-       fprintf(renderer->file, "\\pgfsetdash{{%s\\du}{%s\\du}}{0\\du}\n", 
+       fprintf(renderer->file, "\\pgfsetdash{{%s\\du}{%s\\du}}{0\\du}\n",
                dash_length_buf,
                dash_length_buf);
        break;
@@ -466,15 +526,17 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
 static void
 set_font(DiaRenderer *self, DiaFont *font, real height)
 {
-    PgfRenderer *renderer = PGF_RENDERER(self);
-    /* gchar d_buf[DTOSTR_BUF_SIZE]; */
+  PgfRenderer *renderer = PGF_RENDERER(self);
+
+  g_clear_object (&renderer->font);
+  renderer->font = g_object_ref (font);
 
-    fprintf(renderer->file, "%% setfont left to latex\n");
+  fprintf(renderer->file, "%% setfont left to latex\n");
 }
 
 static void
-draw_line(DiaRenderer *self, 
-         Point *start, Point *end, 
+draw_line(DiaRenderer *self,
+         Point *start, Point *end,
          Color *line_color)
 {
     PgfRenderer *renderer = PGF_RENDERER(self);
@@ -493,16 +555,16 @@ draw_line(DiaRenderer *self,
 }
 
 static void
-draw_polyline(DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polyline(DiaRenderer *self,
+             Point *points, int num_points,
              Color *line_color)
 {
     PgfRenderer *renderer = PGF_RENDERER(self);
     int i;
     gchar px_buf[DTOSTR_BUF_SIZE];
     gchar py_buf[DTOSTR_BUF_SIZE];
-  
-    set_line_color(renderer,line_color);  
+
+    set_line_color(renderer,line_color);
     fprintf(renderer->file, "\\draw (%s\\du,%s\\du)",
            pgf_dtostr(px_buf,points[0].x),
            pgf_dtostr(py_buf,points[0].y) );
@@ -524,7 +586,7 @@ static void draw_rounded_polyline (DiaRenderer *self,
                         Color *color, real radius)
 {
        gchar rad_buf[DTOSTR_BUF_SIZE];
-       
+
        PgfRenderer *renderer = PGF_RENDERER(self);
        pgf_dtostr(rad_buf, (gdouble) radius);
        fprintf(renderer->file, "{\\pgfsetcornersarced{\\pgfpoint{%s\\du}{%s\\du}}",
@@ -544,13 +606,13 @@ pgf_polygon(PgfRenderer *renderer,
 
     if (!filled) {set_line_color(renderer,line_color);}
     else {set_fill_color(renderer,line_color);}
-       
-    
+
+
     fprintf(renderer->file, "\\%s (%s\\du,%s\\du)",
            (filled?"fill":"draw"),
            pgf_dtostr(px_buf,points[0].x),
            pgf_dtostr(py_buf,points[0].y) );
-    
+
     for (i=1;i<num_points;i++) {
        fprintf(renderer->file, "--(%s\\du,%s\\du)",
                pgf_dtostr(px_buf,points[i].x),
@@ -560,8 +622,8 @@ pgf_polygon(PgfRenderer *renderer,
 }
 
 static void
-draw_polygon(DiaRenderer *self, 
-            Point *points, int num_points, 
+draw_polygon(DiaRenderer *self,
+            Point *points, int num_points,
             Color *fill, Color *stroke)
 {
     PgfRenderer *renderer = PGF_RENDERER(self);
@@ -590,7 +652,7 @@ pgf_rect(PgfRenderer *renderer,
     pgf_dtostr(uly_buf, (gdouble) ul_corner->y);
     pgf_dtostr(lrx_buf, (gdouble) lr_corner->x);
     pgf_dtostr(lry_buf, (gdouble) lr_corner->y);
-    
+
     fprintf(renderer->file, "\\%s 
(%s\\du,%s\\du)--(%s\\du,%s\\du)--(%s\\du,%s\\du)--(%s\\du,%s\\du)--cycle;\n",
            (filled?"fill":"draw"),
            ulx_buf, uly_buf,
@@ -599,13 +661,13 @@ pgf_rect(PgfRenderer *renderer,
            lrx_buf, uly_buf );
 }
 
-static void 
-stroke_rounded_rect(DiaRenderer *self, 
+static void
+stroke_rounded_rect(DiaRenderer *self,
                              Point *ul_corner, Point *lr_corner,
                              Color *color, real radius)
 {
        gchar rad_buf[DTOSTR_BUF_SIZE];
-       
+
        PgfRenderer *renderer = PGF_RENDERER(self);
        pgf_dtostr(rad_buf, (gdouble) radius);
        fprintf(renderer->file, "{\\pgfsetcornersarced{\\pgfpoint{%s\\du}{%s\\du}}",
@@ -614,8 +676,8 @@ stroke_rounded_rect(DiaRenderer *self,
        fprintf(renderer->file, "}");
 }
 
-static void 
-fill_rounded_rect(DiaRenderer *self, 
+static void
+fill_rounded_rect(DiaRenderer *self,
                              Point *ul_corner, Point *lr_corner,
                              Color *color, real radius)
 {
@@ -628,8 +690,8 @@ fill_rounded_rect(DiaRenderer *self,
        fprintf(renderer->file, "}");
 }
 
-static void 
-draw_rounded_rect(DiaRenderer *self, 
+static void
+draw_rounded_rect(DiaRenderer *self,
                              Point *ul_corner, Point *lr_corner,
                              Color *fill, Color *stroke, real radius)
 {
@@ -640,7 +702,7 @@ draw_rounded_rect(DiaRenderer *self,
 }
 
 static void
-pgf_arc(PgfRenderer *renderer, 
+pgf_arc(PgfRenderer *renderer,
             Point *center,
             real width, real height,
             real angle1, real angle2,
@@ -657,7 +719,7 @@ pgf_arc(PgfRenderer *renderer,
     gchar sqrt_buf[DTOSTR_BUF_SIZE];
     gchar angle1_buf[DTOSTR_BUF_SIZE];
     gchar angle2_buf[DTOSTR_BUF_SIZE];
-    
+
     radius1=(double) width/2.0;
     radius2=(double) height/2.0;
 
@@ -683,13 +745,13 @@ pgf_arc(PgfRenderer *renderer,
     if (!filled) {set_line_color(renderer,color);}
     else {set_fill_color(renderer,color);}
 
-   
+
     fprintf(renderer->file,"\\pgfpathmoveto{\\pgfpoint{%s\\du}{%s\\du}}\n",
            stx_buf, sty_buf);
     fprintf(renderer->file,"\\pgfpatharc{%s}{%s}{%s\\du and %s\\du}\n",
            angle1_buf, angle2_buf,
            r1_buf, r2_buf);
-           
+
     if (filled)
        fprintf(renderer->file, "\\pgfusepath{fill}\n");
     else
@@ -697,7 +759,7 @@ pgf_arc(PgfRenderer *renderer,
 }
 
 static void
-draw_arc(DiaRenderer *self, 
+draw_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -709,7 +771,7 @@ draw_arc(DiaRenderer *self,
 }
 
 static void
-fill_arc(DiaRenderer *self, 
+fill_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -735,7 +797,7 @@ pgf_ellipse(PgfRenderer *renderer,
     else {set_fill_color(renderer,color);}
 
 /* "\\%sdraw (%s\\du,%s\\du) ellipse (%s\\du and %s\\du)\n", */
-    fprintf(renderer->file, 
+    fprintf(renderer->file,
            "\\pgfpathellipse{\\pgfpoint{%s\\du}{%s\\du}}"
                            "{\\pgfpoint{%s\\du}{0\\du}}"
                            "{\\pgfpoint{0\\du}{%s\\du}}\n"
@@ -748,7 +810,7 @@ pgf_ellipse(PgfRenderer *renderer,
 }
 
 static void
-draw_ellipse(DiaRenderer *self, 
+draw_ellipse(DiaRenderer *self,
             Point *center,
             real width, real height,
             Color *fill, Color *stroke)
@@ -821,7 +883,7 @@ pgf_bezier (PgfRenderer *renderer,
 }
 
 static void
-draw_bezier(DiaRenderer *self, 
+draw_bezier(DiaRenderer *self,
            BezPoint *points,
            int numpoints, /* numpoints = 4+3*n, n=>0 */
            Color *color)
@@ -834,7 +896,7 @@ draw_bezier(DiaRenderer *self,
 
 
 static void
-draw_beziergon (DiaRenderer *self, 
+draw_beziergon (DiaRenderer *self,
                BezPoint *points,
                int numpoints,
                Color *fill,
@@ -845,7 +907,7 @@ draw_beziergon (DiaRenderer *self,
     pgf_bezier(renderer,points,numpoints,fill,stroke,TRUE);
 }
 
-static int 
+static int
 set_arrows(PgfRenderer *renderer, Arrow *start_arrow, Arrow *end_arrow)
 {
     int modified = 2|1; /*=3*/
@@ -867,7 +929,7 @@ set_arrows(PgfRenderer *renderer, Arrow *start_arrow, Arrow *end_arrow)
        modified ^= 2;
     }
     if (modified & 2) start_arrow->type = ARROW_NONE;
-    
+
     switch (end_arrow->type)
     {
     case ARROW_NONE:
@@ -885,12 +947,12 @@ set_arrows(PgfRenderer *renderer, Arrow *start_arrow, Arrow *end_arrow)
        modified ^= 1;
     }
     if (modified & 1) end_arrow->type = ARROW_NONE;
-    
+
     return modified; /* =0 if no native arrow is used */
 }
 
-static void 
-draw_line_with_arrows(DiaRenderer *self, Point *start, Point *end, 
+static void
+draw_line_with_arrows(DiaRenderer *self, Point *start, Point *end,
                                   real line_width, Color *line_color,
                                   Arrow *start_arrow, Arrow *end_arrow)
 {
@@ -924,10 +986,10 @@ draw_line_with_arrows(DiaRenderer *self, Point *start, Point *end,
     {
       orig_draw_line_with_arrows(self, start, end, line_width, line_color, &st_arrow, &e_arrow);
     }
-    
+
 }
 
-static void 
+static void
 draw_arc_with_arrows(DiaRenderer *self, Point *start, Point *end, Point *midpoint,
                                  real line_width, Color *color,
                                  Arrow *start_arrow, Arrow *end_arrow)
@@ -963,7 +1025,7 @@ draw_arc_with_arrows(DiaRenderer *self, Point *start, Point *end, Point *midpoin
     }
 }
 
-static void 
+static void
 draw_polyline_with_arrows(DiaRenderer *self, Point *points, int num_points,
                                      real line_width, Color *color,
                                      Arrow *start_arrow, Arrow *end_arrow)
@@ -999,9 +1061,9 @@ draw_polyline_with_arrows(DiaRenderer *self, Point *points, int num_points,
     }
 }
 
-static void 
-draw_rounded_polyline_with_arrows(DiaRenderer *self, 
-                                     Point *points, int num_points, real line_width, Color *color, 
+static void
+draw_rounded_polyline_with_arrows(DiaRenderer *self,
+                                     Point *points, int num_points, real line_width, Color *color,
                                     Arrow *start_arrow, Arrow *end_arrow, real radius)
 {
     int nat_arr;
@@ -1026,18 +1088,18 @@ draw_rounded_polyline_with_arrows(DiaRenderer *self,
     nat_arr = set_arrows(renderer, &st_arrow, &e_arrow);
     if (nat_arr != 0)
     {
-      orig_draw_rounded_polyline_with_arrows(self, points, num_points, 
+      orig_draw_rounded_polyline_with_arrows(self, points, num_points,
                      line_width, color, NULL, NULL, radius);
     }
     fprintf(renderer->file, "}\n");
     if (nat_arr != 3)
     {
-      orig_draw_rounded_polyline_with_arrows(self, points, num_points, 
+      orig_draw_rounded_polyline_with_arrows(self, points, num_points,
                      line_width, color, &st_arrow, &e_arrow, radius);
     }
 }
 
-static void 
+static void
 draw_bezier_with_arrows(DiaRenderer *self, BezPoint *points, int num_points,
                                    real line_width, Color *color,
                                    Arrow *start_arrow, Arrow *end_arrow)
@@ -1077,7 +1139,7 @@ draw_bezier_with_arrows(DiaRenderer *self, BezPoint *points, int num_points,
 
 
 
-/* Do we really want to do this?  What if the text is intended as 
+/* Do we really want to do this?  What if the text is intended as
  * TeX text?  Jacek says leave it as a TeX string.  TeX uses should know
  * how to escape stuff anyway.  Later versions will get an export option.
  *
@@ -1122,7 +1184,7 @@ tex_escape_string(const gchar *src, DiaContext *ctx)
        case '}': g_string_append(dest, "\\}"); break;
        case '[': g_string_append(dest, "\\ensuremath{[}"); break;
        case ']': g_string_append(dest, "\\ensuremath{]}"); break;
-       default: 
+       default:
             /* if we really have utf8 append the whole 'glyph' */
             g_string_append_len(dest, p, g_utf8_skip[(unsigned char)*p]);
        }
@@ -1195,11 +1257,11 @@ export_pgf(DiagramData *data, DiaContext *ctx,
     gchar scale2_buf[DTOSTR_BUF_SIZE];
 
     Color initial_color;
- 
+
     file = g_fopen(filename, "wb");
 
     if (file == NULL) {
-       dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"), 
+       dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"),
                                            dia_context_get_filename(ctx));
        return FALSE;
     }
@@ -1212,7 +1274,7 @@ export_pgf(DiagramData *data, DiaContext *ctx,
 
     time_now  = time(NULL);
     name = g_get_user_name();
-  
+
     fprintf(file,
        "%% Graphic for TeX using PGF\n"
        "%% Title: %s\n"
@@ -1223,7 +1285,7 @@ export_pgf(DiagramData *data, DiaContext *ctx,
        "%% The following commands are not supported in PSTricks at present\n"
        "%% We define them conditionally, so when they are implemented,\n"
        "%% this pgf file will use them.\n"
-       
+
        "\\ifx\\du\\undefined\n"
        "  \\newlength{\\du}\n"
        "\\fi\n"
diff --git a/plug-ins/pgf/render_pgf.h b/plug-ins/pgf/render_pgf.h
index 03e18972..d42a91b6 100644
--- a/plug-ins/pgf/render_pgf.h
+++ b/plug-ins/pgf/render_pgf.h
@@ -49,13 +49,16 @@ struct _PgfRendererClass
 
 struct _PgfRenderer
 {
-    DiaRenderer parent_instance;
+  DiaRenderer parent_instance;
 
-    FILE *file;
-    int is_ps;
-    int pagenum;
+  FILE *file;
+  int is_ps;
+  int pagenum;
 
-    DiaContext *ctx;
+  DiaContext *ctx;
+
+  DiaFont *font;
+  double font_height;
 };
 
 extern DiaExportFilter pgf_export_filter;
diff --git a/plug-ins/postscript/diapsrenderer.c b/plug-ins/postscript/diapsrenderer.c
index 427c5283..8d7d0073 100644
--- a/plug-ins/postscript/diapsrenderer.c
+++ b/plug-ins/postscript/diapsrenderer.c
@@ -2,7 +2,7 @@
  * Copyright (C) 1998 Alexander Larsson
  *
  * diapsrenderer.c -- implements the base class for Postscript rendering
- *   It is mostly refactoring of render_eps.c (some stuff not from the 
+ *   It is mostly refactoring of render_eps.c (some stuff not from the
  *   latest version but from 1.24) before PS rendering became multi-pass
  *   and text rendering became (necessary) complicated.
  * Refatoring: Copyright (C) 2002 Hans Breuer
@@ -36,6 +36,14 @@
 #define psrenderer_dtostr(buf,d) \
        g_ascii_formatd(buf, sizeof(buf), "%f", d)
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 /* Returns TRUE if this file is an encapsulated postscript file
  * (including e.g. epsi).
  */
@@ -62,7 +70,7 @@ lazy_setcolor(DiaPsRenderer *renderer,
     fprintf(renderer->file, "%s %s %s srgb\n",
             psrenderer_dtostr(r_buf, (gdouble) color->red),
             psrenderer_dtostr(g_buf, (gdouble) color->green),
-            psrenderer_dtostr(b_buf, (gdouble) color->blue) );    
+            psrenderer_dtostr(b_buf, (gdouble) color->blue) );
   }
 }
 
@@ -102,9 +110,9 @@ begin_render(DiaRenderer *self, const Rectangle *update)
     fprintf(renderer->file,
             "%%%%Magnification: 1.0000\n"
          "%%%%BoundingBox: 0 0 %d %d\n",
-            (int) ceil(  (renderer->extent.right - renderer->extent.left) 
+            (int) ceil(  (renderer->extent.right - renderer->extent.left)
                        * renderer->scale),
-            (int) ceil(  (renderer->extent.bottom - renderer->extent.top) 
+            (int) ceil(  (renderer->extent.bottom - renderer->extent.top)
                        * renderer->scale) );
 
   else
@@ -126,16 +134,17 @@ begin_render(DiaRenderer *self, const Rectangle *update)
 }
 
 static void
-end_render(DiaRenderer *self)
+end_render (DiaRenderer *self)
 {
-  DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
+  DiaPsRenderer *renderer = DIA_PS_RENDERER (self);
 
-  if (renderer_is_eps(renderer))
-    fprintf(renderer->file, "showpage\n");
+  if (renderer_is_eps (renderer)) {
+    fprintf (renderer->file, "showpage\n");
+  }
 
-  if (self->font != NULL) {
-    dia_font_unref(self->font);
-    self->font = NULL;
+  if (renderer->font != NULL) {
+    dia_font_unref (renderer->font);
+    renderer->font = NULL;
   }
 }
 
@@ -158,7 +167,7 @@ set_linecaps(DiaRenderer *self, LineCaps mode)
 {
   DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
   int ps_mode;
-  
+
   switch(mode) {
   case LINECAPS_DEFAULT:
   case LINECAPS_BUTT:
@@ -182,7 +191,7 @@ set_linejoin(DiaRenderer *self, LineJoin mode)
 {
   DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
   int ps_mode;
-  
+
   switch(mode) {
   case LINEJOIN_DEFAULT:
   case LINEJOIN_MITER:
@@ -269,30 +278,31 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
 }
 
 static void
-set_font(DiaRenderer *self, DiaFont *font, real height)
+set_font (DiaRenderer *self, DiaFont *font, real height)
 {
-  DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
+  DiaPsRenderer *renderer = DIA_PS_RENDERER (self);
   gchar h_buf[DTOSTR_BUF_SIZE];
 
-  if (font != self->font || height != self->font_height) {
+  if (font != renderer->font || height != renderer->font_height) {
     DiaFont *old_font;
 
-    fprintf(renderer->file, "/%s-latin1 ff %s scf sf\n",
-           dia_font_get_psfontname(font),
-           psrenderer_dtostr(h_buf, (gdouble) height*0.7) );
-    old_font = self->font;
-    self->font = font;
-    dia_font_ref(self->font);
+    fprintf (renderer->file,
+             "/%s-latin1 ff %s scf sf\n",
+             dia_font_get_psfontname (font),
+             psrenderer_dtostr (h_buf, (gdouble) height*0.7));
+    old_font = renderer->font;
+    renderer->font = font;
+    dia_font_ref (renderer->font);
     if (old_font != NULL) {
-      dia_font_unref(old_font);
+      dia_font_unref (old_font);
     }
-    self->font_height = height;
+    renderer->font_height = height;
   }
 }
 
 static void
-draw_line(DiaRenderer *self, 
-         Point *start, Point *end, 
+draw_line(DiaRenderer *self,
+         Point *start, Point *end,
          Color *line_color)
 {
   DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
@@ -311,8 +321,8 @@ draw_line(DiaRenderer *self,
 }
 
 static void
-draw_polyline(DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polyline(DiaRenderer *self,
+             Point *points, int num_points,
              Color *line_color)
 {
   DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
@@ -321,7 +331,7 @@ draw_polyline(DiaRenderer *self,
   gchar py_buf[DTOSTR_BUF_SIZE];
 
   lazy_setcolor(renderer,line_color);
-  
+
   fprintf(renderer->file, "n %s %s m ",
          psrenderer_dtostr(px_buf, points[0].x),
          psrenderer_dtostr(py_buf, points[0].y) );
@@ -365,8 +375,8 @@ psrenderer_polygon(DiaPsRenderer *renderer,
 }
 
 static void
-draw_polygon (DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polygon (DiaRenderer *self,
+             Point *points, int num_points,
              Color *fill, Color *stroke)
 {
   DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
@@ -430,7 +440,7 @@ draw_arc(DiaRenderer *self,
 }
 
 static void
-fill_arc(DiaRenderer *self, 
+fill_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -451,7 +461,7 @@ psrenderer_ellipse(DiaPsRenderer *renderer,
   gchar cy_buf[DTOSTR_BUF_SIZE];
   gchar w_buf[DTOSTR_BUF_SIZE];
   gchar h_buf[DTOSTR_BUF_SIZE];
-  
+
   lazy_setcolor(renderer,color);
 
   fprintf(renderer->file, "n %s %s %s %s 0 360 ellipse %s\n",
@@ -463,7 +473,7 @@ psrenderer_ellipse(DiaPsRenderer *renderer,
 }
 
 static void
-draw_ellipse(DiaRenderer *self, 
+draw_ellipse(DiaRenderer *self,
             Point *center,
             real width, real height,
             Color *fill, Color *stroke)
@@ -498,7 +508,7 @@ psrenderer_bezier(DiaPsRenderer *renderer,
   fprintf(renderer->file, "n %s %s m",
          psrenderer_dtostr(p1x_buf, (gdouble) points[0].p1.x),
          psrenderer_dtostr(p1y_buf, (gdouble) points[0].p1.y) );
-  
+
   for (i = 1; i < numpoints; i++)
     switch (points[i].type) {
     case BEZ_MOVE_TO:
@@ -519,7 +529,7 @@ psrenderer_bezier(DiaPsRenderer *renderer,
              psrenderer_dtostr(p3y_buf, (gdouble) points[i].p3.y) );
       break;
     }
-  
+
   if (filled)
     fprintf(renderer->file, " ef\n");
   else
@@ -527,7 +537,7 @@ psrenderer_bezier(DiaPsRenderer *renderer,
 }
 
 static void
-draw_bezier(DiaRenderer *self, 
+draw_bezier(DiaRenderer *self,
            BezPoint *points,
            int numpoints, /* numpoints = 4+3*n, n=>0 */
            Color *color)
@@ -537,7 +547,7 @@ draw_bezier(DiaRenderer *self,
 }
 
 static void
-draw_beziergon (DiaRenderer *self, 
+draw_beziergon (DiaRenderer *self,
                BezPoint *points, /* Last point must be same as first point */
                int numpoints,
                Color *fill,
@@ -609,7 +619,7 @@ put_text_alignment (DiaPsRenderer *renderer,
            psrenderer_dtostr(px_buf, pos->x),
            psrenderer_dtostr(py_buf, pos->y) );
     break;
-  }  
+  }
 }
 
 static void
@@ -633,7 +643,7 @@ draw_string(DiaRenderer *self,
   g_free(buffer);
 
   pos_adj.x = pos->x;
-  pos_adj.y = pos->y - dia_font_descent("", self->font, self->font_height);
+  pos_adj.y = pos->y - dia_font_descent ("", renderer->font, renderer->font_height);
   put_text_alignment (renderer, alignment, &pos_adj);
 
   fprintf(renderer->file, " gs 1 -1 sc sh gr\n");
@@ -705,7 +715,7 @@ draw_image(DiaRenderer *self,
   }
   fprintf(renderer->file, "gr\n");
   fprintf(renderer->file, "\n");
-   
+
   g_free(rgb_data);
   g_free(mask_data);
 }
@@ -812,7 +822,7 @@ begin_prolog (DiaPsRenderer *renderer)
 }
 
 /* helper function */
-static void 
+static void
 print_reencode_font(FILE *file, char *fontname)
 {
   /* Don't reencode the Symbol font, as it doesn't work in latin1 encoding.
@@ -878,7 +888,7 @@ end_prolog (DiaPsRenderer *renderer)
 {
   gchar d1_buf[DTOSTR_BUF_SIZE];
   gchar d2_buf[DTOSTR_BUF_SIZE];
-  
+
   if (renderer_is_eps(renderer)) {
     fprintf(renderer->file,
             "%s %s scale\n",
@@ -905,7 +915,7 @@ ps_renderer_init (GTypeInstance *instance, gpointer g_class)
   renderer->file = NULL;
 
   renderer->lcolor.red = -1.0;
-  
+
   renderer->is_portrait = TRUE;
 
   renderer->scale = 28.346;
@@ -940,16 +950,63 @@ dia_ps_renderer_get_type (void)
                                             "DiaPsRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
+static void
+dia_ps_renderer_set_property (GObject      *object,
+                              guint         property_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+{
+  DiaPsRenderer *self = DIA_PS_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+dia_ps_renderer_get_property (GObject    *object,
+                              guint       property_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  DiaPsRenderer *self = DIA_PS_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 dia_ps_renderer_finalize (GObject *object)
 {
   DiaPsRenderer *renderer = DIA_PS_RENDERER (object);
 
   g_free(renderer->title);
+  g_clear_object (&renderer->font);
   /*  fclose(renderer->file);*/
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
@@ -964,6 +1021,8 @@ dia_ps_renderer_class_init (DiaPsRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = dia_ps_renderer_set_property;
+  object_class->get_property = dia_ps_renderer_get_property;
   object_class->finalize = dia_ps_renderer_finalize;
 
   renderer_class->begin_render = begin_render;
@@ -974,7 +1033,6 @@ dia_ps_renderer_class_init (DiaPsRendererClass *klass)
   renderer_class->set_linejoin   = set_linejoin;
   renderer_class->set_linestyle  = set_linestyle;
   renderer_class->set_fillstyle  = set_fillstyle;
-  renderer_class->set_font       = set_font;
 
   renderer_class->draw_line    = draw_line;
   renderer_class->draw_polygon = draw_polygon;
@@ -993,5 +1051,7 @@ dia_ps_renderer_class_init (DiaPsRendererClass *klass)
   ps_renderer_class->begin_prolog = begin_prolog;
   ps_renderer_class->dump_fonts = dump_fonts;
   ps_renderer_class->end_prolog = end_prolog;
-}
 
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
+}
diff --git a/plug-ins/postscript/diapsrenderer.h b/plug-ins/postscript/diapsrenderer.h
index 267330f8..4af041b3 100644
--- a/plug-ins/postscript/diapsrenderer.h
+++ b/plug-ins/postscript/diapsrenderer.h
@@ -47,6 +47,9 @@ struct _DiaPsRenderer
   Rectangle extent;
 
   DiaContext *ctx;
+
+  DiaFont *font;
+  double font_height;
 };
 
 struct _DiaPsRendererClass
diff --git a/plug-ins/pstricks/render_pstricks.c b/plug-ins/pstricks/render_pstricks.c
index 44b0ffdb..4197110a 100644
--- a/plug-ins/pstricks/render_pstricks.c
+++ b/plug-ins/pstricks/render_pstricks.c
@@ -31,7 +31,7 @@ TODO:
 4. Maybe draw and fill in a single move?? Will solve the problems
    with visible thin white line between the border and the fill
 5. Verify the Pango stuff isn't spitting out things TeX is unable to read
-   
+
 NOT WORKING (exporting macros):
  1. linecaps
  2. linejoins
@@ -64,6 +64,14 @@ NOT WORKING (exporting macros):
 #define pstricks_dtostr(buf,d) \
        g_ascii_formatd(buf,sizeof(buf),"%f",d)
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 static void begin_render(DiaRenderer *self, const Rectangle *update);
 static void end_render(DiaRenderer *self);
 static void set_linewidth(DiaRenderer *self, real linewidth);
@@ -72,34 +80,34 @@ static void set_linejoin(DiaRenderer *self, LineJoin mode);
 static void set_linestyle(DiaRenderer *self, LineStyle mode, real dash_length);
 static void set_fillstyle(DiaRenderer *self, FillStyle mode);
 static void set_font(DiaRenderer *self, DiaFont *font, real height);
-static void draw_line(DiaRenderer *self, 
-                     Point *start, Point *end, 
+static void draw_line(DiaRenderer *self,
+                     Point *start, Point *end,
                      Color *line_color);
-static void draw_polyline(DiaRenderer *self, 
-                         Point *points, int num_points, 
+static void draw_polyline(DiaRenderer *self,
+                         Point *points, int num_points,
                          Color *line_color);
-static void draw_polygon(DiaRenderer *self, 
-                        Point *points, int num_points, 
+static void draw_polygon(DiaRenderer *self,
+                        Point *points, int num_points,
                         Color *fill, Color *stroke);
-static void draw_arc(DiaRenderer *self, 
+static void draw_arc(DiaRenderer *self,
                     Point *center,
                     real width, real height,
                     real angle1, real angle2,
                     Color *color);
-static void fill_arc(DiaRenderer *self, 
+static void fill_arc(DiaRenderer *self,
                     Point *center,
                     real width, real height,
                     real angle1, real angle2,
                     Color *color);
-static void draw_ellipse(DiaRenderer *self, 
+static void draw_ellipse(DiaRenderer *self,
                         Point *center,
                         real width, real height,
                         Color *fill, Color *stroke);
-static void draw_bezier(DiaRenderer *self, 
+static void draw_bezier(DiaRenderer *self,
                        BezPoint *points,
                        int numpoints,
                        Color *color);
-static void draw_beziergon(DiaRenderer *self, 
+static void draw_beziergon(DiaRenderer *self,
                           BezPoint *points,
                           int numpoints,
                           Color *fill,
@@ -122,7 +130,7 @@ static void draw_image(DiaRenderer *self,
  *
  * \memberof _PstricksRenderer
  */
-static gboolean 
+static gboolean
 is_capable_to (DiaRenderer *renderer, RenderCapability cap)
 {
   if (RENDER_HOLES == cap)
@@ -165,13 +173,63 @@ pstricks_renderer_get_type (void)
                                             "PstricksRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
+static void
+pstricks_renderer_set_property (GObject      *object,
+                                guint         property_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  PstricksRenderer *self = PSTRICKS_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+pstricks_renderer_get_property (GObject    *object,
+                                guint       property_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  PstricksRenderer *self = PSTRICKS_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 pstricks_renderer_finalize (GObject *object)
 {
+  PstricksRenderer *self = PSTRICKS_RENDERER (object);
+
+  g_clear_object (&self->font);
+
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
@@ -183,6 +241,8 @@ pstricks_renderer_class_init (PstricksRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = pstricks_renderer_set_property;
+  object_class->get_property = pstricks_renderer_get_property;
   object_class->finalize = pstricks_renderer_finalize;
 
   renderer_class->begin_render = begin_render;
@@ -194,11 +254,10 @@ pstricks_renderer_class_init (PstricksRendererClass *klass)
   renderer_class->set_linejoin = set_linejoin;
   renderer_class->set_linestyle = set_linestyle;
   renderer_class->set_fillstyle = set_fillstyle;
-  renderer_class->set_font = set_font;
-  
+
   renderer_class->draw_line = draw_line;
   renderer_class->draw_polyline = draw_polyline;
-  
+
   renderer_class->draw_polygon = draw_polygon;
 
   renderer_class->draw_arc = draw_arc;
@@ -212,10 +271,13 @@ pstricks_renderer_class_init (PstricksRendererClass *klass)
   renderer_class->draw_string = draw_string;
 
   renderer_class->draw_image = draw_image;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 
-static void 
+static void
 set_line_color(PstricksRenderer *renderer,Color *color)
 {
     gchar red_buf[DTOSTR_BUF_SIZE];
@@ -229,7 +291,7 @@ set_line_color(PstricksRenderer *renderer,Color *color)
     fprintf(renderer->file,"\\psset{linecolor=dialinecolor}\n");
 }
 
-static void 
+static void
 set_fill_color(PstricksRenderer *renderer,Color *color)
 {
     gchar red_buf[DTOSTR_BUF_SIZE];
@@ -252,7 +314,7 @@ static void
 end_render(DiaRenderer *self)
 {
     PstricksRenderer *renderer = PSTRICKS_RENDERER(self);
-  
+
     fprintf(renderer->file,"}\\endpspicture");
     fclose(renderer->file);
 }
@@ -273,7 +335,7 @@ set_linecaps(DiaRenderer *self, LineCaps mode)
 {
     PstricksRenderer *renderer = PSTRICKS_RENDERER(self);
     int ps_mode;
-  
+
     switch(mode) {
     case LINECAPS_DEFAULT:
     case LINECAPS_BUTT:
@@ -297,7 +359,7 @@ set_linejoin(DiaRenderer *self, LineJoin mode)
 {
     PstricksRenderer *renderer = PSTRICKS_RENDERER(self);
     int ps_mode;
-  
+
     switch(mode) {
     case LINEJOIN_DEFAULT:
     case LINEJOIN_MITER:
@@ -338,7 +400,7 @@ set_linestyle(DiaRenderer *self, LineStyle mode, real dash_length)
        break;
     case LINESTYLE_DASHED:
        pstricks_dtostr(dash_length_buf, dash_length);
-       fprintf(renderer->file, "\\psset{linestyle=dashed,dash=%s %s}\n", 
+       fprintf(renderer->file, "\\psset{linestyle=dashed,dash=%s %s}\n",
                dash_length_buf, dash_length_buf);
        break;
     case LINESTYLE_DASH_DOT:
@@ -377,19 +439,24 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
 }
 
 static void
-set_font(DiaRenderer *self, DiaFont *font, real height)
+set_font (DiaRenderer *self, DiaFont *font, real height)
 {
-    PstricksRenderer *renderer = PSTRICKS_RENDERER(self);
-    gchar d_buf[DTOSTR_BUF_SIZE];
+  PstricksRenderer *renderer = PSTRICKS_RENDERER(self);
+  gchar d_buf[DTOSTR_BUF_SIZE];
 
-    fprintf(renderer->file, "\\setfont{%s}{%s}\n",
-            dia_font_get_psfontname(font),
-           pstricks_dtostr(d_buf, (gdouble) height) );
+  g_clear_object (&renderer->font);
+  renderer->font = g_object_ref (font);
+  renderer->font_height = height;
+
+  fprintf (renderer->file,
+           "\\setfont{%s}{%s}\n",
+           dia_font_get_psfontname (font),
+           pstricks_dtostr (d_buf, (gdouble) height) );
 }
 
 static void
-draw_line(DiaRenderer *self, 
-         Point *start, Point *end, 
+draw_line(DiaRenderer *self,
+         Point *start, Point *end,
          Color *line_color)
 {
     PstricksRenderer *renderer = PSTRICKS_RENDERER(self);
@@ -408,16 +475,16 @@ draw_line(DiaRenderer *self,
 }
 
 static void
-draw_polyline(DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polyline(DiaRenderer *self,
+             Point *points, int num_points,
              Color *line_color)
 {
     PstricksRenderer *renderer = PSTRICKS_RENDERER(self);
     int i;
     gchar px_buf[DTOSTR_BUF_SIZE];
     gchar py_buf[DTOSTR_BUF_SIZE];
-  
-    set_line_color(renderer,line_color);  
+
+    set_line_color(renderer,line_color);
     fprintf(renderer->file, "\\psline(%s,%s)",
            pstricks_dtostr(px_buf,points[0].x),
            pstricks_dtostr(py_buf,points[0].y) );
@@ -432,7 +499,7 @@ draw_polyline(DiaRenderer *self,
 }
 
 static void
-draw_polygon (DiaRenderer *self, 
+draw_polygon (DiaRenderer *self,
              Point *points, int num_points,
              Color *fill, Color *stroke)
 {
@@ -463,7 +530,7 @@ draw_polygon (DiaRenderer *self,
            style,
            pstricks_dtostr(px_buf,points[0].x),
            pstricks_dtostr(py_buf,points[0].y) );
-    
+
     for (i=1;i<num_points;i++) {
        fprintf(renderer->file, "(%s,%s)",
                pstricks_dtostr(px_buf,points[i].x),
@@ -473,7 +540,7 @@ draw_polygon (DiaRenderer *self,
 }
 
 static void
-pstricks_arc(PstricksRenderer *renderer, 
+pstricks_arc(PstricksRenderer *renderer,
             Point *center,
             real width, real height,
             real angle1, real angle2,
@@ -487,7 +554,7 @@ pstricks_arc(PstricksRenderer *renderer,
     gchar sqrt_buf[DTOSTR_BUF_SIZE];
     gchar angle1_buf[DTOSTR_BUF_SIZE];
     gchar angle2_buf[DTOSTR_BUF_SIZE];
-    
+
     radius1=(double) width/2.0;
     radius2=(double) height/2.0;
 
@@ -511,7 +578,7 @@ pstricks_arc(PstricksRenderer *renderer,
            cx_buf, cy_buf,
            sqrt_buf,
            angle2_buf, angle1_buf);
-  
+
     fprintf(renderer->file,"\\psellipse%s(%s,%s)(%s,%s)\n",
            (filled?"*":""),
            cx_buf, cy_buf,
@@ -521,7 +588,7 @@ pstricks_arc(PstricksRenderer *renderer,
 }
 
 static void
-draw_arc(DiaRenderer *self, 
+draw_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -533,7 +600,7 @@ draw_arc(DiaRenderer *self,
 }
 
 static void
-fill_arc(DiaRenderer *self, 
+fill_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -566,7 +633,7 @@ pstricks_ellipse(PstricksRenderer *renderer,
 }
 
 static void
-draw_ellipse(DiaRenderer *self, 
+draw_ellipse(DiaRenderer *self,
             Point *center,
             real width, real height,
             Color *fill, Color *stroke)
@@ -631,7 +698,7 @@ pstricks_bezier(PstricksRenderer *renderer,
                    pstricks_dtostr(p3y_buf,points[i].p3.y) );
            break;
        }
-    
+
     if (closed)
        fprintf(renderer->file, "\\closepath\n");
 
@@ -644,7 +711,7 @@ pstricks_bezier(PstricksRenderer *renderer,
 }
 
 static void
-draw_bezier(DiaRenderer *self, 
+draw_bezier(DiaRenderer *self,
            BezPoint *points,
            int numpoints, /* numpoints = 4+3*n, n=>0 */
            Color *color)
@@ -656,7 +723,7 @@ draw_bezier(DiaRenderer *self,
 
 
 static void
-draw_beziergon (DiaRenderer *self, 
+draw_beziergon (DiaRenderer *self,
                BezPoint *points,
                int numpoints,
                Color *fill,
@@ -667,7 +734,7 @@ draw_beziergon (DiaRenderer *self,
     pstricks_bezier(renderer,points,numpoints,fill,stroke,TRUE);
 }
 
-/* Do we really want to do this?  What if the text is intended as 
+/* Do we really want to do this?  What if the text is intended as
  * TeX text?  Jacek says leave it as a TeX string.  TeX uses should know
  * how to escape stuff anyway.  Later versions will get an export option.
  *
@@ -702,7 +769,7 @@ tex_escape_string(const gchar *src, DiaContext *ctx)
        case '}': g_string_append(dest, "\\}"); break;
        case '[': g_string_append(dest, "\\ensuremath{\\left[\\right.}"); break;
        case ']': g_string_append(dest, "\\ensuremath{\\left.\\right]}"); break;
-       default: 
+       default:
             /* if we really have utf8 append the whole 'glyph' */
             g_string_append_len(dest, p, g_utf8_skip[(unsigned char)*p]);
        }
@@ -863,11 +930,11 @@ export_pstricks(DiagramData *data, DiaContext *ctx,
     gchar scale2_buf[DTOSTR_BUF_SIZE];
 
     Color initial_color;
- 
+
     file = g_fopen(filename, "wb");
 
     if (file == NULL) {
-       dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"), 
+       dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"),
                                            dia_context_get_filename(ctx));
        return FALSE;
     }
@@ -880,9 +947,9 @@ export_pstricks(DiagramData *data, DiaContext *ctx,
 
     time_now  = time(NULL);
     extent = &data->extents;
-  
+
     name = g_get_user_name();
-  
+
     fprintf(file,
        "%% PSTricks TeX macro\n"
        "%% Title: %s\n"
diff --git a/plug-ins/pstricks/render_pstricks.h b/plug-ins/pstricks/render_pstricks.h
index 6b98ef76..c16d7946 100644
--- a/plug-ins/pstricks/render_pstricks.h
+++ b/plug-ins/pstricks/render_pstricks.h
@@ -49,13 +49,16 @@ struct _PstricksRendererClass
 
 struct _PstricksRenderer
 {
-    DiaRenderer parent_instance;
+  DiaRenderer parent_instance;
 
-    FILE *file;
-    int is_ps;
-    int pagenum;
+  FILE *file;
+  int is_ps;
+  int pagenum;
 
-    DiaContext *ctx;
+  DiaContext *ctx;
+
+  DiaFont *font;
+  double font_height;
 };
 
 extern DiaExportFilter pstricks_export_filter;
diff --git a/plug-ins/python/pydia-render.c b/plug-ins/python/pydia-render.c
index a50e3890..f9419a75 100644
--- a/plug-ins/python/pydia-render.c
+++ b/plug-ins/python/pydia-render.c
@@ -79,7 +79,7 @@ struct _DiaPyRenderer
   DiaRenderer parent_instance;
 
   char*     filename;
-  PyObject* self; 
+  PyObject* self;
   PyObject* diagram_data;
   char*     old_locale;
 };
@@ -118,8 +118,8 @@ begin_render(DiaRenderer *renderer, const Rectangle *update)
   if (func && PyCallable_Check(func)) {
     Py_INCREF(self);
     Py_INCREF(func);
-    arg = Py_BuildValue ("(Os)", 
-                         DIA_PY_RENDERER(renderer)->diagram_data, 
+    arg = Py_BuildValue ("(Os)",
+                         DIA_PY_RENDERER(renderer)->diagram_data,
                          DIA_PY_RENDERER(renderer)->filename);
     if (arg) {
       res = PyEval_CallObject (func, arg);
@@ -167,7 +167,7 @@ end_render(DiaRenderer *renderer)
  */
 static void
 set_linewidth(DiaRenderer *renderer, real linewidth)
-{  
+{
   PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer);
 
   func = PyObject_GetAttrString (self, "set_linewidth");
@@ -351,38 +351,6 @@ set_fillstyle(DiaRenderer *renderer, FillStyle mode)
     PyErr_Clear();
 }
 
-/*!
- * \brief Set font for later use
- *
- * Optional on the PyDia side.
- *
- * \memberof _DiaPyRenderer
- */
-static void
-set_font(DiaRenderer *renderer, DiaFont *font, real height)
-{
-  PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer);
-
-  func = PyObject_GetAttrString (self, "set_font");
-  if (func && PyCallable_Check(func)) {
-    PyObject *ofont = PyDiaFont_New (font);
-
-    Py_INCREF(self);
-    Py_INCREF(func);
-    arg = Py_BuildValue ("(Od)", ofont, height);
-    if (arg) {
-      res = PyEval_CallObject (func, arg);
-      ON_RES(res, FALSE);
-    }
-    Py_XDECREF (arg);
-    Py_XDECREF (ofont);
-    Py_DECREF(func);
-    Py_DECREF(self);
-  }
-  else /* member optional */
-    PyErr_Clear();
-}
-
 static gpointer parent_class = NULL;
 
 /*!
@@ -419,7 +387,7 @@ is_capable_to (DiaRenderer *renderer, RenderCapability cap)
   return bRet;
 }
 
-/*! 
+/*!
  * \brief Render all the visible object in the layer
  * @param renderer explicit this pointer
  * @param layer    layer to draw
@@ -471,8 +439,8 @@ draw_layer (DiaRenderer *renderer,
  * Optional on the PyDia side. If not implemented the base class method
  * will be called.
  *
- * Intercepting this method on the Python side allows to create per 
- * object information in the drawing. It is also necessary if the PyDia 
+ * Intercepting this method on the Python side allows to create per
+ * object information in the drawing. It is also necessary if the PyDia
  * renderer should support transformations.
  *
  * If implementing a drawing export filter and overwriting draw_object()
@@ -531,14 +499,14 @@ draw_object (DiaRenderer *renderer, DiaObject *object, DiaMatrix *matrix)
 /*!
  * \brief Draw line
  *
- * Not optional on the PyDia side. If not implemented a runtime warning 
+ * Not optional on the PyDia side. If not implemented a runtime warning
  * will be generated when called.
  *
  * \memberof _DiaPyRenderer
  */
 static void
-draw_line(DiaRenderer *renderer, 
-          Point *start, Point *end, 
+draw_line(DiaRenderer *renderer,
+          Point *start, Point *end,
           Color *line_colour)
 {
   PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer);
@@ -580,8 +548,8 @@ draw_line(DiaRenderer *renderer,
  * \memberof _DiaPyRenderer
  */
 static void
-draw_polyline(DiaRenderer *renderer, 
-             Point *points, int num_points, 
+draw_polyline(DiaRenderer *renderer,
+             Point *points, int num_points,
              Color *line_colour)
 {
   PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer);
@@ -619,8 +587,8 @@ draw_polyline(DiaRenderer *renderer,
  * \memberof _DiaPyRenderer
  */
 static void
-draw_polygon(DiaRenderer *renderer, 
-            Point *points, int num_points, 
+draw_polygon(DiaRenderer *renderer,
+            Point *points, int num_points,
             Color *fill, Color *stroke)
 {
   PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer);
@@ -658,7 +626,7 @@ draw_polygon(DiaRenderer *renderer,
 }
 
 static void
-draw_rect(DiaRenderer *renderer, 
+draw_rect(DiaRenderer *renderer,
          Point *ul_corner, Point *lr_corner,
          Color *fill, Color *stroke)
 {
@@ -700,7 +668,7 @@ draw_rect(DiaRenderer *renderer,
 }
 
 static void
-draw_rounded_rect(DiaRenderer *renderer, 
+draw_rounded_rect(DiaRenderer *renderer,
          Point *ul_corner, Point *lr_corner,
          Color *fill, Color *stroke, real rounding)
 {
@@ -743,7 +711,7 @@ draw_rounded_rect(DiaRenderer *renderer,
 }
 
 static void
-draw_arc(DiaRenderer *renderer, 
+draw_arc(DiaRenderer *renderer,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -783,13 +751,13 @@ draw_arc(DiaRenderer *renderer,
 /*!
  * \brief Fill arc
  *
- * Not optional on the PyDia side. If not implemented a runtime warning 
+ * Not optional on the PyDia side. If not implemented a runtime warning
  * will be generated when called.
  *
  * \memberof _DiaPyRenderer
  */
 static void
-fill_arc(DiaRenderer *renderer, 
+fill_arc(DiaRenderer *renderer,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -829,13 +797,13 @@ fill_arc(DiaRenderer *renderer,
 /*!
  * \brief Draw ellipse
  *
- * Not optional on the PyDia side. If not implemented a runtime warning 
+ * Not optional on the PyDia side. If not implemented a runtime warning
  * will be generated when called.
  *
  * \memberof _DiaPyRenderer
  */
 static void
-draw_ellipse(DiaRenderer *renderer, 
+draw_ellipse(DiaRenderer *renderer,
             Point *center,
             real width, real height,
             Color *fill, Color *stroke)
@@ -880,7 +848,7 @@ draw_ellipse(DiaRenderer *renderer,
 }
 
 static void
-draw_bezier(DiaRenderer *renderer, 
+draw_bezier(DiaRenderer *renderer,
            BezPoint *points,
            int num_points,
            Color *colour)
@@ -913,7 +881,7 @@ draw_bezier(DiaRenderer *renderer,
 
 /* kept for backward compatibility, not any longer in the renderer interface */
 static void
-fill_bezier(DiaRenderer *renderer, 
+fill_bezier(DiaRenderer *renderer,
            BezPoint *points, /* Last point must be same as first point */
            int num_points,
            Color *colour)
@@ -998,7 +966,7 @@ draw_beziergon (DiaRenderer *renderer,
 /*!
  * \brief Draw string
  *
- * Not optional on the PyDia side. If not implemented a runtime warning 
+ * Not optional on the PyDia side. If not implemented a runtime warning
  * will be generated when called.
  *
  * \memberof _DiaPyRenderer
@@ -1049,7 +1017,7 @@ draw_string(DiaRenderer *renderer,
 /*!
  * \brief Draw image
  *
- * Not optional on the PyDia side. If not implemented a runtime warning 
+ * Not optional on the PyDia side. If not implemented a runtime warning
  * will be generated when called.
  *
  * \memberof _DiaPyRenderer
@@ -1099,7 +1067,7 @@ PyDia_export_data(DiagramData *data, DiaContext *ctx,
     file = g_fopen(filename, "w"); /* "wb" for binary! */
 
     if (file == NULL) {
-      dia_context_add_message_with_errno(ctx, errno, _("Couldn't open '%s' for writing.\n"), 
+      dia_context_add_message_with_errno(ctx, errno, _("Couldn't open '%s' for writing.\n"),
                                         dia_context_get_filename(ctx));
       return FALSE;
     }
@@ -1127,10 +1095,10 @@ DiaRenderer *
 PyDia_new_renderer_wrapper (PyObject *self)
 {
   DiaPyRenderer *wrapper;
-  
+
   wrapper = g_object_new (DIA_TYPE_PY_RENDERER, NULL);
   wrapper->self = self;
-  
+
   return DIA_RENDERER (wrapper);
 }
 
@@ -1163,7 +1131,7 @@ dia_py_renderer_get_type (void)
                                             "DiaPyRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
@@ -1202,8 +1170,6 @@ dia_py_renderer_class_init (DiaPyRendererClass *klass)
   renderer_class->set_linestyle  = set_linestyle;
   renderer_class->set_fillstyle  = set_fillstyle;
 
-  renderer_class->set_font  = set_font;
-
   renderer_class->draw_line    = draw_line;
   renderer_class->draw_polygon = draw_polygon;
   renderer_class->draw_arc     = draw_arc;
diff --git a/plug-ins/svg/render_svg.c b/plug-ins/svg/render_svg.c
index 1af057a6..ca7b5f78 100644
--- a/plug-ins/svg/render_svg.c
+++ b/plug-ins/svg/render_svg.c
@@ -82,7 +82,7 @@ typedef struct _SvgRendererClass SvgRendererClass;
 struct _SvgRenderer
 {
   DiaSvgRenderer parent_instance;
-  
+
   /*! track the parents while grouping in draw_object() */
   GQueue *parents;
 };
@@ -155,7 +155,7 @@ svg_renderer_get_type (void)
                                             "SvgRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
@@ -185,7 +185,7 @@ end_render (DiaRenderer *self)
  *
  * \memberof _SvgRenderer
  */
-static gboolean 
+static gboolean
 is_capable_to (DiaRenderer *renderer, RenderCapability cap)
 {
   if (RENDER_HOLES == cap)
@@ -207,7 +207,7 @@ svg_renderer_finalize (GObject *object)
 
   g_queue_free (svg_renderer->parents);
 
-  G_OBJECT_CLASS (parent_class)->finalize (object);  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
@@ -248,7 +248,7 @@ new_svg_renderer(DiagramData *data, const char *filename)
   gchar buf[512];
   Rectangle *extent;
   xmlDtdPtr dtd;
- 
+
   /* we need access to our base object */
   renderer = DIA_SVG_RENDERER (g_object_new(SVG_TYPE_RENDERER, NULL));
 
@@ -325,7 +325,7 @@ draw_layer (DiaRenderer *self,
  *
  * \memberof _SvgRenderer
  */
-static void 
+static void
 draw_object(DiaRenderer *self,
             DiaObject   *object,
            DiaMatrix   *matrix)
@@ -368,7 +368,7 @@ draw_object(DiaRenderer *self,
     }
 
     object->ops->draw(object, DIA_RENDERER (renderer));
-  
+
     /* no easy way to count? */
     child = renderer->root->children;
     while (child != NULL) {
@@ -478,20 +478,27 @@ draw_string(DiaRenderer *self,
            const char *text,
            Point *pos, Alignment alignment,
            Color *colour)
-{    
+{
   DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
   xmlNodePtr node;
   gchar d_buf[G_ASCII_DTOSTR_BUF_SIZE];
+  DiaFont *font;
+  double font_height;
 
-  node = xmlNewChild(renderer->root, renderer->svg_name_space, (xmlChar *)"text", (xmlChar *)text);
+  font = dia_renderer_get_font (self, &font_height);
+
+  node = xmlNewChild (renderer->root,
+                      renderer->svg_name_space,
+                      (xmlChar *) "text",
+                      (xmlChar *) text);
   _adjust_space_preserve (node, text);
 
-  node_set_text_style(node, renderer, self->font, self->font_height, alignment, colour);
-  
-  dia_svg_dtostr(d_buf, pos->x);
-  xmlSetProp(node, (xmlChar *)"x", (xmlChar *)d_buf);
-  dia_svg_dtostr(d_buf, pos->y);
-  xmlSetProp(node, (xmlChar *)"y", (xmlChar *)d_buf);
+  node_set_text_style (node, renderer, font, font_height, alignment, colour);
+
+  dia_svg_dtostr (d_buf, pos->x);
+  xmlSetProp (node, (xmlChar *) "x", (xmlChar *)d_buf);
+  dia_svg_dtostr (d_buf, pos->y);
+  xmlSetProp (node, (xmlChar *) "y", (xmlChar *)d_buf);
 }
 
 /*!
@@ -507,8 +514,8 @@ draw_text_line(DiaRenderer *self, TextLine *text_line,
   DiaFont *font = text_line_get_font(text_line); /* no reference? */
   real font_height = text_line_get_height(text_line);
   gchar d_buf[G_ASCII_DTOSTR_BUF_SIZE];
-  
-  node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"text", 
+
+  node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"text",
                     (xmlChar *) text_line_get_string(text_line));
   _adjust_space_preserve (node, text_line_get_string(text_line));
 
@@ -584,7 +591,7 @@ draw_rotated_text (DiaRenderer *self, Text *text, Point *center, real angle)
     xmlSetProp(node_tspan, (const xmlChar *)"x", (xmlChar *) d_buf);
     dia_svg_dtostr(d_buf, pos.y);
     xmlSetProp(node_tspan, (const xmlChar *)"y", (xmlChar *) d_buf);
-    
+
     pos.y += text->height;
   }
 }
diff --git a/plug-ins/vdx/vdx-export.c b/plug-ins/vdx/vdx-export.c
index 62cc68ec..4512db32 100644
--- a/plug-ins/vdx/vdx-export.c
+++ b/plug-ins/vdx/vdx-export.c
@@ -57,6 +57,15 @@
 #define VDX_IS_RENDERER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VDX_TYPE_RENDERER))
 #define VDX_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VDX_TYPE_RENDERER, VDXRendererClass))
 
+
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 GType vdx_renderer_get_type (void) G_GNUC_CONST;
 
 typedef struct _VDXRenderer VDXRenderer;
@@ -139,6 +148,68 @@ vdx_renderer_get_type (void)
   return object_type;
 }
 
+/** Set font
+ * @param self a renderer
+ * @param font new font
+ * @param height new font height
+ */
+
+static void
+set_font (DiaRenderer *self, DiaFont *font, real height)
+{
+  VDXRenderer *renderer = VDX_RENDERER(self);
+
+  g_clear_object (&renderer->font);
+  renderer->font = g_object_ref (font);
+  renderer->fontheight = height;
+}
+
+static void
+vdx_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  VDXRenderer *self = VDX_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->fontheight);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+vdx_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  VDXRenderer *self = VDX_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->fontheight);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 /** Finalise a renderer
  * @param object a renderer
  */
@@ -146,6 +217,10 @@ vdx_renderer_get_type (void)
 static void
 vdx_renderer_finalize (GObject *object)
 {
+  VDXRenderer *self = VDX_RENDERER (object);
+
+  g_clear_object (&self->font);
+
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
@@ -290,21 +365,6 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
   renderer->fillmode = mode;
 }
 
-/** Set font
- * @param self a renderer
- * @param font new font
- * @param height new font height
- */
-
-static void
-set_font(DiaRenderer *self, DiaFont *font, real height)
-{
-  VDXRenderer *renderer = VDX_RENDERER(self);
-
-  renderer->font = font;
-  renderer->fontheight = height;
-}
-
 /** Get colour number from colour table
  * @param renderer a renderer
  * @param color the colour
@@ -1718,36 +1778,36 @@ export_vdx(DiagramData *data, DiaContext *ctx,
 
     renderer->version = 2002;   /* For now */
 
-    DIA_RENDERER_GET_CLASS(renderer)->begin_render(DIA_RENDERER(renderer), NULL);
+    dia_renderer_begin_render (DIA_RENDERER (renderer), NULL);
 
     /* First run through without drawing to setup tables */
-    for (i=0; i<data->layers->len; i++)
-    {
-        layer = (Layer *) g_ptr_array_index(data->layers, i);
-        if (layer->visible)
-            layer_render(layer, DIA_RENDERER(renderer), NULL, NULL, data, 0);
-        renderer->depth++;
+    for (i = 0; i < data->layers->len; i++) {
+      layer = (Layer *) g_ptr_array_index (data->layers, i);
+      if (layer->visible) {
+        layer_render (layer, DIA_RENDERER (renderer), NULL, NULL, data, 0);
+      }
+      renderer->depth++;
     }
 
-    write_header(data, renderer);
+    write_header (data, renderer);
 
-    DIA_RENDERER_GET_CLASS(renderer)->end_render(DIA_RENDERER(renderer));
+    dia_renderer_end_render (DIA_RENDERER (renderer));
 
     renderer->first_pass = FALSE;
 
-    DIA_RENDERER_GET_CLASS(renderer)->begin_render(DIA_RENDERER(renderer), NULL);
+    dia_renderer_begin_render (DIA_RENDERER (renderer), NULL);
 
     /* Now render */
 
-    for (i=0; i<data->layers->len; i++)
-    {
-        layer = (Layer *) g_ptr_array_index(data->layers, i);
-        if (layer->visible)
-            layer_render(layer, DIA_RENDERER(renderer), NULL, NULL, data, 0);
+    for (i = 0; i < data->layers->len; i++) {
+        layer = (Layer *) g_ptr_array_index (data->layers, i);
+        if (layer->visible) {
+            layer_render (layer, DIA_RENDERER (renderer), NULL, NULL, data, 0);
+        }
         renderer->depth++;
     }
 
-    DIA_RENDERER_GET_CLASS(renderer)->end_render(DIA_RENDERER(renderer));
+    dia_renderer_end_render (DIA_RENDERER (renderer));
 
     /* Done */
 
@@ -2047,6 +2107,8 @@ vdx_renderer_class_init (VDXRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = vdx_renderer_set_property;
+  object_class->get_property = vdx_renderer_get_property;
   object_class->finalize = vdx_renderer_finalize;
 
   renderer_class->begin_render = begin_render;
@@ -2057,7 +2119,6 @@ vdx_renderer_class_init (VDXRendererClass *klass)
   renderer_class->set_linejoin = set_linejoin;
   renderer_class->set_linestyle = set_linestyle;
   renderer_class->set_fillstyle = set_fillstyle;
-  renderer_class->set_font = set_font;
 
   renderer_class->draw_line = draw_line;
   renderer_class->draw_polyline = draw_polyline;
@@ -2080,4 +2141,7 @@ vdx_renderer_class_init (VDXRendererClass *klass)
 
   renderer_class->draw_rounded_rect = draw_rounded_rect;
   /* Further high level methods not required (or desired?) */
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
diff --git a/plug-ins/wmf/wmf.cpp b/plug-ins/wmf/wmf.cpp
index 575b2f8f..c13f724a 100644
--- a/plug-ins/wmf/wmf.cpp
+++ b/plug-ins/wmf/wmf.cpp
@@ -101,6 +101,14 @@ G_BEGIN_DECLS
 #define WMF_IS_RENDERER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WMF_TYPE_RENDERER))
 #define WMF_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), WMF_TYPE_RENDERER, WmfRendererClass))
 
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 GType wmf_renderer_get_type (void) G_GNUC_CONST;
 
 typedef struct _WmfRenderer WmfRenderer;
@@ -108,32 +116,35 @@ typedef struct _WmfRendererClass WmfRendererClass;
 
 struct _WmfRenderer
 {
-    DiaRenderer parent_instance;
+  DiaRenderer parent_instance;
 
-    W32::HDC  hFileDC;
-    gchar*    sFileName;
+  DiaFont *font;
+  double font_height;
 
-    W32::HDC  hPrintDC;
+  W32::HDC  hFileDC;
+  gchar*    sFileName;
 
-    /* if applicable everything is scaled to 0.01 mm */
-    int nLineWidth;  /* need to cache these, because ... */
-    int fnPenStyle;  /* ... both are needed at the same time */
-    W32::HPEN  hPen; /* ugliness by concept, see DonePen() */
+  W32::HDC  hPrintDC;
 
-    W32::HFONT hFont;
-    PLACEABLEMETAHEADER pmh;
-    double xoff, yoff;
-    double scale;
+  /* if applicable everything is scaled to 0.01 mm */
+  int nLineWidth;  /* need to cache these, because ... */
+  int fnPenStyle;  /* ... both are needed at the same time */
+  W32::HPEN  hPen; /* ugliness by concept, see DonePen() */
+
+  W32::HFONT hFont;
+  PLACEABLEMETAHEADER pmh;
+  double xoff, yoff;
+  double scale;
 
-    int nDashLen; /* the scaled dash length */
-    gboolean platform_is_nt; /* advanced line styles supported */
-    gboolean target_emf; /* write enhanced metafile */
-    W32::RECT margins;
+  int nDashLen; /* the scaled dash length */
+  gboolean platform_is_nt; /* advanced line styles supported */
+  gboolean target_emf; /* write enhanced metafile */
+  W32::RECT margins;
 
-    gboolean use_pango;
-    PangoContext* pango_context;
+  gboolean use_pango;
+  PangoContext* pango_context;
 
-    DiaContext* ctx;
+  DiaContext* ctx;
 };
 
 struct _WmfRendererClass
@@ -517,29 +528,32 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
 }
 
 static void
-set_font(DiaRenderer *self, DiaFont *font, real height)
+set_font (DiaRenderer *self, DiaFont *font, real height)
 {
-    WmfRenderer *renderer = WMF_RENDERER (self);
-
-    W32::LPCTSTR sFace;
-    W32::DWORD dwItalic = 0;
-    W32::DWORD dwWeight = FW_DONTCARE;
-    DiaFontStyle style = dia_font_get_style(font);
-    real font_size = dia_font_get_size (font) * (height / dia_font_get_height (font));
-
-
-    DIAG_NOTE(renderer, "set_font %s %f\n",
-              dia_font_get_family (font), height);
-    if (renderer->hFont) {
-       W32::DeleteObject(renderer->hFont);
-       renderer->hFont = NULL;
-    }
-    if (renderer->pango_context) {
-        g_object_unref (renderer->pango_context);
-       renderer->pango_context = NULL;
-    }
+  WmfRenderer *renderer = WMF_RENDERER (self);
+
+  W32::LPCTSTR sFace;
+  W32::DWORD dwItalic = 0;
+  W32::DWORD dwWeight = FW_DONTCARE;
+  DiaFontStyle style = dia_font_get_style (font);
+  real font_size = dia_font_get_size (font) * (height / dia_font_get_height (font));
+
+  g_clear_object (&renderer->font);
+  renderer->font = DIA_FONT (g_object_ref (font));
+  renderer->font_height = height;
+
+  DIAG_NOTE (renderer, "set_font %s %f\n",
+             dia_font_get_family (font), height);
+  if (renderer->hFont) {
+    W32::DeleteObject (renderer->hFont);
+    renderer->hFont = NULL;
+  }
+  if (renderer->pango_context) {
+    g_object_unref (renderer->pango_context);
+    renderer->pango_context = NULL;
+  }
 
-    if (renderer->use_pango) {
+  if (renderer->use_pango) {
 #ifdef __PANGOWIN32_H__ /* with the pangowin32 backend there is a better way */
        if (!renderer->pango_context)
            renderer->pango_context = pango_win32_get_context ();
@@ -562,44 +576,44 @@ set_font(DiaRenderer *self, DiaFont *font, real height)
            g_free (desc);
        }
 #else
-       g_assert_not_reached();
+    g_assert_not_reached();
 #endif
-    } else {
-       sFace = dia_font_get_family (font);
-       dwItalic = DIA_FONT_STYLE_GET_SLANT(style) != DIA_FONT_NORMAL;
-
-       /* although there is a known algorithm avoid it for cleanness */
-       switch (DIA_FONT_STYLE_GET_WEIGHT(style)) {
-       case DIA_FONT_ULTRALIGHT    : dwWeight = FW_ULTRALIGHT; break;
-       case DIA_FONT_LIGHT         : dwWeight = FW_LIGHT; break;
-       case DIA_FONT_MEDIUM        : dwWeight = FW_MEDIUM; break;
-       case DIA_FONT_DEMIBOLD      : dwWeight = FW_DEMIBOLD; break;
-       case DIA_FONT_BOLD          : dwWeight = FW_BOLD; break;
-       case DIA_FONT_ULTRABOLD     : dwWeight = FW_ULTRABOLD; break;
-       case DIA_FONT_HEAVY         : dwWeight = FW_HEAVY; break;
-       default : dwWeight = FW_NORMAL; break;
-       }
-       //Hack to get BYTE out of namespace W32
+  } else {
+    sFace = dia_font_get_family (font);
+    dwItalic = DIA_FONT_STYLE_GET_SLANT (style) != DIA_FONT_NORMAL;
+
+    /* although there is a known algorithm avoid it for cleanness */
+    switch (DIA_FONT_STYLE_GET_WEIGHT (style)) {
+      case DIA_FONT_ULTRALIGHT    : dwWeight = FW_ULTRALIGHT; break;
+      case DIA_FONT_LIGHT         : dwWeight = FW_LIGHT; break;
+      case DIA_FONT_MEDIUM        : dwWeight = FW_MEDIUM; break;
+      case DIA_FONT_DEMIBOLD      : dwWeight = FW_DEMIBOLD; break;
+      case DIA_FONT_BOLD          : dwWeight = FW_BOLD; break;
+      case DIA_FONT_ULTRABOLD     : dwWeight = FW_ULTRABOLD; break;
+      case DIA_FONT_HEAVY         : dwWeight = FW_HEAVY; break;
+      default : dwWeight = FW_NORMAL; break;
+    }
+    //Hack to get BYTE out of namespace W32
 #       ifndef BYTE
 #       define BYTE unsigned char
 #       endif
 
-       renderer->hFont = (W32::HFONT)W32::CreateFont(
-               - SC (font_size),  // logical height of font
-               0,              // logical average character width
-               0,              // angle of escapement
-               0,              // base-line orientation angle
-               dwWeight,       // font weight
-               dwItalic,       // italic attribute flag
-               0,              // underline attribute flag
-               0,              // strikeout attribute flag
-               DEFAULT_CHARSET,        // character set identifier
-               OUT_TT_PRECIS,  // output precision
-               CLIP_DEFAULT_PRECIS,    // clipping precision
-               PROOF_QUALITY,          // output quality
-               DEFAULT_PITCH,          // pitch and family
-               sFace);         // pointer to typeface name string
-    }
+  renderer->hFont = (W32::HFONT) W32::CreateFont (
+        - SC (font_size),     // logical height of font
+        0,                    // logical average character width
+        0,                    // angle of escapement
+        0,                    // base-line orientation angle
+        dwWeight,             // font weight
+        dwItalic,             // italic attribute flag
+        0,                    // underline attribute flag
+        0,                    // strikeout attribute flag
+        DEFAULT_CHARSET,      // character set identifier
+        OUT_TT_PRECIS,        // output precision
+        CLIP_DEFAULT_PRECIS,  // clipping precision
+        PROOF_QUALITY,        // output quality
+        DEFAULT_PITCH,        // pitch and family
+        sFace);               // pointer to typeface name string
+  }
 }
 
 static void
@@ -1232,11 +1246,59 @@ wmf_renderer_get_type (void)
   return object_type;
 }
 
+static void
+wmf_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  WmfRenderer *self = WMF_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+wmf_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  WmfRenderer *self = WMF_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 wmf_renderer_finalize (GObject *object)
 {
   WmfRenderer *renderer = WMF_RENDERER (object);
 
+  g_clear_object (&renderer->font);
+
   if (renderer->hFont)
     W32::DeleteObject(renderer->hFont);
   if (renderer->pango_context)
@@ -1253,6 +1315,8 @@ wmf_renderer_class_init (WmfRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = wmf_renderer_set_property;
+  object_class->get_property = wmf_renderer_get_property;
   object_class->finalize = wmf_renderer_finalize;
 
   /* renderer members */
@@ -1268,8 +1332,6 @@ wmf_renderer_class_init (WmfRendererClass *klass)
   renderer_class->set_linestyle  = set_linestyle;
   renderer_class->set_fillstyle  = set_fillstyle;
 
-  renderer_class->set_font  = set_font;
-
   renderer_class->draw_line    = draw_line;
   renderer_class->draw_polygon = draw_polygon;
   renderer_class->draw_arc     = draw_arc;
@@ -1295,6 +1357,9 @@ wmf_renderer_class_init (WmfRendererClass *klass)
 #endif
   /* other */
   renderer_class->is_capable_to = is_capable_to;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 #ifdef G_OS_WIN32
diff --git a/plug-ins/wpg/wpg-import.c b/plug-ins/wpg/wpg-import.c
index 2e5b4ec3..510829e1 100644
--- a/plug-ins/wpg/wpg-import.c
+++ b/plug-ins/wpg/wpg-import.c
@@ -72,12 +72,12 @@ G_DEFINE_TYPE(WpgImportRenderer, wpg_import_renderer, DIA_TYPE_IMPORT_RENDERER);
 #define WPG_TYPE_IMPORT_RENDERER (wpg_import_renderer_get_type ())
 #define WPG_IMPORT_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WPG_TYPE_IMPORT_RENDERER, 
WpgImportRenderer))
 
-static void 
+static void
 wpg_import_renderer_class_init (WpgImportRendererClass *klass)
 {
   /* anything to initialize? */
 }
-static void 
+static void
 wpg_import_renderer_init (WpgImportRenderer *self)
 {
   /* anything to initialize? */
@@ -124,30 +124,35 @@ _do_ellipse (WpgImportRenderer *ren, WPGEllipse* pEll)
   Point center;
   center.x = pEll->x / WPU_PER_DCM;
   center.y = (h - pEll->y) / WPU_PER_DCM;
-  
+
   if (fabs(pEll->EndAngle - pEll->StartAngle) < 360) {
     /* WPG arcs are counter-clockwise so ensure that end is bigger than start */
     real arcEnd = pEll->EndAngle;
     if (arcEnd < pEll->StartAngle)
       arcEnd += 360;
     if (ren->LineAttr.Type != WPG_LA_NONE)
-      DIA_RENDERER_GET_CLASS(ren)->draw_arc (DIA_RENDERER(ren), &center,
-                                            2 * pEll->rx / WPU_PER_DCM,
-                                            2 * pEll->ry / WPU_PER_DCM,
-                                            pEll->StartAngle, arcEnd,
-                                            &ren->stroke);
+      dia_renderer_draw_arc (DIA_RENDERER (ren),
+                             &center,
+                             2 * pEll->rx / WPU_PER_DCM,
+                             2 * pEll->ry / WPU_PER_DCM,
+                             pEll->StartAngle,
+                             arcEnd,
+                             &ren->stroke);
     if (ren->FillAttr.Type != WPG_FA_HOLLOW)
-      DIA_RENDERER_GET_CLASS(ren)->fill_arc (DIA_RENDERER(ren), &center,
-                                            2 * pEll->rx / WPU_PER_DCM,
-                                            2 * pEll->ry / WPU_PER_DCM,
-                                            pEll->StartAngle, arcEnd,
-                                            &ren->fill);
+      dia_renderer_fill_arc (DIA_RENDERER (ren),
+                             &center,
+                             2 * pEll->rx / WPU_PER_DCM,
+                             2 * pEll->ry / WPU_PER_DCM,
+                             pEll->StartAngle,
+                             arcEnd,
+                             &ren->fill);
   } else {
-    DIA_RENDERER_GET_CLASS(ren)->draw_ellipse (DIA_RENDERER(ren), &center,
-                                                2 * pEll->rx / WPU_PER_DCM,
-                                                2 * pEll->ry / WPU_PER_DCM,
-                                                (ren->FillAttr.Type != WPG_FA_HOLLOW) ? &ren->fill : NULL,
-                                                (ren->LineAttr.Type != WPG_LA_NONE) ? &ren->stroke : NULL);
+    dia_renderer_draw_ellipse (DIA_RENDERER (ren),
+                               &center,
+                               2 * pEll->rx / WPU_PER_DCM,
+                               2 * pEll->ry / WPU_PER_DCM,
+                               (ren->FillAttr.Type != WPG_FA_HOLLOW) ? &ren->fill : NULL,
+                               (ren->LineAttr.Type != WPG_LA_NONE) ? &ren->stroke : NULL);
   }
 }
 
@@ -157,19 +162,25 @@ _do_polygon (WpgImportRenderer *ren, Point *points, int iNum)
   g_return_if_fail (iNum > 2);
   if (ren->LineAttr.Type == WPG_LA_NONE && ren->FillAttr.Type == WPG_FA_HOLLOW)
     return; /* nothing to do */
-  DIA_RENDERER_GET_CLASS(ren)->draw_polygon (DIA_RENDERER(ren), points, iNum,
-                                            (ren->FillAttr.Type != WPG_FA_HOLLOW) ? &ren->fill : NULL,
-                                            (ren->LineAttr.Type != WPG_LA_NONE) ? &ren->stroke : NULL);
+  dia_renderer_draw_polygon (DIA_RENDERER (ren),
+                             points,
+                             iNum,
+                             (ren->FillAttr.Type != WPG_FA_HOLLOW) ? &ren->fill : NULL,
+                             (ren->LineAttr.Type != WPG_LA_NONE) ? &ren->stroke : NULL);
 }
+
 static void
 _do_rect (WpgImportRenderer *ren, Point *points)
 {
-  if (ren->LineAttr.Type != WPG_LA_NONE || ren->FillAttr.Type != WPG_FA_HOLLOW)
-    DIA_RENDERER_GET_CLASS(ren)->draw_rect (DIA_RENDERER(ren),
-                                           &points[0], &points[1],
-                                           (ren->FillAttr.Type != WPG_FA_HOLLOW) ? &ren->fill : NULL,
-                                           (ren->LineAttr.Type != WPG_LA_NONE) ? &ren->stroke : NULL);
+  if (ren->LineAttr.Type != WPG_LA_NONE || ren->FillAttr.Type != WPG_FA_HOLLOW) {
+    dia_renderer_draw_rect (DIA_RENDERER (ren),
+                            &points[0],
+                            &points[1],
+                            (ren->FillAttr.Type != WPG_FA_HOLLOW) ? &ren->fill : NULL,
+                            (ren->LineAttr.Type != WPG_LA_NONE) ? &ren->stroke : NULL);
+  }
 }
+
 static void
 _do_bezier (WpgImportRenderer *ren, WPGPoint *pts, int iNum)
 {
@@ -198,12 +209,19 @@ _do_bezier (WpgImportRenderer *ren, WPGPoint *pts, int iNum)
     bps[i].p3.y = (ofs - (gint16)pts[i*3  ].y) / WPU_PER_DCM;
   }
   /* XXX: should we fold this calls into one? What's closing a WPG PolyCurve? */
-  if (ren->LineAttr.Type != WPG_LA_NONE)
-    DIA_RENDERER_GET_CLASS(ren)->draw_bezier (DIA_RENDERER(ren),
-                                             bps, num_points, &ren->stroke);
-  if (ren->FillAttr.Type != WPG_FA_HOLLOW)
-    DIA_RENDERER_GET_CLASS(ren)->draw_beziergon (DIA_RENDERER(ren),
-                                                bps, num_points, &ren->fill, NULL);
+  if (ren->LineAttr.Type != WPG_LA_NONE) {
+    dia_renderer_draw_bezier (DIA_RENDERER (ren),
+                              bps,
+                              num_points,
+                              &ren->stroke);
+  }
+  if (ren->FillAttr.Type != WPG_FA_HOLLOW) {
+    dia_renderer_draw_beziergon (DIA_RENDERER (ren),
+                                 bps,
+                                 num_points,
+                                 &ren->fill,
+                                 NULL);
+  }
 }
 
 /*
@@ -225,14 +243,14 @@ import_object(DiaRenderer* self, DiagramData *dia,
     iNum = 2;
     pts = (WPGPoint*)pData;
     points = _make_points (renderer, pts, iNum);
-    DIA_RENDERER_GET_CLASS(renderer)->draw_line (self, &points[0], &points[1], &renderer->stroke);
+    dia_renderer_draw_line (self, &points[0], &points[1], &renderer->stroke);
     break;
   case WPG_POLYLINE:
     pInt16 = (gint16*)pData;
     iNum = pInt16[0];
     pts = (WPGPoint*)(pData + sizeof(gint16));
     points = _make_points (renderer, pts, iNum);
-    DIA_RENDERER_GET_CLASS(renderer)->draw_polyline (self, points, iNum, &renderer->stroke);
+    dia_renderer_draw_polyline (self, points, iNum, &renderer->stroke);
     break;
   case WPG_RECTANGLE:
     points = _make_rect (renderer, (WPGPoint*)pData);
@@ -288,7 +306,7 @@ import_object(DiaRenderer* self, DiagramData *dia,
   } /* switch */
   g_free (points);
   DIAG_NOTE(g_message("Type %d Num pts %d Size %d", type, iNum, iSize));
-} 
+}
 
 static void
 _make_stroke (WpgImportRenderer *ren)
@@ -303,27 +321,27 @@ _make_stroke (WpgImportRenderer *ren)
   ren->stroke.alpha = 1.0;
   switch (ren->LineAttr.Type) {
   case WPG_LA_SOLID:
-    DIA_RENDERER_GET_CLASS(ren)->set_linestyle (DIA_RENDERER(ren), LINESTYLE_SOLID, 0.0);
+    dia_renderer_set_linestyle (DIA_RENDERER (ren), LINESTYLE_SOLID, 0.0);
     break;
   case WPG_LA_MEDIUMDASH:
-    DIA_RENDERER_GET_CLASS(ren)->set_linestyle (DIA_RENDERER(ren), LINESTYLE_DASHED, 0.66);
+    dia_renderer_set_linestyle (DIA_RENDERER (ren), LINESTYLE_DASHED, 0.66);
     break;
   case WPG_LA_SHORTDASH:
-    DIA_RENDERER_GET_CLASS(ren)->set_linestyle (DIA_RENDERER(ren), LINESTYLE_DASHED, 0.33);
+    dia_renderer_set_linestyle (DIA_RENDERER (ren), LINESTYLE_DASHED, 0.33);
     break;
   case WPG_LA_DASHDOT:
-    DIA_RENDERER_GET_CLASS(ren)->set_linestyle (DIA_RENDERER(ren), LINESTYLE_DASH_DOT, 1.0);
+    dia_renderer_set_linestyle (DIA_RENDERER (ren), LINESTYLE_DASH_DOT, 1.0);
     break;
   case WPG_LA_DASHDOTDOT:
-    DIA_RENDERER_GET_CLASS(ren)->set_linestyle (DIA_RENDERER(ren), LINESTYLE_DASH_DOT_DOT, 1.0);
+    dia_renderer_set_linestyle (DIA_RENDERER (ren), LINESTYLE_DASH_DOT_DOT, 1.0);
     break;
   case WPG_LA_DOTS:
-    DIA_RENDERER_GET_CLASS(ren)->set_linestyle (DIA_RENDERER(ren), LINESTYLE_DOTTED, 1.0);
+    dia_renderer_set_linestyle (DIA_RENDERER (ren), LINESTYLE_DOTTED, 1.0);
     break;
   }
 
-  DIA_RENDERER_GET_CLASS(ren)->set_linewidth (DIA_RENDERER(ren),
-                                             ren->LineAttr.Width / WPU_PER_DCM);
+  dia_renderer_set_linewidth (DIA_RENDERER (ren),
+                              ren->LineAttr.Width / WPU_PER_DCM);
 }
 
 static void
@@ -390,15 +408,19 @@ _render_bmp (WpgImportRenderer *ren, WPGBitmap2 *bmp, FILE *f, int len)
       len--;
     }
     image = dia_image_new_from_pixbuf (pixbuf);
-    if (bmp->Right - bmp->Left == 0 || bmp->Bottom - bmp->Top == 0)
-      DIA_RENDERER_GET_CLASS(ren)->draw_image (DIA_RENDERER(ren), &pt,
-                                              bmp->Xdpi / 2.54, bmp->Ydpi / 2.54,
-                                              image);
-    else /* real WPGBitmap2 */
-      DIA_RENDERER_GET_CLASS(ren)->draw_image (DIA_RENDERER(ren), &pt,
-                                              (bmp->Right - bmp->Left) / WPU_PER_DCM,
-                                              (bmp->Bottom - bmp->Top) / WPU_PER_DCM,
-                                              image);
+    if (bmp->Right - bmp->Left == 0 || bmp->Bottom - bmp->Top == 0) {
+      dia_renderer_draw_image (DIA_RENDERER (ren),
+                               &pt,
+                               bmp->Xdpi / 2.54,
+                               bmp->Ydpi / 2.54,
+                               image);
+    } else { /* real WPGBitmap2 */
+      dia_renderer_draw_image (DIA_RENDERER (ren),
+                               &pt,
+                               (bmp->Right - bmp->Left) / WPU_PER_DCM,
+                               (bmp->Bottom - bmp->Top) / WPU_PER_DCM,
+                               image);
+    }
     g_object_unref (pixbuf);
     g_object_unref (image);
     return bRet;
@@ -438,7 +460,7 @@ _do_textstyle (WpgImportRenderer *ren, WPGTextStyle *ts)
   else /* any is not advices */
     font = dia_font_new_from_style (DIA_FONT_SANS, height);
 
-  DIA_RENDERER_GET_CLASS(ren)->set_font (DIA_RENDERER(ren), font, height);
+  dia_renderer_set_font (DIA_RENDERER (ren), font, height);
 
   dia_font_unref (font);
 }
@@ -450,8 +472,11 @@ _render_text (WpgImportRenderer *ren, WPGPoint *pos, gchar *text)
   pt.x = pos->x / WPU_PER_DCM;
   pt.y = (ren->Box.Height - pos->y ) / WPU_PER_DCM;
 
-  DIA_RENDERER_GET_CLASS(ren)->draw_string (DIA_RENDERER(ren), text, &pt,
-                                           ren->text_align, &ren->text_color);
+  dia_renderer_draw_string (DIA_RENDERER (ren),
+                            text,
+                            &pt,
+                            ren->text_align,
+                            &ren->text_color);
 }
 
 gboolean
@@ -467,7 +492,7 @@ import_data (const gchar *filename, DiagramData *dia, DiaContext *ctx, void* use
     dia_context_add_message(ctx, _("Couldn't open: '%s' for reading.\n"), filename);
     bRet = FALSE;
   }
-  
+
   /* check header */
   if (bRet) {
     WPGFileHead fhead;
@@ -498,9 +523,9 @@ import_data (const gchar *filename, DiagramData *dia, DiaContext *ctx, void* use
           if (0x8000 & i16) {
             DIAG_NOTE(g_print("Large Object: hi:lo %04X", (int)i16));
             iSize = (0x7FFF & i16) << 16;
-            /* Reading large objects involves major uglyness. Instead of getting 
+            /* Reading large objects involves major uglyness. Instead of getting
              * one size, as implied by "Encyclopedia of Graphics File Formats",
-             * it would require putting together small chunks of data to one large 
+             * it would require putting together small chunks of data to one large
              * object. The criteria when to stop isn't absolutely clear.
              */
             bRet = (1 == fread(&i16, sizeof(guint16), 1, f));
@@ -513,7 +538,7 @@ import_data (const gchar *filename, DiagramData *dia, DiaContext *ctx, void* use
 #endif
           }
           else
-            iSize = i16; 
+            iSize = i16;
         }
       } else
         iSize = 0;
@@ -536,7 +561,7 @@ import_data (const gchar *filename, DiagramData *dia, DiaContext *ctx, void* use
           /* not sure if this is the right thing to do */
           bRet &= (1 == fread(&i8, sizeof(gint8), 1, f));
           bRet &= (1 == fread(&i16, sizeof(gint16), 1, f));
-          DIAG_NOTE(g_message("Ignoring tag WPG_STARTWPG2, Size %d\n Type? %d Size? %d", 
+          DIAG_NOTE(g_message("Ignoring tag WPG_STARTWPG2, Size %d\n Type? %d Size? %d",
                     iSize, (int)i8, i16));
           fseek(f, iSize - 3, SEEK_CUR);
           break;
@@ -634,7 +659,7 @@ import_data (const gchar *filename, DiagramData *dia, DiaContext *ctx, void* use
     if (!bRet)
       dia_context_add_message (ctx, _("Unexpected end of file. WPG type %d, size %d.\n"),
                               rh.Type, iSize);
-    if (ren->pPal) 
+    if (ren->pPal)
       g_free(ren->pPal);
     /* transfer to diagram data */
     {
diff --git a/plug-ins/wpg/wpg.c b/plug-ins/wpg/wpg.c
index 47ef0b5b..326e489a 100644
--- a/plug-ins/wpg/wpg.c
+++ b/plug-ins/wpg/wpg.c
@@ -22,7 +22,7 @@
 /*
  * ToDo:
  * - if helper points - like arc centers - are not in Dia's extent box
- *   their clipping produces unpredictable results 
+ *   their clipping produces unpredictable results
  * - the font setting needs improvement (maybe on Dia's side)
  */
 
@@ -72,6 +72,15 @@ G_BEGIN_DECLS
 #define WPG_IS_RENDERER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WPG_TYPE_RENDERER))
 #define WPG_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), WPG_TYPE_RENDERER, WpgRendererClass))
 
+
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 GType wpg_renderer_get_type (void) G_GNUC_CONST;
 
 typedef struct _WpgRenderer WpgRenderer;
@@ -93,6 +102,9 @@ struct _WpgRenderer
 
 
   DiaContext* ctx;
+
+  DiaFont *font;
+  double font_height;
 };
 
 struct _WpgRendererClass
@@ -141,7 +153,7 @@ fwrite_le(void* buf, size_t size, size_t count, FILE* f)
 }
 #endif
 
-/* 
+/*
  * color cube len, WPG is limited to 256 colors. To get simple
  * color reduction algorithms only 216 = 6^3 of them are used.
  */
@@ -149,7 +161,7 @@ fwrite_le(void* buf, size_t size, size_t count, FILE* f)
 
 /*
  * "To avoid problems with WPC products the first 16 colors of
- *  the color map should never be changed". 
+ *  the color map should never be changed".
  * Define WPG_NUM_DEF_COLORS to 0 ignore this statement (It
  * appears to work more reliable; tested with WinWord 97 and
  * Designer 4.1 - the latter does not respect the color maps
@@ -157,14 +169,14 @@ fwrite_le(void* buf, size_t size, size_t count, FILE* f)
  */
 #define WPG_NUM_DEF_COLORS 0 /* 16 */
 
-/* 
- * helper functions 
+/*
+ * helper functions
  */
 static guint8
 LookupColor(WpgRenderer *renderer, Color* colour)
 {
   /* find nearest color in the renderers color map */
-  /* the following hack does only work with a correctly 
+  /* the following hack does only work with a correctly
      sorted color map */
   unsigned long i = (int)floor(colour->red * (CC_LEN - 1))
                   + (int)floor(colour->green * (CC_LEN - 1)) * CC_LEN
@@ -172,7 +184,7 @@ LookupColor(WpgRenderer *renderer, Color* colour)
   DIAG_NOTE(g_message("LookupColor %d.", i));
   if (i >= CC_LEN * CC_LEN * CC_LEN)
     return CC_LEN * CC_LEN * CC_LEN - 1 + WPG_NUM_DEF_COLORS;
-  else 
+  else
     return i + WPG_NUM_DEF_COLORS;
 }
 
@@ -250,21 +262,21 @@ WriteFillAttr(WpgRenderer *renderer, Color* colour, gboolean bFill)
   }
 }
 
-/* 
- * render functions 
- */ 
+/*
+ * render functions
+ */
 static void
 begin_render(DiaRenderer *self, const Rectangle *update)
 {
   WpgRenderer *renderer = WPG_RENDERER (self);
 #if 0
-  const WPGFileHead wpgFileHead = { "\377WPC", 16, 
+  const WPGFileHead wpgFileHead = { "\377WPC", 16,
                                    1, 22,
-                                   1, 0, /* Version */ 
+                                   1, 0, /* Version */
                                    0, 0};
 #else
   /* static conversion to little endian */
-  const char wpgFileHead[16] = {255, 'W', 'P', 'C', 16, 0, 0, 0, 
+  const char wpgFileHead[16] = {255, 'W', 'P', 'C', 16, 0, 0, 0,
                                 1, 22, 1, 0, 0, 0, 0, 0};
 #endif
 
@@ -295,7 +307,7 @@ begin_render(DiaRenderer *self, const Rectangle *update)
     /*
     g_print("%d\t%d\t%d\n", pPal[3*i  ], pPal[3*i+1], pPal[3*i+2]);
      */
-  } 
+  }
 
   WriteRecHead(renderer, WPG_COLORMAP, CC_LEN*CC_LEN*CC_LEN*3 + 2*sizeof(guint16));
   i = WPG_NUM_DEF_COLORS; /* start color */
@@ -326,7 +338,7 @@ end_render(DiaRenderer *self)
 
 static void
 set_linewidth(DiaRenderer *self, real linewidth)
-{  
+{
   WpgRenderer *renderer = WPG_RENDERER (self);
 
   DIAG_NOTE(g_message("set_linewidth %f", linewidth));
@@ -425,13 +437,13 @@ set_font(DiaRenderer *self, DiaFont *font, real height)
   WpgRenderer *renderer = WPG_RENDERER (self);
 
   /* FIXME PANGO: this is a little broken. Use better matching. */
-    
+
   const char *family_name;
   DIAG_NOTE(g_message("set_font %f %s", height, font->name));
   renderer->TextStyle.Height = SC(height);
 
   family_name = dia_font_get_family(font);
-  
+
   if ((strstr(family_name, "courier")) || (strstr(family_name, "monospace")))
     renderer->TextStyle.Font = 0x0DF0;
   else if ((strstr(family_name, "times")) || (strstr(family_name, "serif")))
@@ -442,20 +454,20 @@ set_font(DiaRenderer *self, DiaFont *font, real height)
 }
 
 /* Need to translate coord system:
- * 
+ *
  *   Dia x,y -> Wpg x,-y
  *
  * doing it before scaling.
  */
 static void
-draw_line(DiaRenderer *self, 
-          Point *start, Point *end, 
+draw_line(DiaRenderer *self,
+          Point *start, Point *end,
           Color *line_colour)
 {
   WpgRenderer *renderer = WPG_RENDERER (self);
   gint16 pData[4];
 
-  DIAG_NOTE(g_message("draw_line %f,%f -> %f, %f", 
+  DIAG_NOTE(g_message("draw_line %f,%f -> %f, %f",
             start->x, start->y, end->x, end->y));
 
   WriteLineAttr(renderer, line_colour);
@@ -471,15 +483,15 @@ draw_line(DiaRenderer *self,
 }
 
 static void
-draw_polyline(DiaRenderer *self, 
-              Point *points, int num_points, 
+draw_polyline(DiaRenderer *self,
+              Point *points, int num_points,
               Color *line_colour)
 {
   WpgRenderer *renderer = WPG_RENDERER (self);
   int i;
   gint16* pData;
 
-  DIAG_NOTE(g_message("draw_polyline n:%d %f,%f ...", 
+  DIAG_NOTE(g_message("draw_polyline n:%d %f,%f ...",
             num_points, points->x, points->y));
 
   g_return_if_fail(1 < num_points);
@@ -506,8 +518,8 @@ draw_polyline(DiaRenderer *self,
 }
 
 static void
-draw_polygon(DiaRenderer *self, 
-             Point *points, int num_points, 
+draw_polygon(DiaRenderer *self,
+             Point *points, int num_points,
              Color *fill, Color *stroke)
 {
   WpgRenderer *renderer = WPG_RENDERER (self);
@@ -515,7 +527,7 @@ draw_polygon(DiaRenderer *self,
   int i;
   WPG_LineAttr lt = renderer->LineAttr.Type;
 
-  DIAG_NOTE(g_message("draw_polygon n:%d %f,%f ...", 
+  DIAG_NOTE(g_message("draw_polygon n:%d %f,%f ...",
             num_points, points->x, points->y));
 
   if (!stroke)
@@ -551,7 +563,7 @@ draw_polygon(DiaRenderer *self,
 }
 
 static void
-draw_rect(DiaRenderer *self, 
+draw_rect(DiaRenderer *self,
           Point *ul_corner, Point *lr_corner,
           Color *fill, Color *stroke)
 {
@@ -559,7 +571,7 @@ draw_rect(DiaRenderer *self,
   gint16* pData;
   WPG_LineAttr lt = renderer->LineAttr.Type;
 
-  DIAG_NOTE(g_message("draw_rect %f,%f -> %f,%f", 
+  DIAG_NOTE(g_message("draw_rect %f,%f -> %f,%f",
             ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y));
 
   g_return_if_fail (fill || stroke);
@@ -588,7 +600,7 @@ draw_rect(DiaRenderer *self,
 }
 
 static void
-draw_arc(DiaRenderer *self, 
+draw_arc(DiaRenderer *self,
         Point *center,
         real width, real height,
         real angle1, real angle2,
@@ -598,7 +610,7 @@ draw_arc(DiaRenderer *self,
   WPGEllipse ell;
   gboolean counter_clockwise = angle2 > angle1;
 
-  DIAG_NOTE(g_message("draw_arc %fx%f <%f,<%f", 
+  DIAG_NOTE(g_message("draw_arc %fx%f <%f,<%f",
             width, height, angle1, angle2));
 
   ell.x = SCX(center->x);
@@ -628,7 +640,7 @@ draw_arc(DiaRenderer *self,
 }
 
 static void
-fill_arc(DiaRenderer *self, 
+fill_arc(DiaRenderer *self,
          Point *center,
          real width, real height,
          real angle1, real angle2,
@@ -638,7 +650,7 @@ fill_arc(DiaRenderer *self,
   WPGEllipse ell;
   gboolean counter_clockwise = angle2 > angle1;
 
-  DIAG_NOTE(g_message("fill_arc %fx%f <%f,<%f", 
+  DIAG_NOTE(g_message("fill_arc %fx%f <%f,<%f",
             width, height, angle1, angle2));
 
   ell.x = SCX(center->x);
@@ -669,7 +681,7 @@ fill_arc(DiaRenderer *self,
 }
 
 static void
-draw_ellipse(DiaRenderer *self, 
+draw_ellipse(DiaRenderer *self,
              Point *center,
              real width, real height,
              Color *fill, Color *stroke)
@@ -677,7 +689,7 @@ draw_ellipse(DiaRenderer *self,
   WpgRenderer *renderer = WPG_RENDERER (self);
   WPGEllipse ell;
 
-  DIAG_NOTE(g_message("draw_ellipse %fx%f center @ %f,%f", 
+  DIAG_NOTE(g_message("draw_ellipse %fx%f center @ %f,%f",
             width, height, center->x, center->y));
 
   ell.x = SCX(center->x);
@@ -703,7 +715,7 @@ draw_ellipse(DiaRenderer *self,
 }
 
 static void
-draw_bezier(DiaRenderer *self, 
+draw_bezier(DiaRenderer *self,
             BezPoint *points,
             int numpoints,
             Color *colour)
@@ -713,7 +725,7 @@ draw_bezier(DiaRenderer *self,
   guint16 data[2];
   int i;
 
-  DIAG_NOTE(g_message("draw_bezier n:%d %fx%f ...", 
+  DIAG_NOTE(g_message("draw_bezier n:%d %fx%f ...",
             numpoints, points->p1.x, points->p1.y));
 
   WriteLineAttr(renderer, colour);
@@ -766,7 +778,7 @@ draw_bezier(DiaRenderer *self,
 static gpointer parent_class = NULL;
 
 static void
-draw_beziergon (DiaRenderer *self, 
+draw_beziergon (DiaRenderer *self,
                BezPoint *points,
                int numpoints,
                Color *fill,
@@ -805,7 +817,7 @@ draw_string(DiaRenderer *self,
 
   len = strlen(text);
 
-  DIAG_NOTE(g_message("draw_string(%d) %f,%f %s", 
+  DIAG_NOTE(g_message("draw_string(%d) %f,%f %s",
             len, pos->x, pos->y, text));
 
   if (len < 1) return; /* shouldn't this be handled by Dia's core ? */
@@ -880,7 +892,7 @@ draw_image(DiaRenderer *self,
   bmp.Xdpi = 72; /* ??? */
   bmp.Ydpi = 72;
 
-  DIAG_NOTE(g_message("draw_image %fx%f [%d,%d] @%f,%f", 
+  DIAG_NOTE(g_message("draw_image %fx%f [%d,%d] @%f,%f",
             width, height, bmp.Width, bmp.Height, point->x, point->y));
 
   pDiaImg = dia_image_rgb_data(image);
@@ -909,7 +921,7 @@ draw_image(DiaRenderer *self,
 
       if (cnt > 0)
       {
-        if ((b == b_1) && (cnt < 127)) 
+        if ((b == b_1) && (cnt < 127))
           cnt++; /* increase counter*/
         else
         {
@@ -928,7 +940,7 @@ draw_image(DiaRenderer *self,
     *p++ = (cnt | 0x80); /* write last value(s) */
     *p++ = b;
   }
-  DIAG_NOTE(g_message( "Width x Height: %d RLE: %d", 
+  DIAG_NOTE(g_message( "Width x Height: %d RLE: %d",
              bmp.Width * bmp.Height, p - pOut));
 
   if ((p - pOut) > 32767) {
@@ -953,7 +965,7 @@ draw_image(DiaRenderer *self,
     j = p - pOut;
     for (i = 0; i < j; i+=2)
     {
-      for (x = 0; x < (pOut[i] & 0x7F); x++) 
+      for (x = 0; x < (pOut[i] & 0x7F); x++)
         fwrite(&pOut[i+1], 1, 1, f);
     }
     fclose(f);
@@ -990,15 +1002,63 @@ wpg_renderer_get_type (void)
                                             "WpgRenderer",
                                             &object_info, 0);
     }
-  
+
   return object_type;
 }
 
+static void
+wpg_renderer_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  WpgRenderer *self = WPG_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->font_height);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+wpg_renderer_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  WpgRenderer *self = WPG_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->font_height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 wpg_renderer_finalize (GObject *object)
 {
   WpgRenderer *wpg_renderer = WPG_RENDERER (object);
 
+  g_clear_object (&wpg_renderer->font);
+
   if (wpg_renderer->file)
     fclose(wpg_renderer->file);
   wpg_renderer->file = NULL;
@@ -1014,6 +1074,8 @@ wpg_renderer_class_init (WpgRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = wpg_renderer_set_property;
+  object_class->get_property = wpg_renderer_get_property;
   object_class->finalize = wpg_renderer_finalize;
 
   /* renderer members */
@@ -1026,8 +1088,6 @@ wpg_renderer_class_init (WpgRendererClass *klass)
   renderer_class->set_linestyle  = set_linestyle;
   renderer_class->set_fillstyle  = set_fillstyle;
 
-  renderer_class->set_font  = set_font;
-
   renderer_class->draw_line    = draw_line;
   renderer_class->draw_polygon = draw_polygon;
   renderer_class->draw_arc     = draw_arc;
@@ -1043,6 +1103,9 @@ wpg_renderer_class_init (WpgRendererClass *klass)
 
   renderer_class->draw_bezier   = draw_bezier;
   renderer_class->draw_beziergon = draw_beziergon;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 /* dia export funtion */
@@ -1059,7 +1122,7 @@ export_data(DiagramData *data, DiaContext *ctx,
   file = g_fopen(filename, "wb"); /* "wb" for binary! */
 
   if (file == NULL) {
-    dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"), 
+    dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"),
                                        dia_context_get_filename(ctx));
     return FALSE;
   }
@@ -1072,7 +1135,7 @@ export_data(DiagramData *data, DiaContext *ctx,
   extent = &data->extents;
 
   /* use extents */
-  DIAG_NOTE(g_message("export_data extents %f,%f -> %f,%f", 
+  DIAG_NOTE(g_message("export_data extents %f,%f -> %f,%f",
             extent->left, extent->top, extent->right, extent->bottom));
 
   width  = extent->right - extent->left;
diff --git a/plug-ins/xfig/xfig-export.c b/plug-ins/xfig/xfig-export.c
index 3e4607f2..ce693ac3 100644
--- a/plug-ins/xfig/xfig-export.c
+++ b/plug-ins/xfig/xfig-export.c
@@ -61,6 +61,15 @@
 #define xfig_dtostr(buf,d) \
        g_ascii_formatd(buf, sizeof(buf), "%f", d)
 
+
+enum {
+  PROP_0,
+  PROP_FONT,
+  PROP_FONT_HEIGHT,
+  LAST_PROP
+};
+
+
 GType xfig_renderer_get_type (void) G_GNUC_CONST;
 
 typedef struct _XfigRenderer XfigRenderer;
@@ -215,9 +224,59 @@ xfig_renderer_get_type (void)
   return object_type;
 }
 
+static void
+xfig_renderer_set_property (GObject      *object,
+                            guint         property_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+{
+  XfigRenderer *self = XFIG_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      set_font (DIA_RENDERER (self),
+                DIA_FONT (g_value_get_object (value)),
+                self->fontheight);
+      break;
+    case PROP_FONT_HEIGHT:
+      set_font (DIA_RENDERER (self),
+                self->font,
+                g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+xfig_renderer_get_property (GObject    *object,
+                            guint       property_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  XfigRenderer *self = XFIG_RENDERER (object);
+
+  switch (property_id) {
+    case PROP_FONT:
+      g_value_set_object (value, self->font);
+      break;
+    case PROP_FONT_HEIGHT:
+      g_value_set_double (value, self->fontheight);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
 static void
 xfig_renderer_finalize (GObject *object)
 {
+  XfigRenderer *self = XFIG_RENDERER (object);
+
+  g_clear_object (&self->font);
+
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
@@ -229,6 +288,8 @@ xfig_renderer_class_init (XfigRendererClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->set_property = xfig_renderer_set_property;
+  object_class->get_property = xfig_renderer_get_property;
   object_class->finalize = xfig_renderer_finalize;
 
   renderer_class->begin_render = begin_render;
@@ -239,7 +300,6 @@ xfig_renderer_class_init (XfigRendererClass *klass)
   renderer_class->set_linejoin = set_linejoin;
   renderer_class->set_linestyle = set_linestyle;
   renderer_class->set_fillstyle = set_fillstyle;
-  renderer_class->set_font = set_font;
 
   renderer_class->draw_line = draw_line;
   renderer_class->draw_polyline = draw_polyline;
@@ -264,6 +324,9 @@ xfig_renderer_class_init (XfigRendererClass *klass)
   renderer_class->draw_arc_with_arrows = draw_arc_with_arrows;
   renderer_class->draw_bezier_with_arrows = draw_bezier_with_arrows;
   renderer_class->draw_object = draw_object;
+
+  g_object_class_override_property (object_class, PROP_FONT, "font");
+  g_object_class_override_property (object_class, PROP_FONT_HEIGHT, "font-height");
 }
 
 /* Helper functions */
@@ -550,12 +613,14 @@ set_fillstyle(DiaRenderer *self, FillStyle mode)
 
   renderer->fillmode = mode;
 }
+
 static void
 set_font(DiaRenderer *self, DiaFont *font, real height)
 {
   XfigRenderer *renderer = XFIG_RENDERER(self);
 
-  renderer->font = font;
+  g_clear_object (&renderer->font);
+  renderer->font = g_object_ref (font);
   renderer->fontheight = height;
 }
 
@@ -1065,15 +1130,15 @@ draw_object(DiaRenderer *self,
 
   if (renderer->color_pass) {
     /* color pass does not need transformation */
-    object->ops->draw(object, DIA_RENDERER(renderer));
+    dia_object_draw (object, DIA_RENDERER (renderer));
   } else {
     fprintf(renderer->file, "6 0 0 0 0\n");
     if (matrix) {
       DiaRenderer *tr = dia_transform_renderer_new (self);
-      DIA_RENDERER_GET_CLASS(tr)->draw_object (tr, object, matrix);
+      dia_renderer_draw_object (tr, object, matrix);
       g_object_unref (tr);
     } else {
-      object->ops->draw(object, DIA_RENDERER(renderer));
+      dia_object_draw (object, DIA_RENDERER (renderer));
     }
     fprintf(renderer->file, "-6\n");
   }
@@ -1114,35 +1179,35 @@ export_fig(DiagramData *data, DiaContext *ctx,
 
   renderer->color_pass = TRUE;
 
-  DIA_RENDERER_GET_CLASS(renderer)->begin_render(DIA_RENDERER(renderer), NULL);
+  dia_renderer_begin_render (DIA_RENDERER (renderer), NULL);
 
-  for (i=0; i<data->layers->len; i++) {
-    layer = (Layer *) g_ptr_array_index(data->layers, i);
+  for (i = 0; i < data->layers->len; i++) {
+    layer = (Layer *) g_ptr_array_index (data->layers, i);
     if (layer->visible) {
-      layer_render(layer, DIA_RENDERER(renderer), NULL, NULL, data, 0);
+      layer_render (layer, DIA_RENDERER (renderer), NULL, NULL, data, 0);
       renderer->depth++;
     }
   }
 
-  DIA_RENDERER_GET_CLASS(renderer)->end_render(DIA_RENDERER(renderer));
+  dia_renderer_end_render (DIA_RENDERER (renderer));
 
   renderer->color_pass = FALSE;
 
-  DIA_RENDERER_GET_CLASS(renderer)->begin_render(DIA_RENDERER(renderer), NULL);
+  dia_renderer_begin_render (DIA_RENDERER (renderer), NULL);
 
   for (i=0; i<data->layers->len; i++) {
-    layer = (Layer *) g_ptr_array_index(data->layers, i);
+    layer = (Layer *) g_ptr_array_index (data->layers, i);
     if (layer->visible) {
-      layer_render(layer, DIA_RENDERER(renderer), NULL, NULL, data, 0);
+      layer_render (layer, DIA_RENDERER (renderer), NULL, NULL, data, 0);
       renderer->depth++;
     }
   }
 
-  DIA_RENDERER_GET_CLASS(renderer)->end_render(DIA_RENDERER(renderer));
+  dia_renderer_end_render (DIA_RENDERER (renderer));
 
-  g_object_unref(renderer);
+  g_object_unref (renderer);
 
-  fclose(file);
+  fclose (file);
 
   return TRUE;
 }



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]