提交: a45b01acbb81b3dbc162ba69a9290df6ed522992 - dia (git)

作図ソフト dia の改良版

Commit MetaInfo

• 修訂: a45b01acbb81b3dbc162ba69a9290df6ed522992 (tree)
• 時間: 2000-06-07 18:05:44
• 作者: James Henstridge <james@daa....>
• Commiter: James Henstridge

Log Message

set some table packing options to make it look a little nicer.

2000-06-07 James Henstridge <[e-mail]>

* app/plugin-manager.c (get_plugin_manager): set some table
packing options to make it look a little nicer.

* plug-ins/hpgl/Makefile.am, plug-ins/wpg/Makefile.am: added
makefiles for these plug-ins.

* plug-ins/{hpgl,wmf,wpg}/*: removed dos style cariage returns.

* configure.in: added hpgl and wpg directories to build. Added
note about whether gnome-print support was enabled, and noted that
it is not recommended.

Change Summary

• modified: ChangeLog
• modified: app/plugin-manager.c
• modified: configure.in
• modified: plug-ins/Makefile.am
• add: plug-ins/hpgl/.cvsignore
• add: plug-ins/hpgl/Makefile.am
• modified: plug-ins/hpgl/hpgl.c
• modified: plug-ins/renderer.inc
• add: plug-ins/wmf/.cvsignore
• modified: plug-ins/wmf/wmf.cpp
• add: plug-ins/wpg/.cvsignore
• add: plug-ins/wpg/Makefile.am
• modified: plug-ins/wpg/wpg.c
• modified: plug-ins/wpg/wpg_defs.h

差異

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
[phone]  James Henstridge  <[e-mail]>
+
+	* app/plugin-manager.c (get_plugin_manager): set some table
+	packing options to make it look a little nicer.
+
+	* plug-ins/hpgl/Makefile.am, plug-ins/wpg/Makefile.am: added
+	makefiles for these plug-ins.
+
+	* plug-ins/{hpgl,wmf,wpg}/*: removed dos style cariage returns.
+
+	* configure.in: added hpgl and wpg directories to build.  Added
+	note about whether gnome-print support was enabled, and noted that
+	it is not recommended.
+
 2000-06-06  James Henstridge  <[e-mail]>
 
 	* plug-ins/{hpgl,wmf,wpg}/*: Hans Breuer's plug-ins.  They still need

--- a/app/plugin-manager.c
+++ b/app/plugin-manager.c
@@ -187,7 +187,7 @@ get_plugin_manager(void)
   pm.name_label = gtk_label_new("");
   gtk_misc_set_alignment(GTK_MISC(pm.name_label), 0.0, 0.5);
   gtk_table_attach(GTK_TABLE(table), pm.name_label, 1,2, 0,1,
-		   GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+		   GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
   gtk_widget_show(pm.name_label);
 
   label = gtk_label_new(_("File name:"));
@@ -199,7 +199,7 @@ get_plugin_manager(void)
   pm.file_label = gtk_label_new("");
   gtk_misc_set_alignment(GTK_MISC(pm.file_label), 0.0, 0.5);
   gtk_table_attach(GTK_TABLE(table), pm.file_label, 1,2, 1,2,
-		   GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+		   GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
   gtk_widget_show(pm.file_label);
 
   label = gtk_label_new(_("Description:"));
@@ -213,7 +213,7 @@ get_plugin_manager(void)
   gtk_label_set_justify(GTK_LABEL(pm.description_label), GTK_JUSTIFY_LEFT);
   gtk_label_set_line_wrap(GTK_LABEL(pm.description_label), TRUE);
   gtk_table_attach(GTK_TABLE(table), pm.description_label, 1,2, 2,3,
-		   GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+		   GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
   gtk_widget_show(pm.description_label);
 
   label = gtk_label_new(_("Loaded:"));
@@ -225,7 +225,7 @@ get_plugin_manager(void)
   pm.loaded_label = gtk_label_new("");
   gtk_misc_set_alignment(GTK_MISC(pm.loaded_label), 0.0, 0.5);
   gtk_table_attach(GTK_TABLE(table), pm.loaded_label, 1,2, 3,4,
-		   GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+		   GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
   gtk_widget_show(pm.loaded_label);
 
   pm.autoload_cbutton = gtk_check_button_new_with_label(

--- a/configure.in
+++ b/configure.in
@@ -256,6 +256,8 @@ plug-ins/Makefile
 plug-ins/cgm/Makefile
 plug-ins/pstricks/Makefile
 plug-ins/dxf/Makefile
+plug-ins/hpgl/Makefile
+plug-ins/wpg/Makefile
 )
 
 echo "
@@ -269,5 +271,6 @@ Configuration:
 
 	Gnome support:				${GNOME}
 	Build bonobo component (not supported):	${enable_bonobo}
+        Gnome-print support (not recommended):  ${enable_gnome_print}
 
 Now type make to build dia."

--- a/plug-ins/Makefile.am
+++ b/plug-ins/Makefile.am
@@ -1 +1 @@
-SUBDIRS = cgm pstricks dxf
+SUBDIRS = cgm pstricks dxf hpgl wpg

--- /dev/null
+++ b/plug-ins/hpgl/.cvsignore
@@ -0,0 +1,9 @@
+.cvsignore
+.deps
+.libs
+Makefile
+Makefile.in
+*.lo
+*.la
+*.pyc
+

--- /dev/null
+++ b/plug-ins/hpgl/Makefile.am
@@ -0,0 +1,8 @@
+pkglib_LTLIBRARIES = libhpgl_filter.la
+
+libhpgl_filter_la_SOURCES = hpgl.c
+libhpgl_filter_la_LDFLAGS = -export-dynamic -module -avoid-version
+libhpgl_filter_la_LIBADD = $(GTK_LIBS)
+
+INCLUDES = -I$(top_srcdir)/intl -I$(top_srcdir)/lib \
+  $(GTK_CFLAGS) $(GNOME_CFLAGS)

--- a/plug-ins/hpgl/hpgl.c
+++ b/plug-ins/hpgl/hpgl.c
@@ -1,631 +1,631 @@
-/* Dia -- an diagram creation/manipulation program
- * Copyright (C) 1998 Alexander Larsson
- *
- * hpgl.c -- HPGL export plugin for dia
- * Copyright (C) 2000, Hans Breuer, <[e-mail]>
- *   based on dummy.c 
- *   based on CGM plug-in Copyright (C) 1999 James Henstridge. 
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-
-/*
- * ToDo:
- * - provide more rendering functions like "render_draw_ellipse_by_arc" 
- *   to be used by simple format renderers; move them to libdia?
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-#include <glib.h>
-
-#include "config.h"
-#include "intl.h"
-#include "message.h"
-#include "geometry.h"
-#include "render.h"
-#include "filter.h"
-#include "plug-ins.h"
-
-/* format specific */
-#define HPGL_MAX_PENS 8
-
-/* --- the renderer --- */
-#define MY_RENDERER_NAME "HPGL"
-
-#define PEN_HAS_COLOR (1 << 0) 
-#define PEN_HAS_WIDTH (1 << 1) 
-
-typedef struct _MyRenderer MyRenderer;
-struct _MyRenderer {
-    Renderer renderer;
-
-    FILE *file;
-
-    /*
-     * The number of pens is limited. This is used to select one.
-     */
-    struct {
-        Color color;
-        float width;
-        int   has_it;
-    } pen[HPGL_MAX_PENS];
-    int last_pen;
-    real dash_length;
-    real font_height;
-
-    Point size;  /* extent size */
-    real scale;
-    real offset; /* in dia units */
-};
-
-/* include function declares and render object "vtable" */
-#include "../renderer.inc"
-
-#define DIAG_NOTE /* my_log */
-void
-my_log(MyRenderer* renderer, char* format, ...)
-{
-    gchar *string;
-    va_list args;
-  
-    g_return_if_fail (format != NULL);
-  
-    va_start (args, format);
-    string = g_strdup_vprintf (format, args);
-    va_end (args);
-
-    g_print(string);
-
-    g_free(string);
-}
-
-/* hpgl helpers */
-void hpgl_select_pen(MyRenderer* renderer, Color* color, real width)
-{
-    int nPen = 0;
-    int i;
-    /* look if this pen is defined already */
-    if (0.0 != width) {
-        /* either width ... */
-        for (i = 0; i < HPGL_MAX_PENS; i++) {
-            if (!(renderer->pen[i].has_it & PEN_HAS_WIDTH)) {
-                nPen = i;
-                break;
-            }
-            if (width == renderer->pen[i].width) {
-                nPen = i;
-                break;
-            }
-        }
-    }
- 
-    if (NULL != color) {
-        for (i = nPen; i < HPGL_MAX_PENS; i++) {
-            if (!(renderer->pen[i].has_it & PEN_HAS_COLOR)) {
-                nPen = i;
-                break;
-            }
-            if (   (color->red == renderer->pen[i].color.red)
-                && (color->green == renderer->pen[i].color.green)
-                && (color->blue == renderer->pen[i].color.blue)) {
-                nPen = i;
-                break;
-            }
-        }
-    }
-    /* "create" new pen ... */
-    if ((nPen < HPGL_MAX_PENS) && (-1 < nPen)) {
-        if (0.0 != width) {
-            renderer->pen[nPen].width = width;
-            renderer->pen[nPen].has_it |= PEN_HAS_WIDTH;
-        }
-        if (NULL != color) {
-            renderer->pen[nPen].color = *color;
-            renderer->pen[nPen].has_it |= PEN_HAS_COLOR;
-        }
-    }
-    /* ... or use best fitting one */
-    else if (-1 == nPen) {
-        nPen = 0; /* TODO: */
-    }
-
-    if (renderer->last_pen != nPen)
-        fprintf(renderer->file, "SP%d;\n", nPen+1);
-    renderer->last_pen = nPen;
-}
-
-int
-hpgl_scale(MyRenderer *renderer, real val)
-{
-    return (int)((val + renderer->offset) * renderer->scale);
-}
-
-/* render functions */ 
-static void
-begin_render(MyRenderer *renderer, DiagramData *data)
-{
-    int i;
-
-    DIAG_NOTE(renderer, "begin_render\n");
-
-    /* initialize pens */
-    for (i = 0; i < HPGL_MAX_PENS; i++) {
-        renderer->pen[i].color = color_black;
-        renderer->pen[i].width = 0.0;
-        renderer->pen[i].has_it = 0;
-    }
-    renderer->last_pen = -1;
-    renderer->dash_length = 0.0;
-}
-
-static void
-end_render(MyRenderer *renderer)
-{
-    DIAG_NOTE(renderer, "end_render\n");
-    fclose(renderer->file);
-}
-
-static void
-set_linewidth(MyRenderer *renderer, real linewidth)
-{  
-    DIAG_NOTE(renderer, "set_linewidth %f\n", linewidth);
-
-    hpgl_select_pen(renderer, NULL, linewidth);
-}
-
-static void
-set_linecaps(MyRenderer *renderer, LineCaps mode)
-{
-    DIAG_NOTE(renderer, "set_linecaps %d\n", mode);
-
-    switch(mode) {
-    case LINECAPS_BUTT:
-	break;
-    case LINECAPS_ROUND:
-	break;
-    case LINECAPS_PROJECTING:
-	break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_linejoin(MyRenderer *renderer, LineJoin mode)
-{
-    DIAG_NOTE(renderer, "set_join %d\n", mode);
-
-    switch(mode) {
-    case LINEJOIN_MITER:
-	break;
-    case LINEJOIN_ROUND:
-	break;
-    case LINEJOIN_BEVEL:
-	break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_linestyle(MyRenderer *renderer, LineStyle mode)
-{
-    DIAG_NOTE(renderer, "set_linestyle %d\n", mode);
-
-    /* line type */
-    switch (mode) {
-    case LINESTYLE_SOLID:
-      fprintf(renderer->file, "LT;\n");
-      break;
-    case LINESTYLE_DASHED:
-      if (renderer->dash_length > 0.5) /* ??? unit of dash_lenght ? */
-          fprintf(renderer->file, "LT2;\n"); /* short */
-      else
-          fprintf(renderer->file, "LT3;\n"); /* long */
-      break;
-    case LINESTYLE_DASH_DOT:
-      fprintf(renderer->file, "LT4;\n");
-      break;
-    case LINESTYLE_DASH_DOT_DOT:
-      fprintf(renderer->file, "LT5;\n"); /* ??? Mittellinie? */
-      break;
-    case LINESTYLE_DOTTED:
-      fprintf(renderer->file, "LT1;\n");
-      break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_dashlength(MyRenderer *renderer, real length)
-{  
-    DIAG_NOTE(renderer, "set_dashlength %f\n", length);
-
-    /* dot = 20% of len */
-    renderer->dash_length = length;
-}
-
-static void
-set_fillstyle(MyRenderer *renderer, FillStyle mode)
-{
-    DIAG_NOTE(renderer, "set_fillstyle %d\n", mode);
-
-    switch(mode) {
-    case FILLSTYLE_SOLID:
-	break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_font(MyRenderer *renderer, Font *font, real height)
-{
-    DIAG_NOTE(renderer, "set_font %f\n", height);
-    renderer->font_height = height;
-}
-
-/* Need to translate coord system:
- * 
- *   Dia x,y -> Hpgl x,-y
- *
- * doing it before scaling.
- */
-static void
-draw_line(MyRenderer *renderer, 
-	  Point *start, Point *end, 
-	  Color *line_colour)
-{
-    DIAG_NOTE(renderer, "draw_line %f,%f -> %f, %f\n", 
-              start->x, start->y, end->x, end->y);
-    hpgl_select_pen(renderer, line_colour, 0.0);
-    fprintf (renderer->file, 
-             "PU%d,%d;PD%d,%d;\n",
-             hpgl_scale(renderer, start->x), hpgl_scale(renderer, -start->y),
-             hpgl_scale(renderer, end->x), hpgl_scale(renderer, -end->y));
-}
-
-static void
-draw_polyline(MyRenderer *renderer, 
-	      Point *points, int num_points, 
-	      Color *line_colour)
-{
-    int i;
-
-    DIAG_NOTE(renderer, "draw_polyline n:%d %f,%f ...\n", 
-              num_points, points->x, points->y);
-
-    g_return_if_fail(1 < num_points);
-
-    hpgl_select_pen(renderer, line_colour, 0.0);
-    fprintf (renderer->file, "PU%d,%d;PD;PA",
-             hpgl_scale(renderer, points[0].x),
-             hpgl_scale(renderer, -points[0].y));
-    /* absolute movement */
-    for (i = 1; i < num_points-1; i++)
-        fprintf(renderer->file, "%d,%d,",
-                hpgl_scale(renderer, points[i].x),
-                hpgl_scale(renderer, -points[i].y));
-    i = num_points - 1;
-    fprintf(renderer->file, "%d,%d;\n",
-            hpgl_scale(renderer, points[i].x),
-            hpgl_scale(renderer, -points[i].y));
-}
-
-static void
-draw_polygon(MyRenderer *renderer, 
-	     Point *points, int num_points, 
-	     Color *line_colour)
-{
-    DIAG_NOTE(renderer, "draw_polygon n:%d %f,%f ...\n", 
-              num_points, points->x, points->y);
-    draw_polyline(renderer,points,num_points,line_colour);
-    /* last to first */
-    draw_line(renderer, &points[num_points-1], &points[0], line_colour);
-}
-
-static void
-fill_polygon(MyRenderer *renderer, 
-	     Point *points, int num_points, 
-	     Color *colour)
-{
-    DIAG_NOTE(renderer, "fill_polygon n:%d %f,%f ...\n", 
-              num_points, points->x, points->y);
-    draw_polyline(renderer,points,num_points,colour);
-}
-
-static void
-draw_rect(MyRenderer *renderer, 
-	  Point *ul_corner, Point *lr_corner,
-	  Color *colour)
-{
-    DIAG_NOTE(renderer, "draw_rect %f,%f -> %f,%f\n", 
-              ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
-    hpgl_select_pen(renderer, colour, 0.0);
-    fprintf (renderer->file, "PU%d,%d;PD;EA%d,%d;\n",
-             hpgl_scale(renderer, ul_corner->x),
-             hpgl_scale(renderer, -ul_corner->y),
-             hpgl_scale(renderer, lr_corner->x),
-             hpgl_scale(renderer, -lr_corner->y));
-}
-
-static void
-fill_rect(MyRenderer *renderer, 
-	  Point *ul_corner, Point *lr_corner,
-	  Color *colour)
-{
-    DIAG_NOTE(renderer, "fill_rect %f,%f -> %f,%f\n", 
-              ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
-#if 0
-    hpgl_select_pen(renderer, colour, 0.0);
-    fprintf (renderer->file, "PU%d,%d;PD;RA%d,%d;\n",
-             hpgl_scale(renderer, ul_corner->x),
-             hpgl_scale(renderer, -ul_corner->y),
-             hpgl_scale(renderer, lr_corner->x),
-             hpgl_scale(renderer, -lr_corner->y));
-#else
-    /* the fill modes aren't really compatible ... */
-   draw_rect(renderer, ul_corner, lr_corner, colour);
-#endif
-}
-
-static void
-draw_arc(MyRenderer *renderer, 
-	 Point *center,
-	 real width, real height,
-	 real angle1, real angle2,
-	 Color *colour)
-{
-    Point start;
-
-    DIAG_NOTE(renderer, "draw_arc %fx%f <%f,<%f\n", 
-              width, height, angle1, angle2);
-    hpgl_select_pen(renderer, colour, 0.0);
-
-    /* move to start point */
-    start.x = center->x + (width / 2.0)  * cos((M_PI / 180.0) * angle1);  
-    start.y = - center->y + (height / 2.0) * sin((M_PI / 180.0) * angle1);
-    fprintf (renderer->file, "PU%d,%d;PD;",
-             hpgl_scale(renderer, start.x),
-             hpgl_scale(renderer, start.y));
-    /* Arc Absolute - around center */
-    fprintf (renderer->file, "AA%d,%d,%d;",
-             hpgl_scale(renderer, center->x),
-             hpgl_scale(renderer, - center->y),
-             (int)floor(360.0 - angle1 + angle2));
-}
-
-static void
-fill_arc(MyRenderer *renderer, 
-	 Point *center,
-	 real width, real height,
-	 real angle1, real angle2,
-	 Color *colour)
-{
-    DIAG_NOTE(renderer, "fill_arc %fx%f <%f,<%f\n", 
-              width, height, angle1, angle2);
-    g_assert (width == height);
-
-    /* move to center */
-    fprintf (renderer->file, "PU%d,%d;PD;",
-             hpgl_scale(renderer, center->x),
-             hpgl_scale(renderer, -center->y));
-    /* Edge Wedge */
-    fprintf (renderer->file, "EW%d,%d,%d;",
-             hpgl_scale(renderer, width),
-             (int)angle1, (int)(angle2-angle1));
-}
-
-static void
-draw_ellipse(MyRenderer *renderer, 
-	     Point *center,
-	     real width, real height,
-	     Color *colour)
-{
-  DIAG_NOTE(renderer, "draw_ellipse %fx%f center @ %f,%f\n", 
-            width, height, center->x, center->y);
-
-  if (width != height)
-  {
-    renderer_draw_ellipse_by_arc(renderer, center, width, height, colour);
-  }  
-  else
-  {
-    hpgl_select_pen(renderer, colour, 0.0);
-
-    fprintf (renderer->file, "PU%d,%d;CI%d;\n",
-             hpgl_scale(renderer, center->x),
-             hpgl_scale(renderer, -center->y),
-		 hpgl_scale(renderer, width / 2.0));
-  }
-}
-
-static void
-fill_ellipse(MyRenderer *renderer, 
-	     Point *center,
-	     real width, real height,
-	     Color *colour)
-{
-    DIAG_NOTE(renderer, "fill_ellipse %fx%f center @ %f,%f\n", 
-              width, height, center->x, center->y);
-}
-
-static void
-draw_bezier(MyRenderer *renderer, 
-	    BezPoint *points,
-	    int numpoints,
-	    Color *colour)
-{
-    DIAG_NOTE(renderer, "draw_bezier n:%d %fx%f ...\n", 
-              numpoints, points->p1.x, points->p1.y);
-
-    /* @todo: provide bezier rendering by simple render function callback like:
-     *
-     *  renderer_draw_bezier_by_line(renderer, points, numpoints, colour);
-     */
-}
-
-static void
-fill_bezier(MyRenderer *renderer, 
-	    BezPoint *points, /* Last point must be same as first point */
-	    int numpoints,
-	    Color *colour)
-{
-    DIAG_NOTE(renderer, "fill_bezier n:%d %fx%f ...\n", 
-              numpoints, points->p1.x, points->p1.y);
-}
-
-static void
-draw_string(MyRenderer *renderer,
-	    const char *text,
-	    Point *pos, Alignment alignment,
-	    Color *colour)
-{
-    float height, width;
-
-    DIAG_NOTE(renderer, "draw_string %f,%f %s\n", 
-              pos->x, pos->y, text);
-
-    /* set position */
-    fprintf(renderer->file, "PU%d,%d;",
-            hpgl_scale(renderer, pos->x), hpgl_scale(renderer, -pos->y));
-
-    switch (alignment) {
-    case ALIGN_LEFT:
-        fprintf (renderer->file, "LO1;\n");
-	break;
-    case ALIGN_CENTER:
-        fprintf (renderer->file, "LO4;\n");
-	break;
-    case ALIGN_RIGHT:
-        fprintf (renderer->file, "LO7;\n");
-	break;
-    }
-    hpgl_select_pen(renderer,colour,0.0);
-
-#if 0
-    /*
-     * SR - Relative Character Size >0.0 ... 127.999
-     *    set the capital letter box width and height as a percentage of
-     *    P2X-P1X  and P2Y-P1Y
-     */
-    height = (127.999 * renderer->font_height * renderer->scale) / renderer->size.y; 
-    width  = 0.75 * height; /* FIXME: */
-    fprintf(renderer->file, "SR%.3f,%.3f;", width, height);
-#else
-    /*
-     * SI - character size absolute
-     *    size needed in centimeters
-     */
-    fprintf(renderer->file, "SI%.3f,%.3f;", 
-            renderer->font_height * renderer->scale * 0.75 * 0.0025,
-            renderer->font_height * renderer->scale * 0.0025);
-
-#endif
-    fprintf(renderer->file, "DT\003;" /* Terminator */
-            "LB%s\003;\n", text);
-}
-
-static void
-draw_image(MyRenderer *renderer,
-	   Point *point,
-	   real width, real height,
-	   DiaImage image)
-{
-    DIAG_NOTE(renderer, "draw_image %fx%f @%f,%f\n", 
-              width, height, point->x, point->y);
-    g_warning("HPGL: images unsupported!");
-}
-
-static void
-export_data(DiagramData *data, const gchar *filename, const gchar *diafilename)
-{
-    MyRenderer *renderer;
-    FILE *file;
-    Rectangle *extent;
-    gint len;
-    real width, height;
-
-    file = fopen(filename, "w"); /* "wb" for binary! */
-
-    if (file == NULL) {
-	message_error(_("Couldn't open: '%s' for writing.\n"), filename);
-	return;
-    }
-
-    renderer = g_new(MyRenderer, 1);
-    renderer->renderer.ops = &MyRenderOps;
-    renderer->renderer.is_interactive = 0;
-    renderer->renderer.interactive_ops = NULL;
-
-    renderer->file = file;
-
-    extent = &data->extents;
-
-    /* use extents */
-    DIAG_NOTE(renderer, "export_data extents %f,%f -> %f,%f\n", 
-              extent->left, extent->top, extent->right, extent->bottom);
-
-    width  = extent->right - extent->left;
-    height = extent->bottom - extent->top;
-    renderer->scale = 0.001;
-    if (width > height)
-        while (renderer->scale * width < 3276.7) renderer->scale *= 10.0;
-    else
-        while (renderer->scale * height < 3276.7) renderer->scale *= 10.0;
-    renderer->offset = 0.0; /* just to have one */
-
-    renderer->size.x = width * renderer->scale;
-    renderer->size.y = height * renderer->scale;
-#if 0
-    /* OR: set page size and scale */
-    fprintf(renderer->file, "PS0;SC%d,%d,%d,%d;\n",
-            hpgl_scale(renderer, extent->left),
-            hpgl_scale(renderer, extent->right),
-            hpgl_scale(renderer, extent->bottom),
-            hpgl_scale(renderer, extent->top));
-#endif
-    data_render(data, (Renderer *)renderer, NULL, NULL, NULL);
-
-    g_free(renderer);
-}
-
-static const gchar *extensions[] = { "plt", "hpgl", NULL };
-static DiaExportFilter my_export_filter = {
-    N_(MY_RENDERER_NAME),
-    extensions,
-    export_data
-};
-
-
-/* --- dia plug-in interface --- */
-
-DIA_PLUGIN_CHECK_INIT
-
-PluginInitResult
-dia_plugin_init(PluginInfo *info)
-{
-    if (!dia_plugin_info_init(info, "HPGL",
-			      _("HP Graphics Language export filter"),
-			      NULL, NULL))
-	return DIA_PLUGIN_INIT_ERROR;
-
-    filter_register_export(&my_export_filter);
-
-    return DIA_PLUGIN_INIT_OK;
-}
+/* Dia -- an diagram creation/manipulation program
+ * Copyright (C) 1998 Alexander Larsson
+ *
+ * hpgl.c -- HPGL export plugin for dia
+ * Copyright (C) 2000, Hans Breuer, <[e-mail]>
+ *   based on dummy.c 
+ *   based on CGM plug-in Copyright (C) 1999 James Henstridge. 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * ToDo:
+ * - provide more rendering functions like "render_draw_ellipse_by_arc" 
+ *   to be used by simple format renderers; move them to libdia?
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <glib.h>
+
+#include "config.h"
+#include "intl.h"
+#include "message.h"
+#include "geometry.h"
+#include "render.h"
+#include "filter.h"
+#include "plug-ins.h"
+
+/* format specific */
+#define HPGL_MAX_PENS 8
+
+/* --- the renderer --- */
+#define MY_RENDERER_NAME "HPGL"
+
+#define PEN_HAS_COLOR (1 << 0) 
+#define PEN_HAS_WIDTH (1 << 1) 
+
+typedef struct _MyRenderer MyRenderer;
+struct _MyRenderer {
+    Renderer renderer;
+
+    FILE *file;
+
+    /*
+     * The number of pens is limited. This is used to select one.
+     */
+    struct {
+        Color color;
+        float width;
+        int   has_it;
+    } pen[HPGL_MAX_PENS];
+    int last_pen;
+    real dash_length;
+    real font_height;
+
+    Point size;  /* extent size */
+    real scale;
+    real offset; /* in dia units */
+};
+
+/* include function declares and render object "vtable" */
+#include "../renderer.inc"
+
+#define DIAG_NOTE /* my_log */
+void
+my_log(MyRenderer* renderer, char* format, ...)
+{
+    gchar *string;
+    va_list args;
+  
+    g_return_if_fail (format != NULL);
+  
+    va_start (args, format);
+    string = g_strdup_vprintf (format, args);
+    va_end (args);
+
+    g_print(string);
+
+    g_free(string);
+}
+
+/* hpgl helpers */
+void hpgl_select_pen(MyRenderer* renderer, Color* color, real width)
+{
+    int nPen = 0;
+    int i;
+    /* look if this pen is defined already */
+    if (0.0 != width) {
+        /* either width ... */
+        for (i = 0; i < HPGL_MAX_PENS; i++) {
+            if (!(renderer->pen[i].has_it & PEN_HAS_WIDTH)) {
+                nPen = i;
+                break;
+            }
+            if (width == renderer->pen[i].width) {
+                nPen = i;
+                break;
+            }
+        }
+    }
+ 
+    if (NULL != color) {
+        for (i = nPen; i < HPGL_MAX_PENS; i++) {
+            if (!(renderer->pen[i].has_it & PEN_HAS_COLOR)) {
+                nPen = i;
+                break;
+            }
+            if (   (color->red == renderer->pen[i].color.red)
+                && (color->green == renderer->pen[i].color.green)
+                && (color->blue == renderer->pen[i].color.blue)) {
+                nPen = i;
+                break;
+            }
+        }
+    }
+    /* "create" new pen ... */
+    if ((nPen < HPGL_MAX_PENS) && (-1 < nPen)) {
+        if (0.0 != width) {
+            renderer->pen[nPen].width = width;
+            renderer->pen[nPen].has_it |= PEN_HAS_WIDTH;
+        }
+        if (NULL != color) {
+            renderer->pen[nPen].color = *color;
+            renderer->pen[nPen].has_it |= PEN_HAS_COLOR;
+        }
+    }
+    /* ... or use best fitting one */
+    else if (-1 == nPen) {
+        nPen = 0; /* TODO: */
+    }
+
+    if (renderer->last_pen != nPen)
+        fprintf(renderer->file, "SP%d;\n", nPen+1);
+    renderer->last_pen = nPen;
+}
+
+int
+hpgl_scale(MyRenderer *renderer, real val)
+{
+    return (int)((val + renderer->offset) * renderer->scale);
+}
+
+/* render functions */ 
+static void
+begin_render(MyRenderer *renderer, DiagramData *data)
+{
+    int i;
+
+    DIAG_NOTE(renderer, "begin_render\n");
+
+    /* initialize pens */
+    for (i = 0; i < HPGL_MAX_PENS; i++) {
+        renderer->pen[i].color = color_black;
+        renderer->pen[i].width = 0.0;
+        renderer->pen[i].has_it = 0;
+    }
+    renderer->last_pen = -1;
+    renderer->dash_length = 0.0;
+}
+
+static void
+end_render(MyRenderer *renderer)
+{
+    DIAG_NOTE(renderer, "end_render\n");
+    fclose(renderer->file);
+}
+
+static void
+set_linewidth(MyRenderer *renderer, real linewidth)
+{  
+    DIAG_NOTE(renderer, "set_linewidth %f\n", linewidth);
+
+    hpgl_select_pen(renderer, NULL, linewidth);
+}
+
+static void
+set_linecaps(MyRenderer *renderer, LineCaps mode)
+{
+    DIAG_NOTE(renderer, "set_linecaps %d\n", mode);
+
+    switch(mode) {
+    case LINECAPS_BUTT:
+	break;
+    case LINECAPS_ROUND:
+	break;
+    case LINECAPS_PROJECTING:
+	break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_linejoin(MyRenderer *renderer, LineJoin mode)
+{
+    DIAG_NOTE(renderer, "set_join %d\n", mode);
+
+    switch(mode) {
+    case LINEJOIN_MITER:
+	break;
+    case LINEJOIN_ROUND:
+	break;
+    case LINEJOIN_BEVEL:
+	break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_linestyle(MyRenderer *renderer, LineStyle mode)
+{
+    DIAG_NOTE(renderer, "set_linestyle %d\n", mode);
+
+    /* line type */
+    switch (mode) {
+    case LINESTYLE_SOLID:
+      fprintf(renderer->file, "LT;\n");
+      break;
+    case LINESTYLE_DASHED:
+      if (renderer->dash_length > 0.5) /* ??? unit of dash_lenght ? */
+          fprintf(renderer->file, "LT2;\n"); /* short */
+      else
+          fprintf(renderer->file, "LT3;\n"); /* long */
+      break;
+    case LINESTYLE_DASH_DOT:
+      fprintf(renderer->file, "LT4;\n");
+      break;
+    case LINESTYLE_DASH_DOT_DOT:
+      fprintf(renderer->file, "LT5;\n"); /* ??? Mittellinie? */
+      break;
+    case LINESTYLE_DOTTED:
+      fprintf(renderer->file, "LT1;\n");
+      break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_dashlength(MyRenderer *renderer, real length)
+{  
+    DIAG_NOTE(renderer, "set_dashlength %f\n", length);
+
+    /* dot = 20% of len */
+    renderer->dash_length = length;
+}
+
+static void
+set_fillstyle(MyRenderer *renderer, FillStyle mode)
+{
+    DIAG_NOTE(renderer, "set_fillstyle %d\n", mode);
+
+    switch(mode) {
+    case FILLSTYLE_SOLID:
+	break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_font(MyRenderer *renderer, Font *font, real height)
+{
+    DIAG_NOTE(renderer, "set_font %f\n", height);
+    renderer->font_height = height;
+}
+
+/* Need to translate coord system:
+ * 
+ *   Dia x,y -> Hpgl x,-y
+ *
+ * doing it before scaling.
+ */
+static void
+draw_line(MyRenderer *renderer, 
+	  Point *start, Point *end, 
+	  Color *line_colour)
+{
+    DIAG_NOTE(renderer, "draw_line %f,%f -> %f, %f\n", 
+              start->x, start->y, end->x, end->y);
+    hpgl_select_pen(renderer, line_colour, 0.0);
+    fprintf (renderer->file, 
+             "PU%d,%d;PD%d,%d;\n",
+             hpgl_scale(renderer, start->x), hpgl_scale(renderer, -start->y),
+             hpgl_scale(renderer, end->x), hpgl_scale(renderer, -end->y));
+}
+
+static void
+draw_polyline(MyRenderer *renderer, 
+	      Point *points, int num_points, 
+	      Color *line_colour)
+{
+    int i;
+
+    DIAG_NOTE(renderer, "draw_polyline n:%d %f,%f ...\n", 
+              num_points, points->x, points->y);
+
+    g_return_if_fail(1 < num_points);
+
+    hpgl_select_pen(renderer, line_colour, 0.0);
+    fprintf (renderer->file, "PU%d,%d;PD;PA",
+             hpgl_scale(renderer, points[0].x),
+             hpgl_scale(renderer, -points[0].y));
+    /* absolute movement */
+    for (i = 1; i < num_points-1; i++)
+        fprintf(renderer->file, "%d,%d,",
+                hpgl_scale(renderer, points[i].x),
+                hpgl_scale(renderer, -points[i].y));
+    i = num_points - 1;
+    fprintf(renderer->file, "%d,%d;\n",
+            hpgl_scale(renderer, points[i].x),
+            hpgl_scale(renderer, -points[i].y));
+}
+
+static void
+draw_polygon(MyRenderer *renderer, 
+	     Point *points, int num_points, 
+	     Color *line_colour)
+{
+    DIAG_NOTE(renderer, "draw_polygon n:%d %f,%f ...\n", 
+              num_points, points->x, points->y);
+    draw_polyline(renderer,points,num_points,line_colour);
+    /* last to first */
+    draw_line(renderer, &points[num_points-1], &points[0], line_colour);
+}
+
+static void
+fill_polygon(MyRenderer *renderer, 
+	     Point *points, int num_points, 
+	     Color *colour)
+{
+    DIAG_NOTE(renderer, "fill_polygon n:%d %f,%f ...\n", 
+              num_points, points->x, points->y);
+    draw_polyline(renderer,points,num_points,colour);
+}
+
+static void
+draw_rect(MyRenderer *renderer, 
+	  Point *ul_corner, Point *lr_corner,
+	  Color *colour)
+{
+    DIAG_NOTE(renderer, "draw_rect %f,%f -> %f,%f\n", 
+              ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
+    hpgl_select_pen(renderer, colour, 0.0);
+    fprintf (renderer->file, "PU%d,%d;PD;EA%d,%d;\n",
+             hpgl_scale(renderer, ul_corner->x),
+             hpgl_scale(renderer, -ul_corner->y),
+             hpgl_scale(renderer, lr_corner->x),
+             hpgl_scale(renderer, -lr_corner->y));
+}
+
+static void
+fill_rect(MyRenderer *renderer, 
+	  Point *ul_corner, Point *lr_corner,
+	  Color *colour)
+{
+    DIAG_NOTE(renderer, "fill_rect %f,%f -> %f,%f\n", 
+              ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
+#if 0
+    hpgl_select_pen(renderer, colour, 0.0);
+    fprintf (renderer->file, "PU%d,%d;PD;RA%d,%d;\n",
+             hpgl_scale(renderer, ul_corner->x),
+             hpgl_scale(renderer, -ul_corner->y),
+             hpgl_scale(renderer, lr_corner->x),
+             hpgl_scale(renderer, -lr_corner->y));
+#else
+    /* the fill modes aren't really compatible ... */
+   draw_rect(renderer, ul_corner, lr_corner, colour);
+#endif
+}
+
+static void
+draw_arc(MyRenderer *renderer, 
+	 Point *center,
+	 real width, real height,
+	 real angle1, real angle2,
+	 Color *colour)
+{
+    Point start;
+
+    DIAG_NOTE(renderer, "draw_arc %fx%f <%f,<%f\n", 
+              width, height, angle1, angle2);
+    hpgl_select_pen(renderer, colour, 0.0);
+
+    /* move to start point */
+    start.x = center->x + (width / 2.0)  * cos((M_PI / 180.0) * angle1);  
+    start.y = - center->y + (height / 2.0) * sin((M_PI / 180.0) * angle1);
+    fprintf (renderer->file, "PU%d,%d;PD;",
+             hpgl_scale(renderer, start.x),
+             hpgl_scale(renderer, start.y));
+    /* Arc Absolute - around center */
+    fprintf (renderer->file, "AA%d,%d,%d;",
+             hpgl_scale(renderer, center->x),
+             hpgl_scale(renderer, - center->y),
+             (int)floor(360.0 - angle1 + angle2));
+}
+
+static void
+fill_arc(MyRenderer *renderer, 
+	 Point *center,
+	 real width, real height,
+	 real angle1, real angle2,
+	 Color *colour)
+{
+    DIAG_NOTE(renderer, "fill_arc %fx%f <%f,<%f\n", 
+              width, height, angle1, angle2);
+    g_assert (width == height);
+
+    /* move to center */
+    fprintf (renderer->file, "PU%d,%d;PD;",
+             hpgl_scale(renderer, center->x),
+             hpgl_scale(renderer, -center->y));
+    /* Edge Wedge */
+    fprintf (renderer->file, "EW%d,%d,%d;",
+             hpgl_scale(renderer, width),
+             (int)angle1, (int)(angle2-angle1));
+}
+
+static void
+draw_ellipse(MyRenderer *renderer, 
+	     Point *center,
+	     real width, real height,
+	     Color *colour)
+{
+  DIAG_NOTE(renderer, "draw_ellipse %fx%f center @ %f,%f\n", 
+            width, height, center->x, center->y);
+
+  if (width != height)
+  {
+    renderer_draw_ellipse_by_arc(renderer, center, width, height, colour);
+  }  
+  else
+  {
+    hpgl_select_pen(renderer, colour, 0.0);
+
+    fprintf (renderer->file, "PU%d,%d;CI%d;\n",
+             hpgl_scale(renderer, center->x),
+             hpgl_scale(renderer, -center->y),
+		 hpgl_scale(renderer, width / 2.0));
+  }
+}
+
+static void
+fill_ellipse(MyRenderer *renderer, 
+	     Point *center,
+	     real width, real height,
+	     Color *colour)
+{
+    DIAG_NOTE(renderer, "fill_ellipse %fx%f center @ %f,%f\n", 
+              width, height, center->x, center->y);
+}
+
+static void
+draw_bezier(MyRenderer *renderer, 
+	    BezPoint *points,
+	    int numpoints,
+	    Color *colour)
+{
+    DIAG_NOTE(renderer, "draw_bezier n:%d %fx%f ...\n", 
+              numpoints, points->p1.x, points->p1.y);
+
+    /* @todo: provide bezier rendering by simple render function callback like:
+     *
+     *  renderer_draw_bezier_by_line(renderer, points, numpoints, colour);
+     */
+}
+
+static void
+fill_bezier(MyRenderer *renderer, 
+	    BezPoint *points, /* Last point must be same as first point */
+	    int numpoints,
+	    Color *colour)
+{
+    DIAG_NOTE(renderer, "fill_bezier n:%d %fx%f ...\n", 
+              numpoints, points->p1.x, points->p1.y);
+}
+
+static void
+draw_string(MyRenderer *renderer,
+	    const char *text,
+	    Point *pos, Alignment alignment,
+	    Color *colour)
+{
+    float height, width;
+
+    DIAG_NOTE(renderer, "draw_string %f,%f %s\n", 
+              pos->x, pos->y, text);
+
+    /* set position */
+    fprintf(renderer->file, "PU%d,%d;",
+            hpgl_scale(renderer, pos->x), hpgl_scale(renderer, -pos->y));
+
+    switch (alignment) {
+    case ALIGN_LEFT:
+        fprintf (renderer->file, "LO1;\n");
+	break;
+    case ALIGN_CENTER:
+        fprintf (renderer->file, "LO4;\n");
+	break;
+    case ALIGN_RIGHT:
+        fprintf (renderer->file, "LO7;\n");
+	break;
+    }
+    hpgl_select_pen(renderer,colour,0.0);
+
+#if 0
+    /*
+     * SR - Relative Character Size >0.0 ... 127.999
+     *    set the capital letter box width and height as a percentage of
+     *    P2X-P1X  and P2Y-P1Y
+     */
+    height = (127.999 * renderer->font_height * renderer->scale) / renderer->size.y; 
+    width  = 0.75 * height; /* FIXME: */
+    fprintf(renderer->file, "SR%.3f,%.3f;", width, height);
+#else
+    /*
+     * SI - character size absolute
+     *    size needed in centimeters
+     */
+    fprintf(renderer->file, "SI%.3f,%.3f;", 
+            renderer->font_height * renderer->scale * 0.75 * 0.0025,
+            renderer->font_height * renderer->scale * 0.0025);
+
+#endif
+    fprintf(renderer->file, "DT\003;" /* Terminator */
+            "LB%s\003;\n", text);
+}
+
+static void
+draw_image(MyRenderer *renderer,
+	   Point *point,
+	   real width, real height,
+	   DiaImage image)
+{
+    DIAG_NOTE(renderer, "draw_image %fx%f @%f,%f\n", 
+              width, height, point->x, point->y);
+    g_warning("HPGL: images unsupported!");
+}
+
+static void
+export_data(DiagramData *data, const gchar *filename, const gchar *diafilename)
+{
+    MyRenderer *renderer;
+    FILE *file;
+    Rectangle *extent;
+    gint len;
+    real width, height;
+
+    file = fopen(filename, "w"); /* "wb" for binary! */
+
+    if (file == NULL) {
+	message_error(_("Couldn't open: '%s' for writing.\n"), filename);
+	return;
+    }
+
+    renderer = g_new(MyRenderer, 1);
+    renderer->renderer.ops = &MyRenderOps;
+    renderer->renderer.is_interactive = 0;
+    renderer->renderer.interactive_ops = NULL;
+
+    renderer->file = file;
+
+    extent = &data->extents;
+
+    /* use extents */
+    DIAG_NOTE(renderer, "export_data extents %f,%f -> %f,%f\n", 
+              extent->left, extent->top, extent->right, extent->bottom);
+
+    width  = extent->right - extent->left;
+    height = extent->bottom - extent->top;
+    renderer->scale = 0.001;
+    if (width > height)
+        while (renderer->scale * width < 3276.7) renderer->scale *= 10.0;
+    else
+        while (renderer->scale * height < 3276.7) renderer->scale *= 10.0;
+    renderer->offset = 0.0; /* just to have one */
+
+    renderer->size.x = width * renderer->scale;
+    renderer->size.y = height * renderer->scale;
+#if 0
+    /* OR: set page size and scale */
+    fprintf(renderer->file, "PS0;SC%d,%d,%d,%d;\n",
+            hpgl_scale(renderer, extent->left),
+            hpgl_scale(renderer, extent->right),
+            hpgl_scale(renderer, extent->bottom),
+            hpgl_scale(renderer, extent->top));
+#endif
+    data_render(data, (Renderer *)renderer, NULL, NULL, NULL);
+
+    g_free(renderer);
+}
+
+static const gchar *extensions[] = { "plt", "hpgl", NULL };
+static DiaExportFilter my_export_filter = {
+    N_(MY_RENDERER_NAME),
+    extensions,
+    export_data
+};
+
+
+/* --- dia plug-in interface --- */
+
+DIA_PLUGIN_CHECK_INIT
+
+PluginInitResult
+dia_plugin_init(PluginInfo *info)
+{
+    if (!dia_plugin_info_init(info, "HPGL",
+			      _("HP Graphics Language export filter"),
+			      NULL, NULL))
+	return DIA_PLUGIN_INIT_ERROR;
+
+    filter_register_export(&my_export_filter);
+
+    return DIA_PLUGIN_INIT_OK;
+}

--- a/plug-ins/renderer.inc
+++ b/plug-ins/renderer.inc
@@ -1,163 +1,163 @@
-/* Dia -- an diagram creation/manipulation program
- * Copyright (C) 1998 Alexander Larsson
- *
- * renderer.inc - The Dia renderer interface as include file
- *                to be used with export filters
- *             and
- *                renderer functions to construct complex 
- *                geometric forms by simple drawing commands
- */
-
-/* --- the renderer --- */
-#if !defined(MY_RENDERER_NAME)
-#error You need to define your private name and renderer struct before including this file!
-#endif 
-
-static void begin_render(MyRenderer *renderer, DiagramData *data);
-static void end_render(MyRenderer *renderer);
-static void set_linewidth(MyRenderer *renderer, real linewidth);
-static void set_linecaps(MyRenderer *renderer, LineCaps mode);
-static void set_linejoin(MyRenderer *renderer, LineJoin mode);
-static void set_linestyle(MyRenderer *renderer, LineStyle mode);
-static void set_dashlength(MyRenderer *renderer, real length);
-static void set_fillstyle(MyRenderer *renderer, FillStyle mode);
-static void set_font(MyRenderer *renderer, Font *font, real height);
-static void draw_line(MyRenderer *renderer, 
-		      Point *start, Point *end, 
-		      Color *line_colour);
-static void draw_polyline(MyRenderer *renderer, 
-			  Point *points, int num_points, 
-			  Color *line_colour);
-static void draw_polygon(MyRenderer *renderer, 
-			 Point *points, int num_points, 
-			 Color *line_colour);
-static void fill_polygon(MyRenderer *renderer, 
-			 Point *points, int num_points, 
-			 Color *line_colour);
-static void draw_rect(MyRenderer *renderer, 
-		      Point *ul_corner, Point *lr_corner,
-		      Color *colour);
-static void fill_rect(MyRenderer *renderer, 
-		      Point *ul_corner, Point *lr_corner,
-		      Color *colour);
-static void draw_arc(MyRenderer *renderer, 
-		     Point *center,
-		     real width, real height,
-		     real angle1, real angle2,
-		     Color *colour);
-static void fill_arc(MyRenderer *renderer, 
-		     Point *center,
-		     real width, real height,
-		     real angle1, real angle2,
-		     Color *colour);
-static void draw_ellipse(MyRenderer *renderer, 
-			 Point *center,
-			 real width, real height,
-			 Color *colour);
-static void fill_ellipse(MyRenderer *renderer, 
-			 Point *center,
-			 real width, real height,
-			 Color *colour);
-static void draw_bezier(MyRenderer *renderer, 
-			BezPoint *points,
-			int numpoints,
-			Color *colour);
-static void fill_bezier(MyRenderer *renderer, 
-			BezPoint *points, /* Last point must be same as first point */
-			int numpoints,
-			Color *colour);
-static void draw_string(MyRenderer *renderer,
-			const char *text,
-			Point *pos, Alignment alignment,
-			Color *colour);
-static void draw_image(MyRenderer *renderer,
-		       Point *point,
-		       real width, real height,
-		       DiaImage image);
-
-static RenderOps MyRenderOps = {
-    (BeginRenderFunc) begin_render,
-    (EndRenderFunc) end_render,
-
-    (SetLineWidthFunc) set_linewidth,
-    (SetLineCapsFunc) set_linecaps,
-    (SetLineJoinFunc) set_linejoin,
-    (SetLineStyleFunc) set_linestyle,
-    (SetDashLengthFunc) set_dashlength,
-    (SetFillStyleFunc) set_fillstyle,
-    (SetFontFunc) set_font,
-  
-    (DrawLineFunc) draw_line,
-    (DrawPolyLineFunc) draw_polyline,
-  
-    (DrawPolygonFunc) draw_polygon,
-    (FillPolygonFunc) fill_polygon,
-
-    (DrawRectangleFunc) draw_rect,
-    (FillRectangleFunc) fill_rect,
-
-    (DrawArcFunc) draw_arc,
-    (FillArcFunc) fill_arc,
-
-    (DrawEllipseFunc) draw_ellipse,
-    (FillEllipseFunc) fill_ellipse,
-
-    (DrawBezierFunc) draw_bezier,
-    (FillBezierFunc) fill_bezier,
-
-    (DrawStringFunc) draw_string,
-
-    (DrawImageFunc) draw_image,
-};
-
-/* Draw an ellipse approximation consisting out of
- * four arcs. 
- */
-void
-renderer_draw_ellipse_by_arc(
-    MyRenderer *renderer, 
-    Point *center,
-    real width, real height,
-    Color *colour)
-{
-  real a, b, e, d, alpha, c, x, y;
-  real g, gamma, r;
-  Point pt;
-  real angle;
-
-  a = width / 2;
-  b = height / 2;
-  e = sqrt(a*a - b*b);
-
-  alpha = 0.25*M_PI - asin((e/a) * sin(0.75*M_PI));
-  d = 2*a*sin(alpha);
-
-  c = (sin(0.25*M_PI) * (2*e + d)) / sin(0.75*M_PI - alpha);
-
-  y = c * sin (alpha);
-  x = c * cos (alpha) - e;
-
-  /* draw arcs */
-  g = sqrt((a-x)*(a-x) + y*y);
-  gamma = acos((a-x)/g);
-  r = (sin(gamma) * g) / sin(M_PI-2*gamma);
-
-  pt.y = center->y;
-  angle = (180 * (M_PI-2*gamma)) / M_PI;
-  pt.x = center->x + a - r; /* right */
-  draw_arc(renderer, &pt, 2*r, 2*r, 360-angle, angle, colour);
-  pt.x = center->x - a + r; /* left */
-  draw_arc(renderer, &pt, 2*r, 2*r, 180-angle, 180+angle, colour);
-
-
-  g = sqrt((b-y)*(b-y) + x*x);
-  gamma = acos((b-y)/g);
-  r = (sin(gamma) * g) / sin(M_PI-2*gamma);
-
-  pt.x = center->x;
-  angle = (180 * (M_PI-2*gamma)) / M_PI;
-  pt.y = center->y - b + r; /* top */
-  draw_arc(renderer, &pt, 2*r, 2*r, 90-angle, 90+angle, colour);
-  pt.y = center->y + b - r; /* bottom */
-  draw_arc(renderer, &pt, 2*r, 2*r, 270-angle, 270+angle, colour);
+/* Dia -- an diagram creation/manipulation program
+ * Copyright (C) 1998 Alexander Larsson
+ *
+ * renderer.inc - The Dia renderer interface as include file
+ *                to be used with export filters
+ *             and
+ *                renderer functions to construct complex 
+ *                geometric forms by simple drawing commands
+ */
+
+/* --- the renderer --- */
+#if !defined(MY_RENDERER_NAME)
+#error You need to define your private name and renderer struct before including this file!
+#endif 
+
+static void begin_render(MyRenderer *renderer, DiagramData *data);
+static void end_render(MyRenderer *renderer);
+static void set_linewidth(MyRenderer *renderer, real linewidth);
+static void set_linecaps(MyRenderer *renderer, LineCaps mode);
+static void set_linejoin(MyRenderer *renderer, LineJoin mode);
+static void set_linestyle(MyRenderer *renderer, LineStyle mode);
+static void set_dashlength(MyRenderer *renderer, real length);
+static void set_fillstyle(MyRenderer *renderer, FillStyle mode);
+static void set_font(MyRenderer *renderer, Font *font, real height);
+static void draw_line(MyRenderer *renderer, 
+		      Point *start, Point *end, 
+		      Color *line_colour);
+static void draw_polyline(MyRenderer *renderer, 
+			  Point *points, int num_points, 
+			  Color *line_colour);
+static void draw_polygon(MyRenderer *renderer, 
+			 Point *points, int num_points, 
+			 Color *line_colour);
+static void fill_polygon(MyRenderer *renderer, 
+			 Point *points, int num_points, 
+			 Color *line_colour);
+static void draw_rect(MyRenderer *renderer, 
+		      Point *ul_corner, Point *lr_corner,
+		      Color *colour);
+static void fill_rect(MyRenderer *renderer, 
+		      Point *ul_corner, Point *lr_corner,
+		      Color *colour);
+static void draw_arc(MyRenderer *renderer, 
+		     Point *center,
+		     real width, real height,
+		     real angle1, real angle2,
+		     Color *colour);
+static void fill_arc(MyRenderer *renderer, 
+		     Point *center,
+		     real width, real height,
+		     real angle1, real angle2,
+		     Color *colour);
+static void draw_ellipse(MyRenderer *renderer, 
+			 Point *center,
+			 real width, real height,
+			 Color *colour);
+static void fill_ellipse(MyRenderer *renderer, 
+			 Point *center,
+			 real width, real height,
+			 Color *colour);
+static void draw_bezier(MyRenderer *renderer, 
+			BezPoint *points,
+			int numpoints,
+			Color *colour);
+static void fill_bezier(MyRenderer *renderer, 
+			BezPoint *points, /* Last point must be same as first point */
+			int numpoints,
+			Color *colour);
+static void draw_string(MyRenderer *renderer,
+			const char *text,
+			Point *pos, Alignment alignment,
+			Color *colour);
+static void draw_image(MyRenderer *renderer,
+		       Point *point,
+		       real width, real height,
+		       DiaImage image);
+
+static RenderOps MyRenderOps = {
+    (BeginRenderFunc) begin_render,
+    (EndRenderFunc) end_render,
+
+    (SetLineWidthFunc) set_linewidth,
+    (SetLineCapsFunc) set_linecaps,
+    (SetLineJoinFunc) set_linejoin,
+    (SetLineStyleFunc) set_linestyle,
+    (SetDashLengthFunc) set_dashlength,
+    (SetFillStyleFunc) set_fillstyle,
+    (SetFontFunc) set_font,
+  
+    (DrawLineFunc) draw_line,
+    (DrawPolyLineFunc) draw_polyline,
+  
+    (DrawPolygonFunc) draw_polygon,
+    (FillPolygonFunc) fill_polygon,
+
+    (DrawRectangleFunc) draw_rect,
+    (FillRectangleFunc) fill_rect,
+
+    (DrawArcFunc) draw_arc,
+    (FillArcFunc) fill_arc,
+
+    (DrawEllipseFunc) draw_ellipse,
+    (FillEllipseFunc) fill_ellipse,
+
+    (DrawBezierFunc) draw_bezier,
+    (FillBezierFunc) fill_bezier,
+
+    (DrawStringFunc) draw_string,
+
+    (DrawImageFunc) draw_image,
+};
+
+/* Draw an ellipse approximation consisting out of
+ * four arcs. 
+ */
+void
+renderer_draw_ellipse_by_arc(
+    MyRenderer *renderer, 
+    Point *center,
+    real width, real height,
+    Color *colour)
+{
+  real a, b, e, d, alpha, c, x, y;
+  real g, gamma, r;
+  Point pt;
+  real angle;
+
+  a = width / 2;
+  b = height / 2;
+  e = sqrt(a*a - b*b);
+
+  alpha = 0.25*M_PI - asin((e/a) * sin(0.75*M_PI));
+  d = 2*a*sin(alpha);
+
+  c = (sin(0.25*M_PI) * (2*e + d)) / sin(0.75*M_PI - alpha);
+
+  y = c * sin (alpha);
+  x = c * cos (alpha) - e;
+
+  /* draw arcs */
+  g = sqrt((a-x)*(a-x) + y*y);
+  gamma = acos((a-x)/g);
+  r = (sin(gamma) * g) / sin(M_PI-2*gamma);
+
+  pt.y = center->y;
+  angle = (180 * (M_PI-2*gamma)) / M_PI;
+  pt.x = center->x + a - r; /* right */
+  draw_arc(renderer, &pt, 2*r, 2*r, 360-angle, angle, colour);
+  pt.x = center->x - a + r; /* left */
+  draw_arc(renderer, &pt, 2*r, 2*r, 180-angle, 180+angle, colour);
+
+
+  g = sqrt((b-y)*(b-y) + x*x);
+  gamma = acos((b-y)/g);
+  r = (sin(gamma) * g) / sin(M_PI-2*gamma);
+
+  pt.x = center->x;
+  angle = (180 * (M_PI-2*gamma)) / M_PI;
+  pt.y = center->y - b + r; /* top */
+  draw_arc(renderer, &pt, 2*r, 2*r, 90-angle, 90+angle, colour);
+  pt.y = center->y + b - r; /* bottom */
+  draw_arc(renderer, &pt, 2*r, 2*r, 270-angle, 270+angle, colour);
 }
\ No newline at end of file

--- /dev/null
+++ b/plug-ins/wmf/.cvsignore
@@ -0,0 +1,9 @@
+.cvsignore
+.deps
+.libs
+Makefile
+Makefile.in
+*.lo
+*.la
+*.pyc
+

--- a/plug-ins/wmf/wmf.cpp
+++ b/plug-ins/wmf/wmf.cpp
@@ -1,788 +1,788 @@
-/* Dia -- an diagram creation/manipulation program
- * Copyright (C) 1998 Alexander Larsson
- *
- * wmf.cpp -- Windows Metafile export plugin for dia
- * Copyright (C) 2000, Hans Breuer, <[e-mail]>
- *   based on dummy plug-in. 
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-#include <glib.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "config.h"
-#include "intl.h"
-#include "message.h"
-#include "geometry.h"
-#include "render.h"
-#include "filter.h"
-#include "plug-ins.h"
-
-#ifdef __cplusplus
-}
-#endif
-
-namespace W32 {
-// at least Rectangle conflicts ...
-#include <windows.h>
-}
-
-/* force linking with gdi32 */
-#pragma comment( lib, "gdi32" )
- 
-
-// #define SAVE_EMF
-
-/* --- the renderer --- */
-#define MY_RENDERER_NAME "WMF"
-
-typedef struct _MyRenderer MyRenderer;
-struct _MyRenderer {
-    Renderer renderer;
-
-    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::HFONT hFont;
-};
-
-/* include function declares and render object "vtable" */
-#include "../renderer.inc"
-
-/*
- * helper macros
- */
-#define W32COLOR(c) \
-	 0xff * c->red + \
-	((unsigned char)(0xff * c->green)) * 256 + \
-	((unsigned char)(0xff * c->blue)) * 65536;
-
-#define WMF_SCALE 100.0
-#define SC(a) ((a)*WMF_SCALE)
-
-/*
- * helper functions
- */
-static W32::HGDIOBJ
-UsePen(MyRenderer* renderer, Color* colour)
-{
-    W32::HPEN hOldPen;
-    W32::COLORREF rgb = W32COLOR(colour);
-
-    renderer->hPen = W32::CreatePen( renderer->fnPenStyle, 
-						 renderer->nLineWidth,
-						 rgb);
-    hOldPen = W32::SelectObject(renderer->hFileDC, renderer->hPen);
-    return hOldPen;
-}
-
-static void
-DonePen(MyRenderer* renderer, W32::HPEN hPen)
-{
-    /* restore the OLD one ... */
-    if (hPen) W32::SelectObject(renderer->hFileDC, hPen);
-    /* ... before deleting the last active */
-    if (renderer->hPen)
-    {
-	W32::DeleteObject(renderer->hPen);
-	renderer->hPen = NULL;
-    }
-}
-
-#define DIAG_NOTE my_log
-void
-my_log(MyRenderer* renderer, char* format, ...)
-{
-    gchar *string;
-    va_list args;
-  
-    g_return_if_fail (format != NULL);
-  
-    va_start (args, format);
-    string = g_strdup_vprintf (format, args);
-    va_end (args);
-
-    //fprintf(renderer->file, string);
-    g_print(string);
-
-    g_free(string);
-}
- 
-/*
- * renderer interface implementation
- */
-static void
-begin_render(MyRenderer *renderer, DiagramData *data)
-{
-    DIAG_NOTE(renderer, "begin_render\n");
-
-    /* make unfilled the default */
-    W32::SelectObject(renderer->hFileDC, 
-	W32::GetStockObject (HOLLOW_BRUSH) );
-}
-
-static void
-end_render(MyRenderer *renderer)
-{
-    W32::HENHMETAFILE hEmf;
-    W32::UINT nSize;
-    W32::BYTE* pData = NULL;
-    FILE* f;
-
-    DIAG_NOTE(renderer, "end_render\n");
-    hEmf = W32::CloseEnhMetaFile(renderer->hFileDC);
-
-#ifndef SAVE_EMF
-    /* get size */
-    nSize = W32::GetWinMetaFileBits(hEmf, 0, NULL, MM_ANISOTROPIC, W32::GetDC(NULL));
-    pData = g_new(W32::BYTE, nSize);
-    /* get data */
-    nSize = W32::GetWinMetaFileBits(hEmf, nSize, pData, MM_ANISOTROPIC, W32::GetDC(NULL));
-
-    /* write file */
-    f = fopen(renderer->sFileName, "wb");
-    fwrite(pData,1,nSize,f);
-    fclose(f);
-    
-    g_free(pData);
-#endif
-    g_free(renderer->sFileName);
-
-    if (hEmf)
-	W32::DeleteEnhMetaFile(hEmf);
-    if (renderer->hFont)
-	W32::DeleteObject(renderer->hFont);
-}
-
-static void
-set_linewidth(MyRenderer *renderer, real linewidth)
-{  
-    DIAG_NOTE(renderer, "set_linewidth %f\n", linewidth);
-
-    renderer->nLineWidth = SC(linewidth);
-}
-
-static void
-set_linecaps(MyRenderer *renderer, LineCaps mode)
-{
-    DIAG_NOTE(renderer, "set_linecaps %d\n", mode);
-
-    switch(mode) {
-    case LINECAPS_BUTT:
-	break;
-    case LINECAPS_ROUND:
-	break;
-    case LINECAPS_PROJECTING:
-	break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_linejoin(MyRenderer *renderer, LineJoin mode)
-{
-    DIAG_NOTE(renderer, "set_join %d\n", mode);
-
-    switch(mode) {
-    case LINEJOIN_MITER:
-	break;
-    case LINEJOIN_ROUND:
-	break;
-    case LINEJOIN_BEVEL:
-	break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_linestyle(MyRenderer *renderer, LineStyle mode)
-{
-    DIAG_NOTE(renderer, "set_linestyle %d\n", mode);
-
-    /* line type */
-    switch (mode) {
-    case LINESTYLE_SOLID:
-      renderer->fnPenStyle = PS_SOLID;
-      break;
-    case LINESTYLE_DASHED:
-      renderer->fnPenStyle = PS_DASH;
-      break;
-    case LINESTYLE_DASH_DOT:
-      renderer->fnPenStyle = PS_DASHDOT;
-      break;
-    case LINESTYLE_DASH_DOT_DOT:
-      renderer->fnPenStyle = PS_DASHDOTDOT;
-      break;
-    case LINESTYLE_DOTTED:
-      renderer->fnPenStyle = PS_DOT;
-      break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_dashlength(MyRenderer *renderer, real length)
-{  
-    DIAG_NOTE(renderer, "set_dashlength %f\n", length);
-
-    /* dot = 20% of len */
-}
-
-static void
-set_fillstyle(MyRenderer *renderer, FillStyle mode)
-{
-    DIAG_NOTE(renderer, "set_fillstyle %d\n", mode);
-
-    switch(mode) {
-    case FILLSTYLE_SOLID:
-	break;
-    default:
-	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-    }
-}
-
-static void
-set_font(MyRenderer *renderer, Font *font, real height)
-{
-    W32::LPCTSTR sFace;
-    W32::DWORD dwItalic = 0;
-    W32::DWORD dwWeight = FW_DONTCARE;
-
-    DIAG_NOTE(renderer, "set_font %s %f\n", font->name, height);
-    if (renderer->hFont)
-	W32::DeleteObject(renderer->hFont);
-
-    /* An ugly hack to map font names. It has to be
-     * changed if Dia's fonts ever get changed.
-     * See: lib/font.c
-     *
-     * Wouldn't it be better to provide this info in
-     * a Font field ?
-     */
-    if (strstr(font->name, "Courier"))
-	sFace = "Courier New";
-    else if (strstr(font->name, "Times"))
-	sFace = "Times New Roman";
-    else
-	sFace = "Arial";
-
-    dwItalic = !!(    strstr(font->name, "Italic") 
-		   || strstr(font->name, "Oblique")); //?
-    if (strstr(font->name, "Bold"))
-	dwWeight = FW_BOLD;
-    else if (strstr(font->name, "Demi"))
-	dwWeight = FW_DEMIBOLD;
-    else if (strstr(font->name, "Light"))
-	dwWeight = FW_LIGHT;
-
-    renderer->hFont = (W32::HFONT)W32::CreateFont( 
-	-(height * WMF_SCALE),  // 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
-	ANSI_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
-draw_line(MyRenderer *renderer, 
-	  Point *start, Point *end, 
-	  Color *line_colour)
-{
-    W32::HGDIOBJ hPen;
-
-    DIAG_NOTE(renderer, "draw_line %f,%f -> %f, %f\n", 
-              start->x, start->y, end->x, end->y);
-
-    hPen = UsePen(renderer, line_colour);
-
-    W32::MoveToEx(renderer->hFileDC, SC(start->x), SC(start->y), NULL);
-    W32::LineTo(renderer->hFileDC, SC(end->x), SC(end->y));
-
-    DonePen(renderer, hPen);
-}
-
-static void
-draw_polyline(MyRenderer *renderer, 
-	      Point *points, int num_points, 
-	      Color *line_colour)
-{
-    W32::HGDIOBJ hPen;
-    W32::POINT*  pts;
-    int	    i;
-
-    DIAG_NOTE(renderer, "draw_polyline n:%d %f,%f ...\n", 
-              num_points, points->x, points->y);
-
-    if (num_points < 2)
-	return;
-    pts = g_new (W32::POINT, num_points+1);
-    for (i = 0; i < num_points; i++)
-    {
-	pts[i].x = SC(points[i].x);
-	pts[i].y = SC(points[i].y);
-    }
-
-    hPen = UsePen(renderer, line_colour);
-    W32::Polyline(renderer->hFileDC, pts, num_points);
-    DonePen(renderer, hPen);
-
-    g_free(pts);
-}
-
-static void
-draw_polygon(MyRenderer *renderer, 
-	     Point *points, int num_points, 
-	     Color *line_colour)
-{
-    W32::HGDIOBJ hPen;
-    W32::POINT*  pts;
-    int	    i;
-
-    DIAG_NOTE(renderer, "draw_polygon n:%d %f,%f ...\n", 
-              num_points, points->x, points->y);
-
-    if (num_points < 2)
-	return;
-    pts = g_new (W32::POINT, num_points+1);
-    for (i = 0; i < num_points; i++)
-    {
-	pts[i].x = SC(points[i].x);
-	pts[i].y = SC(points[i].y);
-    }
-
-    hPen = UsePen(renderer, line_colour);
-
-    W32::Polygon(renderer->hFileDC, pts, num_points);
-
-    DonePen(renderer, hPen);
-
-    g_free(pts);
-}
-
-static void
-fill_polygon(MyRenderer *renderer, 
-	     Point *points, int num_points, 
-	     Color *colour)
-{
-    W32::HBRUSH  hBrush, hBrOld;
-    W32::COLORREF rgb = W32COLOR(colour);
-
-    DIAG_NOTE(renderer, "fill_polygon n:%d %f,%f ...\n", 
-              num_points, points->x, points->y);
-
-    hBrush = W32::CreateSolidBrush(rgb);
-    hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
-
-    draw_polygon(renderer, points, num_points, colour);
-
-    W32::SelectObject(renderer->hFileDC, 
-    W32::GetStockObject (HOLLOW_BRUSH) );
-    W32::DeleteObject(hBrush);
-}
-
-static void
-draw_rect(MyRenderer *renderer, 
-	  Point *ul_corner, Point *lr_corner,
-	  Color *colour)
-{
-  W32::HGDIOBJ hPen;
-
-  DIAG_NOTE(renderer, "draw_rect %f,%f -> %f,%f\n", 
-            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
-
-  hPen = UsePen(renderer, colour);
-
-  W32::Rectangle(renderer->hFileDC,
-  SC(ul_corner->x), SC(ul_corner->y),
-  SC(lr_corner->x), SC(lr_corner->y));
-
-  DonePen(renderer, hPen);
-}
-
-static void
-fill_rect(MyRenderer *renderer, 
-	  Point *ul_corner, Point *lr_corner,
-	  Color *colour)
-{
-  W32::HGDIOBJ hBrush, hBrOld;
-  W32::COLORREF rgb = W32COLOR(colour);
-
-  DIAG_NOTE(renderer, "fill_rect %f,%f -> %f,%f\n", 
-            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
-
-  hBrush = W32::CreateSolidBrush(rgb);
-  hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
-
-  draw_rect(renderer, ul_corner, lr_corner, colour);
-
-  W32::SelectObject(renderer->hFileDC, 
-  W32::GetStockObject (HOLLOW_BRUSH) );
-  W32::DeleteObject(hBrush);
-}
-
-static void
-draw_arc(MyRenderer *renderer, 
-	 Point *center,
-	 real width, real height,
-	 real angle1, real angle2,
-	 Color *colour)
-{
-  W32::HGDIOBJ hPen;
-  W32::POINT ptStart, ptEnd;
-
-  DIAG_NOTE(renderer, "draw_arc %fx%f <%f,<%f @%f,%f\n", 
-            width, height, angle1, angle2, center->x, center->y);
-
-  hPen = UsePen(renderer, colour);
-
-  /* calculate start and end points of arc */
-  ptStart.x = SC(center->x + (width / 2.0)  * cos((M_PI / 180.0) * angle1));
-  ptStart.y = SC(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle1));
-  ptEnd.x = SC(center->x + (width / 2.0)  * cos((M_PI / 180.0) * angle2));
-  ptEnd.y = SC(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle2));
-
-  W32::MoveToEx(renderer->hFileDC, ptStart.x, ptStart.y, NULL);
-  W32::Arc(renderer->hFileDC,
-  SC(center->x - width / 2), /* bbox corners */
-  SC(center->y - height / 2),
-  SC(center->x + width / 2), 
-  SC(center->y + height / 2),
-  ptStart.x, ptStart.y, ptEnd.x, ptEnd.y); 
-
-  DonePen(renderer, hPen);
-}
-
-static void
-fill_arc(MyRenderer *renderer, 
-	 Point *center,
-	 real width, real height,
-	 real angle1, real angle2,
-	 Color *colour)
-{
-  W32::HGDIOBJ hPen;
-
-  DIAG_NOTE(renderer, "fill_arc %fx%f <%f,<%f @%f,%f\n", 
-            width, height, angle1, angle2, center->x, center->y);
-
-  hPen = UsePen(renderer, colour);
-
-  DonePen(renderer, hPen);
-}
-
-static void
-draw_ellipse(MyRenderer *renderer, 
-	     Point *center,
-	     real width, real height,
-	     Color *colour)
-{
-  W32::HGDIOBJ hPen;
-
-  DIAG_NOTE(renderer, "draw_ellipse %fx%f @ %f,%f\n", 
-            width, height, center->x, center->y);
-
-  hPen = UsePen(renderer, colour);
-
-  W32::Ellipse(renderer->hFileDC,
-  SC(center->x - width / 2), /* bbox corners */
-  SC(center->y - height / 2),
-  SC(center->x + width / 2), 
-  SC(center->y + height / 2));
-
-  DonePen(renderer, hPen);
-}
-
-static void
-fill_ellipse(MyRenderer *renderer, 
-	     Point *center,
-	     real width, real height,
-	     Color *colour)
-{
-  W32::HGDIOBJ hPen;
-  W32::HGDIOBJ hBrush, hBrOld;
-  W32::COLORREF rgb = W32COLOR(colour);
-
-  DIAG_NOTE(renderer, "fill_ellipse %fx%f @ %f,%f\n", 
-            width, height, center->x, center->y);
-
-  hBrush = W32::CreateSolidBrush(rgb);
-  hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
-
-  draw_ellipse(renderer, center, width, height, colour);
-
-  W32::SelectObject(renderer->hFileDC, 
-  W32::GetStockObject (HOLLOW_BRUSH) );
-  W32::DeleteObject(hBrush);
-}
-
-static void
-draw_bezier(MyRenderer *renderer, 
-	    BezPoint *points,
-	    int numpoints,
-	    Color *colour)
-{
-  W32::HGDIOBJ hPen;
-  W32::POINT * pts;
-  int i;
-
-  DIAG_NOTE(renderer, "draw_bezier n:%d %fx%f ...\n", 
-            numpoints, points->p1.x, points->p1.y);
-
-  pts = g_new(W32::POINT, (numpoints-1) * 3 + 1);
-
-  pts[0].x = SC(points[0].p1.x);
-  pts[0].y = SC(points[0].p1.y);
-
-  for (i = 1; i < numpoints; i++)
-  {
-    switch(points[i].type)
-    {
-	case _BezPoint::BEZ_MOVE_TO:
-        g_warning("only first BezPoint can be a BEZ_MOVE_TO");
-	  break;
-      case _BezPoint::BEZ_LINE_TO:
-        /* everyhing the same ?*/
-        pts[i*3-2].x = pts[i*3-1].x = 
-        pts[i*3  ].x = SC(points[i].p1.x);
-        pts[i*3-2].y = pts[i*3-1].y = 
-        pts[i*3  ].y = SC(points[i].p1.y);
-        break;
-	case _BezPoint::BEZ_CURVE_TO:
-        /* control points */
-        pts[i*3-2].x = SC(points[i].p1.x);
-        pts[i*3-2].y = SC(points[i].p1.y);
-        pts[i*3-1].x = SC(points[i].p2.x);
-        pts[i*3-1].y = SC(points[i].p2.y);
-        /* end point */
-        pts[i*3  ].x = SC(points[i].p3.x);
-        pts[i*3  ].y = SC(points[i].p3.y);
-	  break;
-	default:
-	  break;
-	}
-    }
-
-    hPen = UsePen(renderer, colour);
-
-    W32::PolyBezier(renderer->hFileDC,
-	pts, (numpoints-1)*3+1);
-
-    DonePen(renderer, hPen);
-
-    g_free(pts);
-}
-
-static void
-fill_bezier(MyRenderer *renderer, 
-	    BezPoint *points, /* Last point must be same as first point */
-	    int numpoints,
-	    Color *colour)
-{
-    W32::HGDIOBJ hPen;
-
-    DIAG_NOTE(renderer, "fill_bezier n:%d %fx%f ...\n", 
-              numpoints, points->p1.x, points->p1.y);
-}
-
-static void
-draw_string(MyRenderer *renderer,
-	    const char *text,
-	    Point *pos, Alignment alignment,
-	    Color *colour)
-{
-    int len;
-    W32::HGDIOBJ hOld;
-
-    DIAG_NOTE(renderer, "draw_string %f,%f %s\n", 
-              pos->x, pos->y, text);
-
-    switch (alignment) {
-    case ALIGN_LEFT:
-	W32::SetTextAlign(renderer->hFileDC, TA_LEFT+TA_BASELINE);
-	break;
-    case ALIGN_CENTER:
-	W32::SetTextAlign(renderer->hFileDC, TA_CENTER+TA_BASELINE);
-	break;
-    case ALIGN_RIGHT:
-	W32::SetTextAlign(renderer->hFileDC, TA_RIGHT+TA_BASELINE);
-	break;
-    }
-    /* work out size of first chunk of text */
-    len = strlen(text);
-
-    hOld = W32::SelectObject(renderer->hFileDC, renderer->hFont);
-    W32::TextOut(renderer->hFileDC,
-	SC(pos->x), SC(pos->y),
-	text, len);
-    W32::SelectObject(renderer->hFileDC, hOld);
-}
-
-static void
-draw_image(MyRenderer *renderer,
-	   Point *point,
-	   real width, real height,
-	   DiaImage image)
-{
-    W32::HBITMAP hBmp;
-    int iWidth, iHeight;
-    unsigned char* pData = NULL;
-
-    DIAG_NOTE(renderer, "draw_image %fx%f @%f,%f\n", 
-              width, height, point->x, point->y);
-
-    iWidth  = dia_image_width(image);
-    iHeight = dia_image_height(image);
-
-    if ((dia_image_width(image)*3) % 4)
-    {
-	/* transform data to be DWORD aligned */
-	int x, y;
-	const unsigned char* pIn = NULL;
-	unsigned char* pOut = NULL;
-
-	pOut = pData = g_new(unsigned char, ((((iWidth*3-1)/4)+1)*4)*iHeight);
-
-	pIn = dia_image_rgb_data(image);
-	for (y = 0; y < iHeight; y++)
-	{
-	    for (x = 0; x < iWidth; x++)
-	    {
-		*pOut++ = *pIn++;
-		*pOut++ = *pIn++;
-		*pOut++ = *pIn++;
-	    }
-	    pOut += (4 - (iWidth*3)%4);
-	}
-
-	hBmp = W32::CreateBitmap ( iWidth, iHeight, 1, 24, pData);
-    }
-    else
-    {
-	hBmp = W32::CreateBitmap ( 
-	    dia_image_width(image), dia_image_height(image),
-	    1, 24, dia_image_rgb_data(image));
-    }
-
-    W32::SelectObject(renderer->hFileDC, hBmp);
-    //Hack to get SRCCOPY out of namespace W32
-#   ifndef DWORD
-#     define DWORD unsigned long
-#   endif
-    W32::BitBlt(renderer->hFileDC, // destination
-	SC(point->x), SC(point->y), SC(width), SC(height),
-	renderer->hFileDC, // source
-	0, 0, SRCCOPY);
-
-    W32::DeleteObject(hBmp);
-    if (pData)
-	g_free(pData);
-}
-
-static void
-export_data(DiagramData *data, const gchar *filename, const gchar *diafilename)
-{
-    MyRenderer *renderer;
-    W32::HDC  file;
-    Rectangle *extent;
-    gint len;
-
-    W32::RECT bbox;
-
-    bbox.top = SC(data->extents.top);
-    bbox.left = SC(data->extents.left);
-    bbox.right = SC(data->extents.right);
-    bbox.bottom = SC(data->extents.bottom);
-
-    file = (W32::HDC)W32::CreateEnhMetaFile( 
-	W32::GetDC(NULL), // handle to a reference device context
-#ifdef SAVE_EMF
-	filename,   // pointer to a filename string
-#else
-      NULL, // in memory
-#endif
-	&bbox,	    // pointer to a bounding rectangle
-	"Dia\0Diagram\0"); // pointer to an optional description string 
-
-    if (file == NULL) {
-	message_error(_("Couldn't open: '%s' for writing.\n"), filename);
-	return;
-    }
-
-    renderer = g_new(MyRenderer, 1);
-    renderer->renderer.ops = &MyRenderOps;
-    renderer->renderer.is_interactive = 0;
-    renderer->renderer.interactive_ops = NULL;
-
-    renderer->hFileDC = file;
-    renderer->sFileName = g_strdup(filename);
-
-    extent = &data->extents;
-
-    /* write extents */
-    DIAG_NOTE(renderer, "export_data extents %f,%f -> %f,%f\n", 
-              extent->left, extent->top, extent->right, extent->bottom);
-
-
-    data_render(data, (Renderer *)renderer, NULL, NULL, NULL);
-
-    g_free(renderer);
-}
-
-static const gchar *extensions[] = { "wmf", NULL };
-static DiaExportFilter my_export_filter = {
-    N_("Windows Meta File"),
-    extensions,
-    export_data
-};
-
-
-/* --- dia plug-in interface --- */
-
-DIA_PLUGIN_CHECK_INIT
-
-PluginInitResult
-dia_plugin_init(PluginInfo *info)
-{
-    if (!dia_plugin_info_init(info, "WMF",
-			      _("WMF export filter"),
-			      NULL, NULL))
-	return DIA_PLUGIN_INIT_ERROR;
-
-    filter_register_export(&my_export_filter);
-
-    return DIA_PLUGIN_INIT_OK;
-}
+/* Dia -- an diagram creation/manipulation program
+ * Copyright (C) 1998 Alexander Larsson
+ *
+ * wmf.cpp -- Windows Metafile export plugin for dia
+ * Copyright (C) 2000, Hans Breuer, <[e-mail]>
+ *   based on dummy plug-in. 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "config.h"
+#include "intl.h"
+#include "message.h"
+#include "geometry.h"
+#include "render.h"
+#include "filter.h"
+#include "plug-ins.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+namespace W32 {
+// at least Rectangle conflicts ...
+#include <windows.h>
+}
+
+/* force linking with gdi32 */
+#pragma comment( lib, "gdi32" )
+ 
+
+// #define SAVE_EMF
+
+/* --- the renderer --- */
+#define MY_RENDERER_NAME "WMF"
+
+typedef struct _MyRenderer MyRenderer;
+struct _MyRenderer {
+    Renderer renderer;
+
+    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::HFONT hFont;
+};
+
+/* include function declares and render object "vtable" */
+#include "../renderer.inc"
+
+/*
+ * helper macros
+ */
+#define W32COLOR(c) \
+	 0xff * c->red + \
+	((unsigned char)(0xff * c->green)) * 256 + \
+	((unsigned char)(0xff * c->blue)) * 65536;
+
+#define WMF_SCALE 100.0
+#define SC(a) ((a)*WMF_SCALE)
+
+/*
+ * helper functions
+ */
+static W32::HGDIOBJ
+UsePen(MyRenderer* renderer, Color* colour)
+{
+    W32::HPEN hOldPen;
+    W32::COLORREF rgb = W32COLOR(colour);
+
+    renderer->hPen = W32::CreatePen( renderer->fnPenStyle, 
+						 renderer->nLineWidth,
+						 rgb);
+    hOldPen = W32::SelectObject(renderer->hFileDC, renderer->hPen);
+    return hOldPen;
+}
+
+static void
+DonePen(MyRenderer* renderer, W32::HPEN hPen)
+{
+    /* restore the OLD one ... */
+    if (hPen) W32::SelectObject(renderer->hFileDC, hPen);
+    /* ... before deleting the last active */
+    if (renderer->hPen)
+    {
+	W32::DeleteObject(renderer->hPen);
+	renderer->hPen = NULL;
+    }
+}
+
+#define DIAG_NOTE my_log
+void
+my_log(MyRenderer* renderer, char* format, ...)
+{
+    gchar *string;
+    va_list args;
+  
+    g_return_if_fail (format != NULL);
+  
+    va_start (args, format);
+    string = g_strdup_vprintf (format, args);
+    va_end (args);
+
+    //fprintf(renderer->file, string);
+    g_print(string);
+
+    g_free(string);
+}
+ 
+/*
+ * renderer interface implementation
+ */
+static void
+begin_render(MyRenderer *renderer, DiagramData *data)
+{
+    DIAG_NOTE(renderer, "begin_render\n");
+
+    /* make unfilled the default */
+    W32::SelectObject(renderer->hFileDC, 
+	W32::GetStockObject (HOLLOW_BRUSH) );
+}
+
+static void
+end_render(MyRenderer *renderer)
+{
+    W32::HENHMETAFILE hEmf;
+    W32::UINT nSize;
+    W32::BYTE* pData = NULL;
+    FILE* f;
+
+    DIAG_NOTE(renderer, "end_render\n");
+    hEmf = W32::CloseEnhMetaFile(renderer->hFileDC);
+
+#ifndef SAVE_EMF
+    /* get size */
+    nSize = W32::GetWinMetaFileBits(hEmf, 0, NULL, MM_ANISOTROPIC, W32::GetDC(NULL));
+    pData = g_new(W32::BYTE, nSize);
+    /* get data */
+    nSize = W32::GetWinMetaFileBits(hEmf, nSize, pData, MM_ANISOTROPIC, W32::GetDC(NULL));
+
+    /* write file */
+    f = fopen(renderer->sFileName, "wb");
+    fwrite(pData,1,nSize,f);
+    fclose(f);
+    
+    g_free(pData);
+#endif
+    g_free(renderer->sFileName);
+
+    if (hEmf)
+	W32::DeleteEnhMetaFile(hEmf);
+    if (renderer->hFont)
+	W32::DeleteObject(renderer->hFont);
+}
+
+static void
+set_linewidth(MyRenderer *renderer, real linewidth)
+{  
+    DIAG_NOTE(renderer, "set_linewidth %f\n", linewidth);
+
+    renderer->nLineWidth = SC(linewidth);
+}
+
+static void
+set_linecaps(MyRenderer *renderer, LineCaps mode)
+{
+    DIAG_NOTE(renderer, "set_linecaps %d\n", mode);
+
+    switch(mode) {
+    case LINECAPS_BUTT:
+	break;
+    case LINECAPS_ROUND:
+	break;
+    case LINECAPS_PROJECTING:
+	break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_linejoin(MyRenderer *renderer, LineJoin mode)
+{
+    DIAG_NOTE(renderer, "set_join %d\n", mode);
+
+    switch(mode) {
+    case LINEJOIN_MITER:
+	break;
+    case LINEJOIN_ROUND:
+	break;
+    case LINEJOIN_BEVEL:
+	break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_linestyle(MyRenderer *renderer, LineStyle mode)
+{
+    DIAG_NOTE(renderer, "set_linestyle %d\n", mode);
+
+    /* line type */
+    switch (mode) {
+    case LINESTYLE_SOLID:
+      renderer->fnPenStyle = PS_SOLID;
+      break;
+    case LINESTYLE_DASHED:
+      renderer->fnPenStyle = PS_DASH;
+      break;
+    case LINESTYLE_DASH_DOT:
+      renderer->fnPenStyle = PS_DASHDOT;
+      break;
+    case LINESTYLE_DASH_DOT_DOT:
+      renderer->fnPenStyle = PS_DASHDOTDOT;
+      break;
+    case LINESTYLE_DOTTED:
+      renderer->fnPenStyle = PS_DOT;
+      break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_dashlength(MyRenderer *renderer, real length)
+{  
+    DIAG_NOTE(renderer, "set_dashlength %f\n", length);
+
+    /* dot = 20% of len */
+}
+
+static void
+set_fillstyle(MyRenderer *renderer, FillStyle mode)
+{
+    DIAG_NOTE(renderer, "set_fillstyle %d\n", mode);
+
+    switch(mode) {
+    case FILLSTYLE_SOLID:
+	break;
+    default:
+	message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+    }
+}
+
+static void
+set_font(MyRenderer *renderer, Font *font, real height)
+{
+    W32::LPCTSTR sFace;
+    W32::DWORD dwItalic = 0;
+    W32::DWORD dwWeight = FW_DONTCARE;
+
+    DIAG_NOTE(renderer, "set_font %s %f\n", font->name, height);
+    if (renderer->hFont)
+	W32::DeleteObject(renderer->hFont);
+
+    /* An ugly hack to map font names. It has to be
+     * changed if Dia's fonts ever get changed.
+     * See: lib/font.c
+     *
+     * Wouldn't it be better to provide this info in
+     * a Font field ?
+     */
+    if (strstr(font->name, "Courier"))
+	sFace = "Courier New";
+    else if (strstr(font->name, "Times"))
+	sFace = "Times New Roman";
+    else
+	sFace = "Arial";
+
+    dwItalic = !!(    strstr(font->name, "Italic") 
+		   || strstr(font->name, "Oblique")); //?
+    if (strstr(font->name, "Bold"))
+	dwWeight = FW_BOLD;
+    else if (strstr(font->name, "Demi"))
+	dwWeight = FW_DEMIBOLD;
+    else if (strstr(font->name, "Light"))
+	dwWeight = FW_LIGHT;
+
+    renderer->hFont = (W32::HFONT)W32::CreateFont( 
+	-(height * WMF_SCALE),  // 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
+	ANSI_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
+draw_line(MyRenderer *renderer, 
+	  Point *start, Point *end, 
+	  Color *line_colour)
+{
+    W32::HGDIOBJ hPen;
+
+    DIAG_NOTE(renderer, "draw_line %f,%f -> %f, %f\n", 
+              start->x, start->y, end->x, end->y);
+
+    hPen = UsePen(renderer, line_colour);
+
+    W32::MoveToEx(renderer->hFileDC, SC(start->x), SC(start->y), NULL);
+    W32::LineTo(renderer->hFileDC, SC(end->x), SC(end->y));
+
+    DonePen(renderer, hPen);
+}
+
+static void
+draw_polyline(MyRenderer *renderer, 
+	      Point *points, int num_points, 
+	      Color *line_colour)
+{
+    W32::HGDIOBJ hPen;
+    W32::POINT*  pts;
+    int	    i;
+
+    DIAG_NOTE(renderer, "draw_polyline n:%d %f,%f ...\n", 
+              num_points, points->x, points->y);
+
+    if (num_points < 2)
+	return;
+    pts = g_new (W32::POINT, num_points+1);
+    for (i = 0; i < num_points; i++)
+    {
+	pts[i].x = SC(points[i].x);
+	pts[i].y = SC(points[i].y);
+    }
+
+    hPen = UsePen(renderer, line_colour);
+    W32::Polyline(renderer->hFileDC, pts, num_points);
+    DonePen(renderer, hPen);
+
+    g_free(pts);
+}
+
+static void
+draw_polygon(MyRenderer *renderer, 
+	     Point *points, int num_points, 
+	     Color *line_colour)
+{
+    W32::HGDIOBJ hPen;
+    W32::POINT*  pts;
+    int	    i;
+
+    DIAG_NOTE(renderer, "draw_polygon n:%d %f,%f ...\n", 
+              num_points, points->x, points->y);
+
+    if (num_points < 2)
+	return;
+    pts = g_new (W32::POINT, num_points+1);
+    for (i = 0; i < num_points; i++)
+    {
+	pts[i].x = SC(points[i].x);
+	pts[i].y = SC(points[i].y);
+    }
+
+    hPen = UsePen(renderer, line_colour);
+
+    W32::Polygon(renderer->hFileDC, pts, num_points);
+
+    DonePen(renderer, hPen);
+
+    g_free(pts);
+}
+
+static void
+fill_polygon(MyRenderer *renderer, 
+	     Point *points, int num_points, 
+	     Color *colour)
+{
+    W32::HBRUSH  hBrush, hBrOld;
+    W32::COLORREF rgb = W32COLOR(colour);
+
+    DIAG_NOTE(renderer, "fill_polygon n:%d %f,%f ...\n", 
+              num_points, points->x, points->y);
+
+    hBrush = W32::CreateSolidBrush(rgb);
+    hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
+
+    draw_polygon(renderer, points, num_points, colour);
+
+    W32::SelectObject(renderer->hFileDC, 
+    W32::GetStockObject (HOLLOW_BRUSH) );
+    W32::DeleteObject(hBrush);
+}
+
+static void
+draw_rect(MyRenderer *renderer, 
+	  Point *ul_corner, Point *lr_corner,
+	  Color *colour)
+{
+  W32::HGDIOBJ hPen;
+
+  DIAG_NOTE(renderer, "draw_rect %f,%f -> %f,%f\n", 
+            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
+
+  hPen = UsePen(renderer, colour);
+
+  W32::Rectangle(renderer->hFileDC,
+  SC(ul_corner->x), SC(ul_corner->y),
+  SC(lr_corner->x), SC(lr_corner->y));
+
+  DonePen(renderer, hPen);
+}
+
+static void
+fill_rect(MyRenderer *renderer, 
+	  Point *ul_corner, Point *lr_corner,
+	  Color *colour)
+{
+  W32::HGDIOBJ hBrush, hBrOld;
+  W32::COLORREF rgb = W32COLOR(colour);
+
+  DIAG_NOTE(renderer, "fill_rect %f,%f -> %f,%f\n", 
+            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
+
+  hBrush = W32::CreateSolidBrush(rgb);
+  hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
+
+  draw_rect(renderer, ul_corner, lr_corner, colour);
+
+  W32::SelectObject(renderer->hFileDC, 
+  W32::GetStockObject (HOLLOW_BRUSH) );
+  W32::DeleteObject(hBrush);
+}
+
+static void
+draw_arc(MyRenderer *renderer, 
+	 Point *center,
+	 real width, real height,
+	 real angle1, real angle2,
+	 Color *colour)
+{
+  W32::HGDIOBJ hPen;
+  W32::POINT ptStart, ptEnd;
+
+  DIAG_NOTE(renderer, "draw_arc %fx%f <%f,<%f @%f,%f\n", 
+            width, height, angle1, angle2, center->x, center->y);
+
+  hPen = UsePen(renderer, colour);
+
+  /* calculate start and end points of arc */
+  ptStart.x = SC(center->x + (width / 2.0)  * cos((M_PI / 180.0) * angle1));
+  ptStart.y = SC(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle1));
+  ptEnd.x = SC(center->x + (width / 2.0)  * cos((M_PI / 180.0) * angle2));
+  ptEnd.y = SC(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle2));
+
+  W32::MoveToEx(renderer->hFileDC, ptStart.x, ptStart.y, NULL);
+  W32::Arc(renderer->hFileDC,
+  SC(center->x - width / 2), /* bbox corners */
+  SC(center->y - height / 2),
+  SC(center->x + width / 2), 
+  SC(center->y + height / 2),
+  ptStart.x, ptStart.y, ptEnd.x, ptEnd.y); 
+
+  DonePen(renderer, hPen);
+}
+
+static void
+fill_arc(MyRenderer *renderer, 
+	 Point *center,
+	 real width, real height,
+	 real angle1, real angle2,
+	 Color *colour)
+{
+  W32::HGDIOBJ hPen;
+
+  DIAG_NOTE(renderer, "fill_arc %fx%f <%f,<%f @%f,%f\n", 
+            width, height, angle1, angle2, center->x, center->y);
+
+  hPen = UsePen(renderer, colour);
+
+  DonePen(renderer, hPen);
+}
+
+static void
+draw_ellipse(MyRenderer *renderer, 
+	     Point *center,
+	     real width, real height,
+	     Color *colour)
+{
+  W32::HGDIOBJ hPen;
+
+  DIAG_NOTE(renderer, "draw_ellipse %fx%f @ %f,%f\n", 
+            width, height, center->x, center->y);
+
+  hPen = UsePen(renderer, colour);
+
+  W32::Ellipse(renderer->hFileDC,
+  SC(center->x - width / 2), /* bbox corners */
+  SC(center->y - height / 2),
+  SC(center->x + width / 2), 
+  SC(center->y + height / 2));
+
+  DonePen(renderer, hPen);
+}
+
+static void
+fill_ellipse(MyRenderer *renderer, 
+	     Point *center,
+	     real width, real height,
+	     Color *colour)
+{
+  W32::HGDIOBJ hPen;
+  W32::HGDIOBJ hBrush, hBrOld;
+  W32::COLORREF rgb = W32COLOR(colour);
+
+  DIAG_NOTE(renderer, "fill_ellipse %fx%f @ %f,%f\n", 
+            width, height, center->x, center->y);
+
+  hBrush = W32::CreateSolidBrush(rgb);
+  hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
+
+  draw_ellipse(renderer, center, width, height, colour);
+
+  W32::SelectObject(renderer->hFileDC, 
+  W32::GetStockObject (HOLLOW_BRUSH) );
+  W32::DeleteObject(hBrush);
+}
+
+static void
+draw_bezier(MyRenderer *renderer, 
+	    BezPoint *points,
+	    int numpoints,
+	    Color *colour)
+{
+  W32::HGDIOBJ hPen;
+  W32::POINT * pts;
+  int i;
+
+  DIAG_NOTE(renderer, "draw_bezier n:%d %fx%f ...\n", 
+            numpoints, points->p1.x, points->p1.y);
+
+  pts = g_new(W32::POINT, (numpoints-1) * 3 + 1);
+
+  pts[0].x = SC(points[0].p1.x);
+  pts[0].y = SC(points[0].p1.y);
+
+  for (i = 1; i < numpoints; i++)
+  {
+    switch(points[i].type)
+    {
+	case _BezPoint::BEZ_MOVE_TO:
+        g_warning("only first BezPoint can be a BEZ_MOVE_TO");
+	  break;
+      case _BezPoint::BEZ_LINE_TO:
+        /* everyhing the same ?*/
+        pts[i*3-2].x = pts[i*3-1].x = 
+        pts[i*3  ].x = SC(points[i].p1.x);
+        pts[i*3-2].y = pts[i*3-1].y = 
+        pts[i*3  ].y = SC(points[i].p1.y);
+        break;
+	case _BezPoint::BEZ_CURVE_TO:
+        /* control points */
+        pts[i*3-2].x = SC(points[i].p1.x);
+        pts[i*3-2].y = SC(points[i].p1.y);
+        pts[i*3-1].x = SC(points[i].p2.x);
+        pts[i*3-1].y = SC(points[i].p2.y);
+        /* end point */
+        pts[i*3  ].x = SC(points[i].p3.x);
+        pts[i*3  ].y = SC(points[i].p3.y);
+	  break;
+	default:
+	  break;
+	}
+    }
+
+    hPen = UsePen(renderer, colour);
+
+    W32::PolyBezier(renderer->hFileDC,
+	pts, (numpoints-1)*3+1);
+
+    DonePen(renderer, hPen);
+
+    g_free(pts);
+}
+
+static void
+fill_bezier(MyRenderer *renderer, 
+	    BezPoint *points, /* Last point must be same as first point */
+	    int numpoints,
+	    Color *colour)
+{
+    W32::HGDIOBJ hPen;
+
+    DIAG_NOTE(renderer, "fill_bezier n:%d %fx%f ...\n", 
+              numpoints, points->p1.x, points->p1.y);
+}
+
+static void
+draw_string(MyRenderer *renderer,
+	    const char *text,
+	    Point *pos, Alignment alignment,
+	    Color *colour)
+{
+    int len;
+    W32::HGDIOBJ hOld;
+
+    DIAG_NOTE(renderer, "draw_string %f,%f %s\n", 
+              pos->x, pos->y, text);
+
+    switch (alignment) {
+    case ALIGN_LEFT:
+	W32::SetTextAlign(renderer->hFileDC, TA_LEFT+TA_BASELINE);
+	break;
+    case ALIGN_CENTER:
+	W32::SetTextAlign(renderer->hFileDC, TA_CENTER+TA_BASELINE);
+	break;
+    case ALIGN_RIGHT:
+	W32::SetTextAlign(renderer->hFileDC, TA_RIGHT+TA_BASELINE);
+	break;
+    }
+    /* work out size of first chunk of text */
+    len = strlen(text);
+
+    hOld = W32::SelectObject(renderer->hFileDC, renderer->hFont);
+    W32::TextOut(renderer->hFileDC,
+	SC(pos->x), SC(pos->y),
+	text, len);
+    W32::SelectObject(renderer->hFileDC, hOld);
+}
+
+static void
+draw_image(MyRenderer *renderer,
+	   Point *point,
+	   real width, real height,
+	   DiaImage image)
+{
+    W32::HBITMAP hBmp;
+    int iWidth, iHeight;
+    unsigned char* pData = NULL;
+
+    DIAG_NOTE(renderer, "draw_image %fx%f @%f,%f\n", 
+              width, height, point->x, point->y);
+
+    iWidth  = dia_image_width(image);
+    iHeight = dia_image_height(image);
+
+    if ((dia_image_width(image)*3) % 4)
+    {
+	/* transform data to be DWORD aligned */
+	int x, y;
+	const unsigned char* pIn = NULL;
+	unsigned char* pOut = NULL;
+
+	pOut = pData = g_new(unsigned char, ((((iWidth*3-1)/4)+1)*4)*iHeight);
+
+	pIn = dia_image_rgb_data(image);
+	for (y = 0; y < iHeight; y++)
+	{
+	    for (x = 0; x < iWidth; x++)
+	    {
+		*pOut++ = *pIn++;
+		*pOut++ = *pIn++;
+		*pOut++ = *pIn++;
+	    }
+	    pOut += (4 - (iWidth*3)%4);
+	}
+
+	hBmp = W32::CreateBitmap ( iWidth, iHeight, 1, 24, pData);
+    }
+    else
+    {
+	hBmp = W32::CreateBitmap ( 
+	    dia_image_width(image), dia_image_height(image),
+	    1, 24, dia_image_rgb_data(image));
+    }
+
+    W32::SelectObject(renderer->hFileDC, hBmp);
+    //Hack to get SRCCOPY out of namespace W32
+#   ifndef DWORD
+#     define DWORD unsigned long
+#   endif
+    W32::BitBlt(renderer->hFileDC, // destination
+	SC(point->x), SC(point->y), SC(width), SC(height),
+	renderer->hFileDC, // source
+	0, 0, SRCCOPY);
+
+    W32::DeleteObject(hBmp);
+    if (pData)
+	g_free(pData);
+}
+
+static void
+export_data(DiagramData *data, const gchar *filename, const gchar *diafilename)
+{
+    MyRenderer *renderer;
+    W32::HDC  file;
+    Rectangle *extent;
+    gint len;
+
+    W32::RECT bbox;
+
+    bbox.top = SC(data->extents.top);
+    bbox.left = SC(data->extents.left);
+    bbox.right = SC(data->extents.right);
+    bbox.bottom = SC(data->extents.bottom);
+
+    file = (W32::HDC)W32::CreateEnhMetaFile( 
+	W32::GetDC(NULL), // handle to a reference device context
+#ifdef SAVE_EMF
+	filename,   // pointer to a filename string
+#else
+      NULL, // in memory
+#endif
+	&bbox,	    // pointer to a bounding rectangle
+	"Dia\0Diagram\0"); // pointer to an optional description string 
+
+    if (file == NULL) {
+	message_error(_("Couldn't open: '%s' for writing.\n"), filename);
+	return;
+    }
+
+    renderer = g_new(MyRenderer, 1);
+    renderer->renderer.ops = &MyRenderOps;
+    renderer->renderer.is_interactive = 0;
+    renderer->renderer.interactive_ops = NULL;
+
+    renderer->hFileDC = file;
+    renderer->sFileName = g_strdup(filename);
+
+    extent = &data->extents;
+
+    /* write extents */
+    DIAG_NOTE(renderer, "export_data extents %f,%f -> %f,%f\n", 
+              extent->left, extent->top, extent->right, extent->bottom);
+
+
+    data_render(data, (Renderer *)renderer, NULL, NULL, NULL);
+
+    g_free(renderer);
+}
+
+static const gchar *extensions[] = { "wmf", NULL };
+static DiaExportFilter my_export_filter = {
+    N_("Windows Meta File"),
+    extensions,
+    export_data
+};
+
+
+/* --- dia plug-in interface --- */
+
+DIA_PLUGIN_CHECK_INIT
+
+PluginInitResult
+dia_plugin_init(PluginInfo *info)
+{
+    if (!dia_plugin_info_init(info, "WMF",
+			      _("WMF export filter"),
+			      NULL, NULL))
+	return DIA_PLUGIN_INIT_ERROR;
+
+    filter_register_export(&my_export_filter);
+
+    return DIA_PLUGIN_INIT_OK;
+}

--- /dev/null
+++ b/plug-ins/wpg/.cvsignore
@@ -0,0 +1,9 @@
+.cvsignore
+.deps
+.libs
+Makefile
+Makefile.in
+*.lo
+*.la
+*.pyc
+

--- /dev/null
+++ b/plug-ins/wpg/Makefile.am
@@ -0,0 +1,8 @@
+pkglib_LTLIBRARIES = libwpg_filter.la
+
+libwpg_filter_la_SOURCES = wpg.c wpg_defs.h
+libwpg_filter_la_LDFLAGS = -export-dynamic -module -avoid-version
+libwpg_filter_la_LIBADD = $(GTK_LIBS)
+
+INCLUDES = -I$(top_srcdir)/intl -I$(top_srcdir)/lib \
+  $(GTK_CFLAGS) $(GNOME_CFLAGS)

--- a/plug-ins/wpg/wpg.c
+++ b/plug-ins/wpg/wpg.c
@@ -1,1202 +1,1202 @@
-/* Dia -- an diagram creation/manipulation program
- * Copyright (C) 1998 Alexander Larsson
- *
- * wpg.c -- HPGL export plugin for dia
- * Copyright (C) 2000, Hans Breuer, <[e-mail]>
- *   based on dummy.c 
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-
-/*
- * ToDo:
- * - if helper points - like arc centers - are not in Dia's extent box
- *   their clipping produces unpredictable results 
- * - the font setting needs improvement (maybe on Dia's side)
- * - bezier curves are not correctly converted to WPG's poly curve
- *   (two point beziers are)
- *
- * MayBe:
- * - full featured import (IMO Dia's import support should be improved
- *   before / on the way ...)
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-#include <glib.h>
-
-#include "config.h"
-#include "intl.h"
-#include "message.h"
-#include "geometry.h"
-#include "render.h"
-#include "filter.h"
-#include "plug-ins.h"
-
-/* format specific */
-#include "wpg_defs.h"
-
-/* Import is not yet finished but only implemented to check the
- * export capabilities and to investigate other programs WPG
- * formats. 
- * The following is not the reason for <en/dis>abling import, 
- * but it should do it for now ...
- */
-#define WPG_WITH_IMPORT defined (_MSC_VER)
-
-/*
- * helper macros
- */
-#define SC(a) ((a) * renderer->Scale)
-
-/* --- the renderer --- */
-#define MY_RENDERER_NAME "WPG"
-
-typedef struct _MyRenderer MyRenderer;
-struct _MyRenderer {
-  Renderer renderer;
-
-  FILE *file;
-
-  real Scale;
-
-  real dash_length;
-
-  WPGStartData Box;
-  WPGFillAttr  FillAttr;
-  WPGLineAttr  LineAttr;
-  WPGTextStyle TextStyle;
-
-  WPGColorRGB* pPal;
-};
-
-/* include function declares and render object "vtable" */
-#include "../renderer.inc"
-
-#define DIAG_NOTE my_log /* */
-void
-my_log(MyRenderer* renderer, char* format, ...)
-{
-    gchar *string;
-    va_list args;
-  
-    g_return_if_fail (format != NULL);
-  
-    va_start (args, format);
-    string = g_strdup_vprintf (format, args);
-    va_end (args);
-
-    g_print(string);
-
-    g_free(string);
-}
-
-#if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
-/* shortcut if testing of indirection isn't needed anymore */
-#pragma message("LITTLE_ENDIAN: disabling fwrite_le")
-#define fwrite_le(a,b,c,d) fwrite(a,b,c,d)
-#else
-static size_t
-fwrite_le(void* buf, size_t size, size_t count, FILE* f)
-{
-  size_t n = 0;
-  guint i;
-
-  g_assert((1 == size) || (2 == size) || (4 == size));
-
-  if (4 == size)
-  {
-    gint32 i32;
-
-    for (i = 0; i < count; i++)
-    {
-      i32 = GINT32_TO_LE(((gint32*)buf)[i]);
-      n += fwrite(&i32, sizeof(gint32), 1, f);
-    }
-  }
-  else if (2 == size)
-  {
-    gint16 i16;
-
-    for (i = 0; i < count; i++)
-    {
-      i16 = GINT16_TO_LE(((gint16*)buf)[i]);
-      n += fwrite(&i16, sizeof(gint16), 1, f);
-    }
-  }
-  else
-    n = fwrite(buf, size, count, f);
-
-  return n;
-}
-#endif
-
-/* 
- * color cube len, WPG is limited to 256 colors. To get simple
- * color reduction algorithms only 216 = 6^3 of them are used.
- */
-#define CC_LEN 6
-
-/*
- * "To avoid problems with WPC products the first 16 colors of
- *  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
- * start color).
- */
-#define WPG_NUM_DEF_COLORS 0 /* 16 */
-
-/* 
- * helper functions 
- */
-guint8
-LookupColor(MyRenderer *renderer, Color* colour)
-{
-  /* find nearest color in the renderers color map */
-  /* 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
-                  + (int)floor(colour->blue * (CC_LEN - 1)) * CC_LEN  * CC_LEN;
-  DIAG_NOTE(renderer, "LookupColor %d.\n", i);
-  if (i >= CC_LEN * CC_LEN * CC_LEN)
-    return CC_LEN * CC_LEN * CC_LEN - 1 + WPG_NUM_DEF_COLORS;
-  else 
-    return i + WPG_NUM_DEF_COLORS;
-}
-
-void
-WriteRecHead(MyRenderer *renderer, WPG_Type Type, guint32 Size)
-{
-  if (Size < 255)
-  {
-    WPGHead8 rh;
-    rh.Type = (guint8)Type;
-    rh.Size = (guint8)Size;
-    fwrite(&rh, sizeof(guint8), 2, renderer->file);
-  }
-  else if (Size < 32768)
-  {
-    WPGHead16 rh;
-    rh.Type  = (guint8)Type;
-    rh.Dummy = 0xFF;
-    rh.Size  = (guint16)Size;
-    fwrite(&rh, sizeof(guint8), 2, renderer->file);
-    fwrite_le(&(rh.Size), sizeof(guint16), 1, renderer->file);
-  }
-  else
-  {
-    WPGHead32 rh;
-    rh.Type  = (guint8)Type;
-    rh.Dummy = 0xFF;
-    rh.Size  = Size;
-
-    /* To avoid problems with stucture packing this struct
-     * is written in parts ...
-     */
-    fwrite(&rh, sizeof(guint8), 2, renderer->file);
-    fwrite_le(&rh.Size, sizeof(guint32), 1, renderer->file);
-  }
-}
-
-void
-WriteLineAttr(MyRenderer *renderer, Color* colour)
-{
-  g_assert(4 == sizeof(WPGLineAttr));
-
-  WriteRecHead(renderer, WPG_LINEATTR, sizeof(WPGLineAttr));
-  renderer->LineAttr.Color = LookupColor(renderer, colour);
-  fwrite(&renderer->LineAttr, sizeof(guint8), 2, renderer->file);
-  fwrite_le(&renderer->LineAttr.Width, sizeof(guint16), 1, renderer->file);
-}
-
-void
-WriteFillAttr(MyRenderer *renderer, Color* colour, gboolean bFill)
-{
-  g_assert(2 == sizeof(WPGFillAttr));
-
-  WriteRecHead(renderer, WPG_FILLATTR, sizeof(WPGFillAttr));
-  if (bFill)
-  {
-    renderer->FillAttr.Color = LookupColor(renderer, colour);
-    fwrite(&renderer->FillAttr, sizeof(WPGFillAttr), 1, renderer->file);
-  }
-  else
-  {
-    WPGFillAttr fa;
-    fa.Color = LookupColor(renderer, colour);
-    fa.Type = WPG_FA_HOLLOW;
-    fwrite(&fa, sizeof(WPGFillAttr), 1, renderer->file);
-  }
-}
-
-/* 
- * render functions 
- */ 
-static void
-begin_render(MyRenderer *renderer, DiagramData *data)
-{
-#if 0
-  const WPGFileHead wpgFileHead = { "\377WPC", 16, 
-                                   1, 22,
-                                   1, 0, /* Version */ 
-                                   0, 0};
-#else
-  /* static conversion to little endian */
-  const char wpgFileHead[16] = {255, 'W', 'P', 'C', 16, 0, 0, 0, 
-                                1, 22, 1, 0, 0, 0, 0, 0};
-#endif
-
-  gint16 i;
-  guint8* pPal;
-  Color color = {1, 1, 1};
-
-  DIAG_NOTE(renderer, "begin_render\n");
-
-  fwrite(&wpgFileHead, 1, 16, renderer->file);
-
-  /* bounding box */
-  WriteRecHead(renderer, WPG_START, sizeof(WPGStartData));
-#if 0
-  fwrite(&renderer->Box, sizeof(WPGStartData), 1, renderer->file);
-#else
-  g_assert(6 == sizeof(WPGStartData));
-  fwrite(&renderer->Box, sizeof(guint8), 2, renderer->file);
-  fwrite_le(&renderer->Box.Width, sizeof(guint16), 2, renderer->file);
-#endif
-  /* initialize a well known colormap, see LookupColor */
-  pPal = g_new(gint8, CC_LEN*CC_LEN*CC_LEN*3);
-  for (i = 0; i < CC_LEN * CC_LEN * CC_LEN; i++)
-  {
-    pPal[3*i  ] = ((i % CC_LEN) * 255) / (CC_LEN - 1);   /* red */
-    pPal[3*i+1] = (((i / CC_LEN) % CC_LEN) * 255) / (CC_LEN - 1); /* green */
-    pPal[3*i+2] = ((i / (CC_LEN * CC_LEN)) * 255) / (CC_LEN - 1); /* blue varies least */
-    /*
-    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 */
-  fwrite_le(&i, sizeof(gint16), 1, renderer->file);
-  i = CC_LEN*CC_LEN*CC_LEN;
-  fwrite_le(&i, sizeof(gint16), 1, renderer->file);
-  fwrite(pPal, 1, CC_LEN*CC_LEN*CC_LEN*3, renderer->file);
-
-  /* FIXME: following 3 lines needed to make filling work !? */
-  renderer->FillAttr.Type = WPG_FA_SOLID;
-  WriteFillAttr(renderer, &color, TRUE);
-  WriteFillAttr(renderer, &color, FALSE);
-
-  g_free(pPal);
-}
-
-static void
-end_render(MyRenderer *renderer)
-{
-  DIAG_NOTE(renderer, "end_render\n");
-
-  WriteRecHead(renderer, WPG_END, 0); /* no data following */
-  fclose(renderer->file);
-}
-
-static void
-set_linewidth(MyRenderer *renderer, real linewidth)
-{  
-  DIAG_NOTE(renderer, "set_linewidth %f\n", linewidth);
-
-  renderer->LineAttr.Width = SC(linewidth);
-}
-
-static void
-set_linecaps(MyRenderer *renderer, LineCaps mode)
-{
-  DIAG_NOTE(renderer, "set_linecaps %d\n", mode);
-
-  switch(mode) {
-  case LINECAPS_BUTT:
-    break;
-  case LINECAPS_ROUND:
-    break;
-  case LINECAPS_PROJECTING:
-    break;
-  default:
-    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-  }
-}
-
-static void
-set_linejoin(MyRenderer *renderer, LineJoin mode)
-{
-  DIAG_NOTE(renderer, "set_join %d\n", mode);
-
-  switch(mode) {
-  case LINEJOIN_MITER:
-    break;
-  case LINEJOIN_ROUND:
-    break;
-  case LINEJOIN_BEVEL:
-    break;
-  default:
-    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-  }
-}
-
-static void
-set_linestyle(MyRenderer *renderer, LineStyle mode)
-{
-  DIAG_NOTE(renderer, "set_linestyle %d\n", mode);
-
-  /* line type */
-  switch (mode) {
-  case LINESTYLE_SOLID:
-    renderer->LineAttr.Type = WPG_LA_SOLID;
-    break;
-  case LINESTYLE_DASHED:
-    if (renderer->dash_length < 0.5)
-      renderer->LineAttr.Type = WPG_LA_SHORTDASH;
-    else
-      renderer->LineAttr.Type = WPG_LA_MEDIUMDASH;
-    break;
-  case LINESTYLE_DASH_DOT:
-    renderer->LineAttr.Type = WPG_LA_DASHDOT;
-    break;
-  case LINESTYLE_DASH_DOT_DOT:
-    renderer->LineAttr.Type = WPG_LA_DASHDOTDOT;
-    break;
-  case LINESTYLE_DOTTED:
-    renderer->LineAttr.Type = WPG_LA_DOTS;
-    break;
-  default:
-    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-  }
-}
-
-static void
-set_dashlength(MyRenderer *renderer, real length)
-{  
-  DIAG_NOTE(renderer, "set_dashlength %f\n", length);
-
-  /* dot = 20% of len */
-  renderer->dash_length = length;
-}
-
-static void
-set_fillstyle(MyRenderer *renderer, FillStyle mode)
-{
-  DIAG_NOTE(renderer, "set_fillstyle %d\n", mode);
-
-  switch(mode) {
-  case FILLSTYLE_SOLID:
-    renderer->FillAttr.Type = WPG_FA_SOLID;
-    break;
-  default:
-    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
-  }
-}
-
-static void
-set_font(MyRenderer *renderer, Font *font, real height)
-{
-  DIAG_NOTE(renderer, "set_font %f %s\n", height, font->name);
-  renderer->TextStyle.Height = SC(height);
-
-  if (strstr(font->name, "Courier"))
-    renderer->TextStyle.Font = 0x0DF0;
-  else if (strstr(font->name, "Times"))
-    renderer->TextStyle.Font = 0x1950;
-  else
-    renderer->TextStyle.Font = 0x1150; /* Helv */
-}
-
-/* Need to translate coord system:
- * 
- *   Dia x,y -> Wpg x,-y
- *
- * doing it before scaling.
- */
-static void
-draw_line(MyRenderer *renderer, 
-          Point *start, Point *end, 
-          Color *line_colour)
-{
-  gint16 pData[4];
-
-  DIAG_NOTE(renderer, "draw_line %f,%f -> %f, %f\n", 
-            start->x, start->y, end->x, end->y);
-
-  WriteLineAttr(renderer, line_colour);
-  WriteRecHead(renderer, WPG_LINE, 4 * sizeof(gint16));
-
-  /* point data */
-  pData[0] = SC(start->x);
-  pData[1] = SC(-start->y);
-  pData[2] = SC(end->x);
-  pData[3] = SC(-end->y);
-
-  fwrite_le(pData, sizeof(gint16), 4, renderer->file);
-}
-
-static void
-draw_polyline(MyRenderer *renderer, 
-              Point *points, int num_points, 
-              Color *line_colour)
-{
-  int i;
-  gint16* pData;
-
-  DIAG_NOTE(renderer, "draw_polyline n:%d %f,%f ...\n", 
-            num_points, points->x, points->y);
-
-  g_return_if_fail(1 < num_points);
-
-  WriteLineAttr(renderer, line_colour);
-  WriteRecHead(renderer, WPG_POLYLINE, num_points * 2 * sizeof(gint16) + sizeof(gint16));
-
-  pData = g_new(gint16, num_points * 2);
-
-  /* number of points */
-  pData[0] = num_points;
-  fwrite_le(pData, sizeof(gint16), 1, renderer->file);
-
-  /* point data */
-  for (i = 0; i < num_points; i++)
-  {
-    pData[2*i]   = SC(points[i].x);
-    pData[2*i+1] = SC(-points[i].y);
-  }
-
-  fwrite_le(pData, sizeof(gint16), num_points*2, renderer->file);
-
-  g_free(pData);
-}
-
-static void
-draw_polygon(MyRenderer *renderer, 
-             Point *points, int num_points, 
-             Color *line_colour)
-{
-  gint16* pData;
-  int i;
-
-  DIAG_NOTE(renderer, "draw_polygon n:%d %f,%f ...\n", 
-            num_points, points->x, points->y);
-
-  WriteLineAttr(renderer, line_colour);
-  WriteRecHead(renderer, WPG_POLYGON, (num_points * 2 + 1) * sizeof(gint16));
-
-  pData = g_new(gint16, num_points * 2);
-
-  /* number of vertices */
-  pData[0] = num_points;
-  fwrite_le(pData, sizeof(gint16), 1, renderer->file);
-
-  /* point data */
-  for (i = 0; i < num_points; i++)
-  {
-    pData[2*i]   = SC(points[i].x);
-    pData[2*i+1] = SC(-points[i].y);
-  }
-
-  fwrite_le(pData, sizeof(gint16), num_points*2, renderer->file);
-
-  g_free(pData);
-}
-
-static void
-fill_polygon(MyRenderer *renderer, 
-             Point *points, int num_points, 
-             Color *colour)
-{
-  DIAG_NOTE(renderer, "fill_polygon n:%d %f,%f ...\n", 
-            num_points, points->x, points->y);
-
-  WriteFillAttr(renderer, colour, TRUE);
-  draw_polygon(renderer,points,num_points,colour);
-  WriteFillAttr(renderer, colour, FALSE);
-}
-
-static void
-draw_rect(MyRenderer *renderer, 
-          Point *ul_corner, Point *lr_corner,
-          Color *colour)
-{
-  gint16* pData;
-  DIAG_NOTE(renderer, "draw_rect %f,%f -> %f,%f\n", 
-            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
-
-  WriteLineAttr(renderer, colour);
-  WriteRecHead(renderer, WPG_RECTANGLE, 4*sizeof(gint16));
-
-  pData = g_new(gint16, 4);
-  pData[0] = SC(ul_corner->x); /* lower left corner ! */
-  pData[1] = SC(-lr_corner->y);
-  pData[2] = SC(lr_corner->x - ul_corner->x); /* width */
-  pData[3] = SC(lr_corner->y - ul_corner->y); /* height */
-
-  fwrite_le(pData, sizeof(gint16), 4, renderer->file);
-
-  g_free(pData);
-}
-
-static void
-fill_rect(MyRenderer *renderer, 
-          Point *ul_corner, Point *lr_corner,
-          Color *colour)
-{
-  DIAG_NOTE(renderer, "fill_rect %f,%f -> %f,%f\n", 
-            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
-
-  WriteFillAttr(renderer, colour, TRUE);
-  draw_rect(renderer, ul_corner, lr_corner, colour);
-  WriteFillAttr(renderer, colour, FALSE);
-}
-
-static void
-draw_arc(MyRenderer *renderer, 
-	 Point *center,
-	 real width, real height,
-	 real angle1, real angle2,
-	 Color *colour)
-{
-  WPGEllipse ell;
-
-  DIAG_NOTE(renderer, "draw_arc %fx%f <%f,<%f\n", 
-            width, height, angle1, angle2);
-
-  ell.x = SC(center->x);
-  ell.y = SC(-center->y);
-  ell.RotAngle = 0;
-  ell.rx = SC(width / 2.0);
-  ell.ry = SC(height / 2.0);
-
-  ell.StartAngle = angle1;
-  ell.EndAngle   = angle2;
-  ell.Flags = 0;
-
-  WriteLineAttr(renderer, colour);
-  WriteRecHead(renderer, WPG_ELLIPSE, sizeof(WPGEllipse));
-
-  g_assert(16 == sizeof(WPGEllipse));
-  fwrite_le(&ell, sizeof(guint16), sizeof(WPGEllipse) / sizeof(guint16), renderer->file);
-}
-
-static void
-fill_arc(MyRenderer *renderer, 
-         Point *center,
-         real width, real height,
-         real angle1, real angle2,
-         Color *colour)
-{
-  WPGEllipse ell;
-
-  DIAG_NOTE(renderer, "fill_arc %fx%f <%f,<%f\n", 
-            width, height, angle1, angle2);
-
-  ell.x = SC(center->x);
-  ell.y = SC(-center->y);
-  ell.RotAngle = 0;
-  ell.rx = SC(width / 2.0);
-  ell.ry = SC(height / 2.0);
-
-  ell.StartAngle = angle1;
-  ell.EndAngle   = angle2;
-  ell.Flags = 0; /* 0: connect to center; 1: connect start and end */
-
-  WriteLineAttr(renderer, colour);
-  WriteFillAttr(renderer, colour, TRUE);
-  WriteRecHead(renderer, WPG_ELLIPSE, sizeof(WPGEllipse));
-
-  g_assert(16 == sizeof(WPGEllipse));
-  fwrite_le(&ell, sizeof(guint16), sizeof(WPGEllipse) / sizeof(guint16), renderer->file);
-  WriteFillAttr(renderer, colour, FALSE);
-}
-
-static void
-draw_ellipse(MyRenderer *renderer, 
-             Point *center,
-             real width, real height,
-             Color *colour)
-{
-  WPGEllipse ell;
-
-  DIAG_NOTE(renderer, "draw_ellipse %fx%f center @ %f,%f\n", 
-            width, height, center->x, center->y);
-
-  ell.x = SC(center->x);
-  ell.y = SC(-center->y);
-  ell.RotAngle = 0;
-  ell.rx = SC(width / 2.0);
-  ell.ry = SC(height / 2.0);
-
-  ell.StartAngle = 0;
-  ell.EndAngle   = 360;
-  ell.Flags = 0;
-
-  WriteLineAttr(renderer, colour);
-  WriteRecHead(renderer, WPG_ELLIPSE, sizeof(WPGEllipse));
-
-  g_assert(16 == sizeof(WPGEllipse));
-  fwrite_le(&ell, sizeof(guint16), sizeof(WPGEllipse) / sizeof(guint16), renderer->file);
-}
-
-static void
-fill_ellipse(MyRenderer *renderer, 
-             Point *center,
-             real width, real height,
-             Color *colour)
-{
-  DIAG_NOTE(renderer, "fill_ellipse %fx%f center @ %f,%f\n", 
-            width, height, center->x, center->y);
-
-  WriteFillAttr(renderer, colour, TRUE);
-  draw_ellipse(renderer,center,width,height,colour);
-  WriteFillAttr(renderer, colour, FALSE);
-}
-
-static void
-draw_bezier(MyRenderer *renderer, 
-            BezPoint *points,
-            int numpoints,
-            Color *colour)
-{
-  gint16* pData;
-  int i;
-
-  DIAG_NOTE(renderer, "draw_bezier n:%d %fx%f ...\n", 
-            numpoints, points->p1.x, points->p1.y);
-
-  WriteLineAttr(renderer, colour);
-  WriteRecHead(renderer, WPG_POLYCURVE, (numpoints * 2) * 2 * sizeof(gint16) + 3 * sizeof(gint16));
-
-  pData = g_new(gint16, numpoints * 6);
-
-  /* ??? size of equivalent data in pre5.1 files ? */
-#if 1
-  memset(pData, 0, sizeof(gint16)*2);
-#else
-  /* try first point instead */
-  pData[0] = SC(points[0].p1.x);
-  pData[1] = SC(-points[0].p1.y);
-#endif
-  fwrite_le(pData, sizeof(gint16), 2, renderer->file);
-
-  pData[0] = numpoints * 2;
-  fwrite_le(pData, sizeof(gint16), 1, renderer->file);
-
-  /* WPG's Poly Curve is not quite the same as DIA's Bezier.
-   * There is only one Control Point per Point and I can't 
-   * get it right, but at least they are read without error.
-   */
-  for (i = 0; i < numpoints; i++)
-  {
-    switch (points[i].type)
-    {
-    case BEZ_MOVE_TO:
-    case BEZ_LINE_TO:
-      /* real point */
-      pData[4*i  ] = SC( points[i].p1.x);
-      pData[4*i+1] = SC(-points[i].p1.y);
-
-      /* control point (1st from next point) */
-      if (i+1 < numpoints) {
-        pData[4*i+2] = SC( points[i+1].p1.x);
-        pData[4*i+3] = SC(-points[i+1].p1.y);
-      }
-      else {
-        pData[4*i+2] = SC( points[i].p1.x);
-        pData[4*i+3] = SC(-points[i].p1.y);
-      }
-      break;
-    case BEZ_CURVE_TO:
-      if (0 && (i+1 < numpoints)) {
-        /* real point ?? */
-        pData[4*i  ] = SC( points[i].p3.x);
-        pData[4*i+1] = SC(-points[i].p3.y);
-        /* control point (1st from next point) */
-        pData[4*i+2] = SC( points[i+1].p1.x);
-        pData[4*i+3] = SC(-points[i+1].p1.y);
-      }
-      else {
-        /* need to swap these ?? */
-        /* real point ?? */
-        pData[4*i  ] = SC( points[i].p2.x);
-        pData[4*i+1] = SC(-points[i].p2.y);
-
-        /* control point ?? */
-        pData[4*i+2] = SC( points[i].p3.x);
-        pData[4*i+3] = SC(-points[i].p3.y);
-      }
-      break;
-    }
-  }
-
-  fwrite_le(pData, sizeof(gint16), numpoints*4, renderer->file);
-  g_free(pData);
-}
-
-static void
-fill_bezier(MyRenderer *renderer, 
-            BezPoint *points, /* Last point must be same as first point */
-            int numpoints,
-            Color *colour)
-{
-  DIAG_NOTE(renderer, "fill_bezier n:%d %fx%f ...\n", 
-            numpoints, points->p1.x, points->p1.y);
-
-}
-
-static void
-draw_string(MyRenderer *renderer,
-            const char *text,
-            Point *pos, Alignment alignment,
-            Color *colour)
-{
-  gint16 len;
-  WPGPoint pt;
-
-  len = strlen(text);
-
-  DIAG_NOTE(renderer, "draw_string(%d) %f,%f %s\n", 
-            len, pos->x, pos->y, text);
-
-  if (len < 1) return;
-
-  renderer->TextStyle.YAlign = 3; /* bottom ??? */
-
-  switch (alignment) {
-  case ALIGN_LEFT:
-    renderer->TextStyle.XAlign = 0;
-    break;
-  case ALIGN_CENTER:
-    renderer->TextStyle.XAlign = 1;
-    break;
-  case ALIGN_RIGHT:
-    renderer->TextStyle.XAlign = 2;
-    break;
-  }
-
-  renderer->TextStyle.Color = LookupColor(renderer, colour);
-  renderer->TextStyle.Angle = 0;
-
-  renderer->TextStyle.Width = renderer->TextStyle.Height * 0.6; /* ??? */
-
-  WriteRecHead(renderer, WPG_TEXTSTYLE, sizeof(WPGTextStyle));
-
-#if 0
-  fwrite(&renderer->TextStyle, sizeof(WPGTextStyle), 1, renderer->file);
-#else
-  g_assert(22 == sizeof(WPGTextStyle));
-  fwrite_le(&renderer->TextStyle.Width, sizeof(guint16), 1, renderer->file);
-  fwrite_le(&renderer->TextStyle.Height, sizeof(guint16), 1, renderer->file);
-  fwrite(&renderer->TextStyle.Reserved, 1, sizeof(renderer->TextStyle.Reserved), renderer->file);
-  fwrite_le(&renderer->TextStyle.Font, sizeof(guint16), 1, renderer->file);
-  fwrite(&renderer->TextStyle.Reserved2, sizeof(guint8), 1, renderer->file);
-  fwrite(&renderer->TextStyle.XAlign, 1, 1, renderer->file);
-  fwrite(&renderer->TextStyle.YAlign, 1, 1, renderer->file);
-  fwrite(&renderer->TextStyle.Color, 1, 1, renderer->file);
-  fwrite_le(&renderer->TextStyle.Angle, sizeof(guint16), 1, renderer->file);
-#endif
-  pt.x = SC(pos->x);
-  pt.y = SC(-pos->y);
-
-  WriteRecHead(renderer, WPG_TEXT, 3*sizeof(gint16) + len);
-  fwrite_le(&len, sizeof(gint16), 1, renderer->file);
-  fwrite_le(&pt.x,  sizeof(guint16), 1, renderer->file);
-  fwrite_le(&pt.y,  sizeof(guint16), 1, renderer->file);
-  fwrite(text, 1, len, renderer->file);
-}
-
-static void
-draw_image(MyRenderer *renderer,
-           Point *point,
-           real width, real height,
-           DiaImage image)
-{
-  WPGBitmap2 bmp;
-  guint8 * pDiaImg = NULL, * pOut = NULL, * pIn = NULL, * p = NULL;
-  guint8 b_1, b, cnt;
-  int x, y;
-
-  bmp.Angle  = 0;
-  bmp.Left   = SC(point->x);
-  bmp.Top    = SC(-point->y - height);
-  bmp.Right  = SC(point->x + width);
-  bmp.Bottom = SC(-point->y);
-
-  bmp.Width  = dia_image_width(image);
-  bmp.Height = dia_image_height(image);
-  bmp.Depth  = 8; /* maximum allowed */
-
-  bmp.Xdpi = 72; /* ??? */
-  bmp.Ydpi = 72;
-
-  DIAG_NOTE(renderer, "draw_image %fx%f [%d,%d] @%f,%f\n", 
-            width, height, bmp.Width, bmp.Height, point->x, point->y);
-
-  pDiaImg = pIn = dia_image_rgb_data(image);
-  pOut = g_new(guint8, bmp.Width * bmp.Height * 2); /* space for worst case RLE */
-  p = pOut;
-
-  pIn += (3* bmp.Width * (bmp.Height - 1)); /* last line */ 
-  for (y = 0; y < bmp.Height; y++)
-  {
-    cnt = 0; /* reset with every line */
-    for (x = 0; x < bmp.Width; x ++)
-    {
-      /* simple color reduction to default palette */
-      b = (((CC_LEN - 1) * pIn[0]) / 255) /* red */
-        + (((CC_LEN - 1) * pIn[1]) / 255) * CC_LEN /* green */
-        + (((CC_LEN - 1) * pIn[2]) / 255) * CC_LEN * CC_LEN /* blue */
-        + WPG_NUM_DEF_COLORS;
-
-      pIn += 3; /* increase read pointer */
-
-      if (cnt > 0)
-      {
-        if ((b == b_1) && (cnt < 127)) 
-          cnt++; /* increase counter*/
-        else
-        {
-          *p++ = (cnt | 0x80); /* write run length and value */
-          *p++ = b_1;
-          cnt = 1; /* reset */
-          b_1 = b;
-        }
-      }
-      else
-      {
-        b_1 = b;
-        cnt = 1;
-      }
-    }
-    *p++ = (cnt | 0x80); /* write last value(s) */
-    *p++ = b;
-    pIn -= (3 * bmp.Width * 2); /* start of previous line */
-  }
-  DIAG_NOTE(renderer, "Width x Height: %d RLE: %d\n", bmp.Width * bmp.Height, p - pOut);
-
-  if ((p - pOut) > 32767) {
-    g_warning(MY_RENDERER_NAME ": Bitmap size exceeds blocksize. Ignored.");
-  }
-  else {
-    WriteRecHead(renderer, WPG_BITMAP2, sizeof(WPGBitmap2) + (p - pOut));
-#if 0
-    fwrite(&bmp, sizeof(WPGBitmap2), 1, renderer->file);
-#else
-    g_assert(20 == sizeof(WPGBitmap2));
-    fwrite(&bmp, sizeof(guint16), sizeof(WPGBitmap2) / sizeof(guint16), renderer->file);
-#endif
-    fwrite(pOut, sizeof(guint8), p - pOut, renderer->file);
-  }
-#if 1
-  /* RLE diagnose */
-  {
-    FILE* f;
-    int i, j;
-    f = fopen("c:\\temp\\wpg_bmp.raw", "wb");
-    j = p - pOut;
-    for (i = 0; i < j; i+=2)
-    {
-      for (x = 0; x < (pOut[i] & 0x7F); x++) 
-        fwrite(&pOut[i+1], 1, 1, f);
-    }
-    fclose(f);
-  }
-#endif
-  g_free(pDiaImg);
-  g_free(pOut);
-}
-
-static void
-export_data(DiagramData *data, const gchar *filename, const gchar *diafilename)
-{
-  MyRenderer *renderer;
-  FILE *file;
-  Rectangle *extent;
-  gint len;
-  real width, height;
-
-  file = fopen(filename, "wb"); /* "wb" for binary! */
-
-  if (file == NULL) {
-    message_error(_("Couldn't open: '%s' for writing.\n"), filename);
-    return;
-  }
-
-  renderer = g_new0(MyRenderer, 1);
-  renderer->renderer.ops = &MyRenderOps;
-  renderer->renderer.is_interactive = 0;
-  renderer->renderer.interactive_ops = NULL;
-
-  renderer->file = file;
-
-  extent = &data->extents;
-
-  /* use extents */
-  DIAG_NOTE(renderer, "export_data extents %f,%f -> %f,%f\n", 
-            extent->left, extent->top, extent->right, extent->bottom);
-
-  width  = extent->right - extent->left;
-  height = extent->bottom - extent->top;
-  renderer->Scale = 0.001;
-  if (width > height)
-    while (renderer->Scale * width < 3276.7) renderer->Scale *= 10.0;
-  else
-    while (renderer->Scale * height < 3276.7) renderer->Scale *= 10.0;
-
-  renderer->Box.Width  = width * renderer->Scale;
-  renderer->Box.Height = height * renderer->Scale;
-  renderer->Box.Flag   = 0;
-  renderer->Box.Version = 0;
-
-  data_render(data, (Renderer *)renderer, NULL, NULL, NULL);
-
-  g_free(renderer);
-}
-
-#if WPG_WITH_IMPORT
-/*
- * Import (under construction)
- */
-static void
-import_object(MyRenderer* renderer, DiagramData *dia,
-              WPG_Type type, int iSize, guchar* pData)
-{
-  WPGPoint* pts = NULL;
-  gint16* pInt16 = NULL;
-  int    iNum = 0;
-  gint32 iPre51 = 0;
-
-  switch (type) {
-  case WPG_LINE:
-    iNum = 2;
-    pts = (WPGPoint*)pData;
-    break;
-  case WPG_POLYLINE:
-    pInt16 = (gint16*)pData;
-    iNum = pInt16[0];
-    pts = (WPGPoint*)(pData + sizeof(gint16));
-    break;
-  case WPG_RECTANGLE:
-    iNum = 2;
-    pts = (WPGPoint*)pData;
-    break;
-  case WPG_POLYGON:
-    pInt16 = (gint16*)pData;
-    iNum = pInt16[0];
-    pts = (WPGPoint*)(pData + sizeof(gint16));
-    break;
-  case WPG_ELLIPSE:
-    {
-      WPGEllipse* pEll;
-      pEll = (WPGEllipse*)pData;
-    }
-    break;
-  case WPG_POLYCURVE:
-    iPre51 = *((gint32*)pData);
-    pInt16 = (gint16*)pData;
-    iNum = pInt16[2];
-    pts = (WPGPoint*)(pData + 3*sizeof(gint16));
-    DIAG_NOTE(renderer, "POLYCURVE Num pts %d Pre51 %d\n", iNum, iPre51);
-    break;
-  } /* switch */
-  DIAG_NOTE(renderer, "Type %d Num pts %d Size %d\n", type, iNum, iSize);
-} 
-
-static gboolean
-import_data (const gchar *filename, DiagramData *dia)
-{
-  FILE* f;
-  gboolean bRet;
-  WPGHead8 rh;
-
-  f = fopen(filename, "rb");
-
-  if (NULL == f) {
-    message_error(_("Couldn't open: '%s' for reading.\n"), filename);
-    bRet = FALSE;
-  }
-  
-  /* check header */
-  if (bRet) {
-    WPGFileHead fhead;
-    bRet = ( (1 == fread(&fhead, sizeof(WPGFileHead), 1, f))
-            && fhead.fid[0] == 255 && fhead.fid[1] == 'W'
-            && fhead.fid[2] == 'P' && fhead.fid[3] == 'C'
-            && (1 == fhead.MajorVersion) && (0 == fhead.MinorVersion));
-    if (!bRet)
-      message_error(_("File: %s type/version unsupported.\n"), filename);
-  }
-
-  if (bRet) {
-    int iSize;
-    gint16 i16, iNum16;
-    guint8 i8;
-    MyRenderer ren;
-
-    ren.pPal = g_new0(WPGColorRGB, 256);
-
-    DIAG_NOTE(&ren, "Parsing: %s \n", filename);
-
-    do {
-      if (1 == fread(&rh, sizeof(WPGHead8), 1, f)) {
-        if (rh.Size < 0xFF)
-          iSize = rh.Size;
-        else {
-          bRet = (1 == fread(&i16, sizeof(guint16), 1, f));
-          if (0x8000 & i16) {
-            DIAG_NOTE(&ren, "Large Object: hi:lo %04X", (int)i16);
-            iSize = i16 << 16;
-            /* 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 
-             * object. The criteria when to stop isn't absolutely clear.
-             */
-            iSize = 0;
-            bRet = (1 == fread(&i16, sizeof(guint16), 1, f));
-            DIAG_NOTE(&ren, "Large Object: %d\n", (int)i16);
-            iSize += i16;
-#if 1
-            /* Ignore this large objec part */
-            fseek(f, iSize, SEEK_CUR);
-            continue;
-#endif
-          }
-          else
-            iSize = i16; 
-        }
-      } else
-        iSize = 0;
-
-      //DIAG_NOTE(&ren, "Type %d Size %d\n", rh.Type, iSize);
-      if (iSize > 0) {
-        switch (rh.Type) {
-        case WPG_FILLATTR:
-          bRet = (1 == fread(&ren.FillAttr, sizeof(WPGFillAttr), 1, f));
-          break;
-        case WPG_LINEATTR:
-          bRet = (1 == fread(&ren.LineAttr, sizeof(WPGLineAttr), 1, f));
-          break;
-        case WPG_START:
-          bRet = (1 == fread(&ren.Box, sizeof(WPGStartData), 1, f));
-          break;
-        case WPG_STARTWPG2:
-          /* 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(&ren, "Ignoring tag WPG_STARTWPG2, Size %d\n Type? %d Size? %d\n", 
-                    iSize, (int)i8, i16);
-          fseek(f, iSize - 3, SEEK_CUR);
-          break;
-        case WPG_LINE:
-        case WPG_POLYLINE:
-        case WPG_RECTANGLE:
-        case WPG_POLYGON:
-        case WPG_POLYCURVE:
-        case WPG_ELLIPSE:
-          {
-            guchar* pData;
-
-            pData = g_new(guchar, iSize);
-            bRet = (iSize == (int)fread(pData, 1, iSize, f));
-            import_object(&ren, dia, rh.Type, iSize, pData);
-            g_free(pData);
-          }
-          break;
-        case WPG_COLORMAP:
-          bRet &= (1 == fread(&i16, sizeof(gint16), 1, f));
-          bRet &= (1 == fread(&iNum16, sizeof(gint16), 1, f));
-          if (iNum16 != (gint16)((iSize - 2) / sizeof(WPGColorRGB)))
-            g_warning(MY_RENDERER_NAME ": colormap size/header mismatch.");
-          if (i16 >= 0 && i16 <= iSize) {
-            bRet &= (iNum16 == (int)fread(&ren.pPal[i16], sizeof(WPGColorRGB), iNum16, f));
-          }
-          else {
-            g_warning(MY_RENDERER_NAME ": start color map index out of range.");
-            bRet &= (iNum16 == (int)fread(ren.pPal, sizeof(WPGColorRGB), iNum16, f));
-          }
-          break;
-        case WPG_BITMAP2:
-          {
-            WPGBitmap2 bmp;
-
-            fread(&bmp, sizeof(WPGBitmap2), 1, f);
-            DIAG_NOTE(&ren, "Bitmap %dx%d %d bits @%d,%d %d,%d.\n", 
-                      bmp.Width, bmp.Height, bmp.Depth, 
-                      bmp.Left, bmp.Top, bmp.Right, bmp.Bottom);
-            fseek(f, iSize - sizeof(WPGBitmap2), SEEK_CUR);
-          }
-          break;
-        default:
-          fseek(f, iSize, SEEK_CUR);
-          g_warning ("Unknown Type %d Size %d.", (int)rh.Type, iSize);
-        } /* switch */
-      } /* if iSize */
-      else {
-        if (WPG_END != rh.Type)
-          g_warning("Size 0 on Type %d, expecting WPG_END\n", (int)rh.Type);
-      }
-    }
-    while ((iSize > 0) && (bRet));
-
-    if (!bRet)
-      g_warning(MY_RENDERER_NAME ": unexpected eof. Type %d, Size %d.\n",
-                rh.Type, iSize);
-    if (ren.pPal) g_free(ren.pPal);
-  } /* bRet */
-
-  if (f) fclose(f);
-  return bRet;
-}
-
-#endif /* WPG_WITH_IMPORT */
-
-static const gchar *extensions[] = { "wpg", NULL };
-static DiaExportFilter my_export_filter = {
-    N_(MY_RENDERER_NAME),
-    extensions,
-    export_data
-};
-
-#if WPG_WITH_IMPORT
-DiaImportFilter my_import_filter = {
-    N_(MY_RENDERER_NAME),
-    extensions,
-    import_data
-};
-#endif /* WPG_WITH_IMPORT */
-
-/* --- dia plug-in interface --- */
-
-DIA_PLUGIN_CHECK_INIT
-
-PluginInitResult
-dia_plugin_init(PluginInfo *info)
-{
-  if (!dia_plugin_info_init(info, "WPG",
-			          _("WordPerfect Graphics export filter"),
-			          NULL, NULL))
-    return DIA_PLUGIN_INIT_ERROR;
-
-  filter_register_export(&my_export_filter);
-#if WPG_WITH_IMPORT
-  filter_register_import(&my_import_filter);
-#endif
-
-  return DIA_PLUGIN_INIT_OK;
-}
+/* Dia -- an diagram creation/manipulation program
+ * Copyright (C) 1998 Alexander Larsson
+ *
+ * wpg.c -- HPGL export plugin for dia
+ * Copyright (C) 2000, Hans Breuer, <[e-mail]>
+ *   based on dummy.c 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * ToDo:
+ * - if helper points - like arc centers - are not in Dia's extent box
+ *   their clipping produces unpredictable results 
+ * - the font setting needs improvement (maybe on Dia's side)
+ * - bezier curves are not correctly converted to WPG's poly curve
+ *   (two point beziers are)
+ *
+ * MayBe:
+ * - full featured import (IMO Dia's import support should be improved
+ *   before / on the way ...)
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <glib.h>
+
+#include "config.h"
+#include "intl.h"
+#include "message.h"
+#include "geometry.h"
+#include "render.h"
+#include "filter.h"
+#include "plug-ins.h"
+
+/* format specific */
+#include "wpg_defs.h"
+
+/* Import is not yet finished but only implemented to check the
+ * export capabilities and to investigate other programs WPG
+ * formats. 
+ * The following is not the reason for <en/dis>abling import, 
+ * but it should do it for now ...
+ */
+#define WPG_WITH_IMPORT defined (_MSC_VER)
+
+/*
+ * helper macros
+ */
+#define SC(a) ((a) * renderer->Scale)
+
+/* --- the renderer --- */
+#define MY_RENDERER_NAME "WPG"
+
+typedef struct _MyRenderer MyRenderer;
+struct _MyRenderer {
+  Renderer renderer;
+
+  FILE *file;
+
+  real Scale;
+
+  real dash_length;
+
+  WPGStartData Box;
+  WPGFillAttr  FillAttr;
+  WPGLineAttr  LineAttr;
+  WPGTextStyle TextStyle;
+
+  WPGColorRGB* pPal;
+};
+
+/* include function declares and render object "vtable" */
+#include "../renderer.inc"
+
+#define DIAG_NOTE my_log /* */
+void
+my_log(MyRenderer* renderer, char* format, ...)
+{
+    gchar *string;
+    va_list args;
+  
+    g_return_if_fail (format != NULL);
+  
+    va_start (args, format);
+    string = g_strdup_vprintf (format, args);
+    va_end (args);
+
+    g_print(string);
+
+    g_free(string);
+}
+
+#if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
+/* shortcut if testing of indirection isn't needed anymore */
+#pragma message("LITTLE_ENDIAN: disabling fwrite_le")
+#define fwrite_le(a,b,c,d) fwrite(a,b,c,d)
+#else
+static size_t
+fwrite_le(void* buf, size_t size, size_t count, FILE* f)
+{
+  size_t n = 0;
+  guint i;
+
+  g_assert((1 == size) || (2 == size) || (4 == size));
+
+  if (4 == size)
+  {
+    gint32 i32;
+
+    for (i = 0; i < count; i++)
+    {
+      i32 = GINT32_TO_LE(((gint32*)buf)[i]);
+      n += fwrite(&i32, sizeof(gint32), 1, f);
+    }
+  }
+  else if (2 == size)
+  {
+    gint16 i16;
+
+    for (i = 0; i < count; i++)
+    {
+      i16 = GINT16_TO_LE(((gint16*)buf)[i]);
+      n += fwrite(&i16, sizeof(gint16), 1, f);
+    }
+  }
+  else
+    n = fwrite(buf, size, count, f);
+
+  return n;
+}
+#endif
+
+/* 
+ * color cube len, WPG is limited to 256 colors. To get simple
+ * color reduction algorithms only 216 = 6^3 of them are used.
+ */
+#define CC_LEN 6
+
+/*
+ * "To avoid problems with WPC products the first 16 colors of
+ *  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
+ * start color).
+ */
+#define WPG_NUM_DEF_COLORS 0 /* 16 */
+
+/* 
+ * helper functions 
+ */
+guint8
+LookupColor(MyRenderer *renderer, Color* colour)
+{
+  /* find nearest color in the renderers color map */
+  /* 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
+                  + (int)floor(colour->blue * (CC_LEN - 1)) * CC_LEN  * CC_LEN;
+  DIAG_NOTE(renderer, "LookupColor %d.\n", i);
+  if (i >= CC_LEN * CC_LEN * CC_LEN)
+    return CC_LEN * CC_LEN * CC_LEN - 1 + WPG_NUM_DEF_COLORS;
+  else 
+    return i + WPG_NUM_DEF_COLORS;
+}
+
+void
+WriteRecHead(MyRenderer *renderer, WPG_Type Type, guint32 Size)
+{
+  if (Size < 255)
+  {
+    WPGHead8 rh;
+    rh.Type = (guint8)Type;
+    rh.Size = (guint8)Size;
+    fwrite(&rh, sizeof(guint8), 2, renderer->file);
+  }
+  else if (Size < 32768)
+  {
+    WPGHead16 rh;
+    rh.Type  = (guint8)Type;
+    rh.Dummy = 0xFF;
+    rh.Size  = (guint16)Size;
+    fwrite(&rh, sizeof(guint8), 2, renderer->file);
+    fwrite_le(&(rh.Size), sizeof(guint16), 1, renderer->file);
+  }
+  else
+  {
+    WPGHead32 rh;
+    rh.Type  = (guint8)Type;
+    rh.Dummy = 0xFF;
+    rh.Size  = Size;
+
+    /* To avoid problems with stucture packing this struct
+     * is written in parts ...
+     */
+    fwrite(&rh, sizeof(guint8), 2, renderer->file);
+    fwrite_le(&rh.Size, sizeof(guint32), 1, renderer->file);
+  }
+}
+
+void
+WriteLineAttr(MyRenderer *renderer, Color* colour)
+{
+  g_assert(4 == sizeof(WPGLineAttr));
+
+  WriteRecHead(renderer, WPG_LINEATTR, sizeof(WPGLineAttr));
+  renderer->LineAttr.Color = LookupColor(renderer, colour);
+  fwrite(&renderer->LineAttr, sizeof(guint8), 2, renderer->file);
+  fwrite_le(&renderer->LineAttr.Width, sizeof(guint16), 1, renderer->file);
+}
+
+void
+WriteFillAttr(MyRenderer *renderer, Color* colour, gboolean bFill)
+{
+  g_assert(2 == sizeof(WPGFillAttr));
+
+  WriteRecHead(renderer, WPG_FILLATTR, sizeof(WPGFillAttr));
+  if (bFill)
+  {
+    renderer->FillAttr.Color = LookupColor(renderer, colour);
+    fwrite(&renderer->FillAttr, sizeof(WPGFillAttr), 1, renderer->file);
+  }
+  else
+  {
+    WPGFillAttr fa;
+    fa.Color = LookupColor(renderer, colour);
+    fa.Type = WPG_FA_HOLLOW;
+    fwrite(&fa, sizeof(WPGFillAttr), 1, renderer->file);
+  }
+}
+
+/* 
+ * render functions 
+ */ 
+static void
+begin_render(MyRenderer *renderer, DiagramData *data)
+{
+#if 0
+  const WPGFileHead wpgFileHead = { "\377WPC", 16, 
+                                   1, 22,
+                                   1, 0, /* Version */ 
+                                   0, 0};
+#else
+  /* static conversion to little endian */
+  const char wpgFileHead[16] = {255, 'W', 'P', 'C', 16, 0, 0, 0, 
+                                1, 22, 1, 0, 0, 0, 0, 0};
+#endif
+
+  gint16 i;
+  guint8* pPal;
+  Color color = {1, 1, 1};
+
+  DIAG_NOTE(renderer, "begin_render\n");
+
+  fwrite(&wpgFileHead, 1, 16, renderer->file);
+
+  /* bounding box */
+  WriteRecHead(renderer, WPG_START, sizeof(WPGStartData));
+#if 0
+  fwrite(&renderer->Box, sizeof(WPGStartData), 1, renderer->file);
+#else
+  g_assert(6 == sizeof(WPGStartData));
+  fwrite(&renderer->Box, sizeof(guint8), 2, renderer->file);
+  fwrite_le(&renderer->Box.Width, sizeof(guint16), 2, renderer->file);
+#endif
+  /* initialize a well known colormap, see LookupColor */
+  pPal = g_new(gint8, CC_LEN*CC_LEN*CC_LEN*3);
+  for (i = 0; i < CC_LEN * CC_LEN * CC_LEN; i++)
+  {
+    pPal[3*i  ] = ((i % CC_LEN) * 255) / (CC_LEN - 1);   /* red */
+    pPal[3*i+1] = (((i / CC_LEN) % CC_LEN) * 255) / (CC_LEN - 1); /* green */
+    pPal[3*i+2] = ((i / (CC_LEN * CC_LEN)) * 255) / (CC_LEN - 1); /* blue varies least */
+    /*
+    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 */
+  fwrite_le(&i, sizeof(gint16), 1, renderer->file);
+  i = CC_LEN*CC_LEN*CC_LEN;
+  fwrite_le(&i, sizeof(gint16), 1, renderer->file);
+  fwrite(pPal, 1, CC_LEN*CC_LEN*CC_LEN*3, renderer->file);
+
+  /* FIXME: following 3 lines needed to make filling work !? */
+  renderer->FillAttr.Type = WPG_FA_SOLID;
+  WriteFillAttr(renderer, &color, TRUE);
+  WriteFillAttr(renderer, &color, FALSE);
+
+  g_free(pPal);
+}
+
+static void
+end_render(MyRenderer *renderer)
+{
+  DIAG_NOTE(renderer, "end_render\n");
+
+  WriteRecHead(renderer, WPG_END, 0); /* no data following */
+  fclose(renderer->file);
+}
+
+static void
+set_linewidth(MyRenderer *renderer, real linewidth)
+{  
+  DIAG_NOTE(renderer, "set_linewidth %f\n", linewidth);
+
+  renderer->LineAttr.Width = SC(linewidth);
+}
+
+static void
+set_linecaps(MyRenderer *renderer, LineCaps mode)
+{
+  DIAG_NOTE(renderer, "set_linecaps %d\n", mode);
+
+  switch(mode) {
+  case LINECAPS_BUTT:
+    break;
+  case LINECAPS_ROUND:
+    break;
+  case LINECAPS_PROJECTING:
+    break;
+  default:
+    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+  }
+}
+
+static void
+set_linejoin(MyRenderer *renderer, LineJoin mode)
+{
+  DIAG_NOTE(renderer, "set_join %d\n", mode);
+
+  switch(mode) {
+  case LINEJOIN_MITER:
+    break;
+  case LINEJOIN_ROUND:
+    break;
+  case LINEJOIN_BEVEL:
+    break;
+  default:
+    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+  }
+}
+
+static void
+set_linestyle(MyRenderer *renderer, LineStyle mode)
+{
+  DIAG_NOTE(renderer, "set_linestyle %d\n", mode);
+
+  /* line type */
+  switch (mode) {
+  case LINESTYLE_SOLID:
+    renderer->LineAttr.Type = WPG_LA_SOLID;
+    break;
+  case LINESTYLE_DASHED:
+    if (renderer->dash_length < 0.5)
+      renderer->LineAttr.Type = WPG_LA_SHORTDASH;
+    else
+      renderer->LineAttr.Type = WPG_LA_MEDIUMDASH;
+    break;
+  case LINESTYLE_DASH_DOT:
+    renderer->LineAttr.Type = WPG_LA_DASHDOT;
+    break;
+  case LINESTYLE_DASH_DOT_DOT:
+    renderer->LineAttr.Type = WPG_LA_DASHDOTDOT;
+    break;
+  case LINESTYLE_DOTTED:
+    renderer->LineAttr.Type = WPG_LA_DOTS;
+    break;
+  default:
+    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+  }
+}
+
+static void
+set_dashlength(MyRenderer *renderer, real length)
+{  
+  DIAG_NOTE(renderer, "set_dashlength %f\n", length);
+
+  /* dot = 20% of len */
+  renderer->dash_length = length;
+}
+
+static void
+set_fillstyle(MyRenderer *renderer, FillStyle mode)
+{
+  DIAG_NOTE(renderer, "set_fillstyle %d\n", mode);
+
+  switch(mode) {
+  case FILLSTYLE_SOLID:
+    renderer->FillAttr.Type = WPG_FA_SOLID;
+    break;
+  default:
+    message_error(MY_RENDERER_NAME ": Unsupported fill mode specified!\n");
+  }
+}
+
+static void
+set_font(MyRenderer *renderer, Font *font, real height)
+{
+  DIAG_NOTE(renderer, "set_font %f %s\n", height, font->name);
+  renderer->TextStyle.Height = SC(height);
+
+  if (strstr(font->name, "Courier"))
+    renderer->TextStyle.Font = 0x0DF0;
+  else if (strstr(font->name, "Times"))
+    renderer->TextStyle.Font = 0x1950;
+  else
+    renderer->TextStyle.Font = 0x1150; /* Helv */
+}
+
+/* Need to translate coord system:
+ * 
+ *   Dia x,y -> Wpg x,-y
+ *
+ * doing it before scaling.
+ */
+static void
+draw_line(MyRenderer *renderer, 
+          Point *start, Point *end, 
+          Color *line_colour)
+{
+  gint16 pData[4];
+
+  DIAG_NOTE(renderer, "draw_line %f,%f -> %f, %f\n", 
+            start->x, start->y, end->x, end->y);
+
+  WriteLineAttr(renderer, line_colour);
+  WriteRecHead(renderer, WPG_LINE, 4 * sizeof(gint16));
+
+  /* point data */
+  pData[0] = SC(start->x);
+  pData[1] = SC(-start->y);
+  pData[2] = SC(end->x);
+  pData[3] = SC(-end->y);
+
+  fwrite_le(pData, sizeof(gint16), 4, renderer->file);
+}
+
+static void
+draw_polyline(MyRenderer *renderer, 
+              Point *points, int num_points, 
+              Color *line_colour)
+{
+  int i;
+  gint16* pData;
+
+  DIAG_NOTE(renderer, "draw_polyline n:%d %f,%f ...\n", 
+            num_points, points->x, points->y);
+
+  g_return_if_fail(1 < num_points);
+
+  WriteLineAttr(renderer, line_colour);
+  WriteRecHead(renderer, WPG_POLYLINE, num_points * 2 * sizeof(gint16) + sizeof(gint16));
+
+  pData = g_new(gint16, num_points * 2);
+
+  /* number of points */
+  pData[0] = num_points;
+  fwrite_le(pData, sizeof(gint16), 1, renderer->file);
+
+  /* point data */
+  for (i = 0; i < num_points; i++)
+  {
+    pData[2*i]   = SC(points[i].x);
+    pData[2*i+1] = SC(-points[i].y);
+  }
+
+  fwrite_le(pData, sizeof(gint16), num_points*2, renderer->file);
+
+  g_free(pData);
+}
+
+static void
+draw_polygon(MyRenderer *renderer, 
+             Point *points, int num_points, 
+             Color *line_colour)
+{
+  gint16* pData;
+  int i;
+
+  DIAG_NOTE(renderer, "draw_polygon n:%d %f,%f ...\n", 
+            num_points, points->x, points->y);
+
+  WriteLineAttr(renderer, line_colour);
+  WriteRecHead(renderer, WPG_POLYGON, (num_points * 2 + 1) * sizeof(gint16));
+
+  pData = g_new(gint16, num_points * 2);
+
+  /* number of vertices */
+  pData[0] = num_points;
+  fwrite_le(pData, sizeof(gint16), 1, renderer->file);
+
+  /* point data */
+  for (i = 0; i < num_points; i++)
+  {
+    pData[2*i]   = SC(points[i].x);
+    pData[2*i+1] = SC(-points[i].y);
+  }
+
+  fwrite_le(pData, sizeof(gint16), num_points*2, renderer->file);
+
+  g_free(pData);
+}
+
+static void
+fill_polygon(MyRenderer *renderer, 
+             Point *points, int num_points, 
+             Color *colour)
+{
+  DIAG_NOTE(renderer, "fill_polygon n:%d %f,%f ...\n", 
+            num_points, points->x, points->y);
+
+  WriteFillAttr(renderer, colour, TRUE);
+  draw_polygon(renderer,points,num_points,colour);
+  WriteFillAttr(renderer, colour, FALSE);
+}
+
+static void
+draw_rect(MyRenderer *renderer, 
+          Point *ul_corner, Point *lr_corner,
+          Color *colour)
+{
+  gint16* pData;
+  DIAG_NOTE(renderer, "draw_rect %f,%f -> %f,%f\n", 
+            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
+
+  WriteLineAttr(renderer, colour);
+  WriteRecHead(renderer, WPG_RECTANGLE, 4*sizeof(gint16));
+
+  pData = g_new(gint16, 4);
+  pData[0] = SC(ul_corner->x); /* lower left corner ! */
+  pData[1] = SC(-lr_corner->y);
+  pData[2] = SC(lr_corner->x - ul_corner->x); /* width */
+  pData[3] = SC(lr_corner->y - ul_corner->y); /* height */
+
+  fwrite_le(pData, sizeof(gint16), 4, renderer->file);
+
+  g_free(pData);
+}
+
+static void
+fill_rect(MyRenderer *renderer, 
+          Point *ul_corner, Point *lr_corner,
+          Color *colour)
+{
+  DIAG_NOTE(renderer, "fill_rect %f,%f -> %f,%f\n", 
+            ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
+
+  WriteFillAttr(renderer, colour, TRUE);
+  draw_rect(renderer, ul_corner, lr_corner, colour);
+  WriteFillAttr(renderer, colour, FALSE);
+}
+
+static void
+draw_arc(MyRenderer *renderer, 
+	 Point *center,
+	 real width, real height,
+	 real angle1, real angle2,
+	 Color *colour)
+{
+  WPGEllipse ell;
+
+  DIAG_NOTE(renderer, "draw_arc %fx%f <%f,<%f\n", 
+            width, height, angle1, angle2);
+
+  ell.x = SC(center->x);
+  ell.y = SC(-center->y);
+  ell.RotAngle = 0;
+  ell.rx = SC(width / 2.0);
+  ell.ry = SC(height / 2.0);
+
+  ell.StartAngle = angle1;
+  ell.EndAngle   = angle2;
+  ell.Flags = 0;
+
+  WriteLineAttr(renderer, colour);
+  WriteRecHead(renderer, WPG_ELLIPSE, sizeof(WPGEllipse));
+
+  g_assert(16 == sizeof(WPGEllipse));
+  fwrite_le(&ell, sizeof(guint16), sizeof(WPGEllipse) / sizeof(guint16), renderer->file);
+}
+
+static void
+fill_arc(MyRenderer *renderer, 
+         Point *center,
+         real width, real height,
+         real angle1, real angle2,
+         Color *colour)
+{
+  WPGEllipse ell;
+
+  DIAG_NOTE(renderer, "fill_arc %fx%f <%f,<%f\n", 
+            width, height, angle1, angle2);
+
+  ell.x = SC(center->x);
+  ell.y = SC(-center->y);
+  ell.RotAngle = 0;
+  ell.rx = SC(width / 2.0);
+  ell.ry = SC(height / 2.0);
+
+  ell.StartAngle = angle1;
+  ell.EndAngle   = angle2;
+  ell.Flags = 0; /* 0: connect to center; 1: connect start and end */
+
+  WriteLineAttr(renderer, colour);
+  WriteFillAttr(renderer, colour, TRUE);
+  WriteRecHead(renderer, WPG_ELLIPSE, sizeof(WPGEllipse));
+
+  g_assert(16 == sizeof(WPGEllipse));
+  fwrite_le(&ell, sizeof(guint16), sizeof(WPGEllipse) / sizeof(guint16), renderer->file);
+  WriteFillAttr(renderer, colour, FALSE);
+}
+
+static void
+draw_ellipse(MyRenderer *renderer, 
+             Point *center,
+             real width, real height,
+             Color *colour)
+{
+  WPGEllipse ell;
+
+  DIAG_NOTE(renderer, "draw_ellipse %fx%f center @ %f,%f\n", 
+            width, height, center->x, center->y);
+
+  ell.x = SC(center->x);
+  ell.y = SC(-center->y);
+  ell.RotAngle = 0;
+  ell.rx = SC(width / 2.0);
+  ell.ry = SC(height / 2.0);
+
+  ell.StartAngle = 0;
+  ell.EndAngle   = 360;
+  ell.Flags = 0;
+
+  WriteLineAttr(renderer, colour);
+  WriteRecHead(renderer, WPG_ELLIPSE, sizeof(WPGEllipse));
+
+  g_assert(16 == sizeof(WPGEllipse));
+  fwrite_le(&ell, sizeof(guint16), sizeof(WPGEllipse) / sizeof(guint16), renderer->file);
+}
+
+static void
+fill_ellipse(MyRenderer *renderer, 
+             Point *center,
+             real width, real height,
+             Color *colour)
+{
+  DIAG_NOTE(renderer, "fill_ellipse %fx%f center @ %f,%f\n", 
+            width, height, center->x, center->y);
+
+  WriteFillAttr(renderer, colour, TRUE);
+  draw_ellipse(renderer,center,width,height,colour);
+  WriteFillAttr(renderer, colour, FALSE);
+}
+
+static void
+draw_bezier(MyRenderer *renderer, 
+            BezPoint *points,
+            int numpoints,
+            Color *colour)
+{
+  gint16* pData;
+  int i;
+
+  DIAG_NOTE(renderer, "draw_bezier n:%d %fx%f ...\n", 
+            numpoints, points->p1.x, points->p1.y);
+
+  WriteLineAttr(renderer, colour);
+  WriteRecHead(renderer, WPG_POLYCURVE, (numpoints * 2) * 2 * sizeof(gint16) + 3 * sizeof(gint16));
+
+  pData = g_new(gint16, numpoints * 6);
+
+  /* ??? size of equivalent data in pre5.1 files ? */
+#if 1
+  memset(pData, 0, sizeof(gint16)*2);
+#else
+  /* try first point instead */
+  pData[0] = SC(points[0].p1.x);
+  pData[1] = SC(-points[0].p1.y);
+#endif
+  fwrite_le(pData, sizeof(gint16), 2, renderer->file);
+
+  pData[0] = numpoints * 2;
+  fwrite_le(pData, sizeof(gint16), 1, renderer->file);
+
+  /* WPG's Poly Curve is not quite the same as DIA's Bezier.
+   * There is only one Control Point per Point and I can't 
+   * get it right, but at least they are read without error.
+   */
+  for (i = 0; i < numpoints; i++)
+  {
+    switch (points[i].type)
+    {
+    case BEZ_MOVE_TO:
+    case BEZ_LINE_TO:
+      /* real point */
+      pData[4*i  ] = SC( points[i].p1.x);
+      pData[4*i+1] = SC(-points[i].p1.y);
+
+      /* control point (1st from next point) */
+      if (i+1 < numpoints) {
+        pData[4*i+2] = SC( points[i+1].p1.x);
+        pData[4*i+3] = SC(-points[i+1].p1.y);
+      }
+      else {
+        pData[4*i+2] = SC( points[i].p1.x);
+        pData[4*i+3] = SC(-points[i].p1.y);
+      }
+      break;
+    case BEZ_CURVE_TO:
+      if (0 && (i+1 < numpoints)) {
+        /* real point ?? */
+        pData[4*i  ] = SC( points[i].p3.x);
+        pData[4*i+1] = SC(-points[i].p3.y);
+        /* control point (1st from next point) */
+        pData[4*i+2] = SC( points[i+1].p1.x);
+        pData[4*i+3] = SC(-points[i+1].p1.y);
+      }
+      else {
+        /* need to swap these ?? */
+        /* real point ?? */
+        pData[4*i  ] = SC( points[i].p2.x);
+        pData[4*i+1] = SC(-points[i].p2.y);
+
+        /* control point ?? */
+        pData[4*i+2] = SC( points[i].p3.x);
+        pData[4*i+3] = SC(-points[i].p3.y);
+      }
+      break;
+    }
+  }
+
+  fwrite_le(pData, sizeof(gint16), numpoints*4, renderer->file);
+  g_free(pData);
+}
+
+static void
+fill_bezier(MyRenderer *renderer, 
+            BezPoint *points, /* Last point must be same as first point */
+            int numpoints,
+            Color *colour)
+{
+  DIAG_NOTE(renderer, "fill_bezier n:%d %fx%f ...\n", 
+            numpoints, points->p1.x, points->p1.y);
+
+}
+
+static void
+draw_string(MyRenderer *renderer,
+            const char *text,
+            Point *pos, Alignment alignment,
+            Color *colour)
+{
+  gint16 len;
+  WPGPoint pt;
+
+  len = strlen(text);
+
+  DIAG_NOTE(renderer, "draw_string(%d) %f,%f %s\n", 
+            len, pos->x, pos->y, text);
+
+  if (len < 1) return;
+
+  renderer->TextStyle.YAlign = 3; /* bottom ??? */
+
+  switch (alignment) {
+  case ALIGN_LEFT:
+    renderer->TextStyle.XAlign = 0;
+    break;
+  case ALIGN_CENTER:
+    renderer->TextStyle.XAlign = 1;
+    break;
+  case ALIGN_RIGHT:
+    renderer->TextStyle.XAlign = 2;
+    break;
+  }
+
+  renderer->TextStyle.Color = LookupColor(renderer, colour);
+  renderer->TextStyle.Angle = 0;
+
+  renderer->TextStyle.Width = renderer->TextStyle.Height * 0.6; /* ??? */
+
+  WriteRecHead(renderer, WPG_TEXTSTYLE, sizeof(WPGTextStyle));
+
+#if 0
+  fwrite(&renderer->TextStyle, sizeof(WPGTextStyle), 1, renderer->file);
+#else
+  g_assert(22 == sizeof(WPGTextStyle));
+  fwrite_le(&renderer->TextStyle.Width, sizeof(guint16), 1, renderer->file);
+  fwrite_le(&renderer->TextStyle.Height, sizeof(guint16), 1, renderer->file);
+  fwrite(&renderer->TextStyle.Reserved, 1, sizeof(renderer->TextStyle.Reserved), renderer->file);
+  fwrite_le(&renderer->TextStyle.Font, sizeof(guint16), 1, renderer->file);
+  fwrite(&renderer->TextStyle.Reserved2, sizeof(guint8), 1, renderer->file);
+  fwrite(&renderer->TextStyle.XAlign, 1, 1, renderer->file);
+  fwrite(&renderer->TextStyle.YAlign, 1, 1, renderer->file);
+  fwrite(&renderer->TextStyle.Color, 1, 1, renderer->file);
+  fwrite_le(&renderer->TextStyle.Angle, sizeof(guint16), 1, renderer->file);
+#endif
+  pt.x = SC(pos->x);
+  pt.y = SC(-pos->y);
+
+  WriteRecHead(renderer, WPG_TEXT, 3*sizeof(gint16) + len);
+  fwrite_le(&len, sizeof(gint16), 1, renderer->file);
+  fwrite_le(&pt.x,  sizeof(guint16), 1, renderer->file);
+  fwrite_le(&pt.y,  sizeof(guint16), 1, renderer->file);
+  fwrite(text, 1, len, renderer->file);
+}
+
+static void
+draw_image(MyRenderer *renderer,
+           Point *point,
+           real width, real height,
+           DiaImage image)
+{
+  WPGBitmap2 bmp;
+  guint8 * pDiaImg = NULL, * pOut = NULL, * pIn = NULL, * p = NULL;
+  guint8 b_1, b, cnt;
+  int x, y;
+
+  bmp.Angle  = 0;
+  bmp.Left   = SC(point->x);
+  bmp.Top    = SC(-point->y - height);
+  bmp.Right  = SC(point->x + width);
+  bmp.Bottom = SC(-point->y);
+
+  bmp.Width  = dia_image_width(image);
+  bmp.Height = dia_image_height(image);
+  bmp.Depth  = 8; /* maximum allowed */
+
+  bmp.Xdpi = 72; /* ??? */
+  bmp.Ydpi = 72;
+
+  DIAG_NOTE(renderer, "draw_image %fx%f [%d,%d] @%f,%f\n", 
+            width, height, bmp.Width, bmp.Height, point->x, point->y);
+
+  pDiaImg = pIn = dia_image_rgb_data(image);
+  pOut = g_new(guint8, bmp.Width * bmp.Height * 2); /* space for worst case RLE */
+  p = pOut;
+
+  pIn += (3* bmp.Width * (bmp.Height - 1)); /* last line */ 
+  for (y = 0; y < bmp.Height; y++)
+  {
+    cnt = 0; /* reset with every line */
+    for (x = 0; x < bmp.Width; x ++)
+    {
+      /* simple color reduction to default palette */
+      b = (((CC_LEN - 1) * pIn[0]) / 255) /* red */
+        + (((CC_LEN - 1) * pIn[1]) / 255) * CC_LEN /* green */
+        + (((CC_LEN - 1) * pIn[2]) / 255) * CC_LEN * CC_LEN /* blue */
+        + WPG_NUM_DEF_COLORS;
+
+      pIn += 3; /* increase read pointer */
+
+      if (cnt > 0)
+      {
+        if ((b == b_1) && (cnt < 127)) 
+          cnt++; /* increase counter*/
+        else
+        {
+          *p++ = (cnt | 0x80); /* write run length and value */
+          *p++ = b_1;
+          cnt = 1; /* reset */
+          b_1 = b;
+        }
+      }
+      else
+      {
+        b_1 = b;
+        cnt = 1;
+      }
+    }
+    *p++ = (cnt | 0x80); /* write last value(s) */
+    *p++ = b;
+    pIn -= (3 * bmp.Width * 2); /* start of previous line */
+  }
+  DIAG_NOTE(renderer, "Width x Height: %d RLE: %d\n", bmp.Width * bmp.Height, p - pOut);
+
+  if ((p - pOut) > 32767) {
+    g_warning(MY_RENDERER_NAME ": Bitmap size exceeds blocksize. Ignored.");
+  }
+  else {
+    WriteRecHead(renderer, WPG_BITMAP2, sizeof(WPGBitmap2) + (p - pOut));
+#if 0
+    fwrite(&bmp, sizeof(WPGBitmap2), 1, renderer->file);
+#else
+    g_assert(20 == sizeof(WPGBitmap2));
+    fwrite(&bmp, sizeof(guint16), sizeof(WPGBitmap2) / sizeof(guint16), renderer->file);
+#endif
+    fwrite(pOut, sizeof(guint8), p - pOut, renderer->file);
+  }
+#if 1
+  /* RLE diagnose */
+  {
+    FILE* f;
+    int i, j;
+    f = fopen("c:\\temp\\wpg_bmp.raw", "wb");
+    j = p - pOut;
+    for (i = 0; i < j; i+=2)
+    {
+      for (x = 0; x < (pOut[i] & 0x7F); x++) 
+        fwrite(&pOut[i+1], 1, 1, f);
+    }
+    fclose(f);
+  }
+#endif
+  g_free(pDiaImg);
+  g_free(pOut);
+}
+
+static void
+export_data(DiagramData *data, const gchar *filename, const gchar *diafilename)
+{
+  MyRenderer *renderer;
+  FILE *file;
+  Rectangle *extent;
+  gint len;
+  real width, height;
+
+  file = fopen(filename, "wb"); /* "wb" for binary! */
+
+  if (file == NULL) {
+    message_error(_("Couldn't open: '%s' for writing.\n"), filename);
+    return;
+  }
+
+  renderer = g_new0(MyRenderer, 1);
+  renderer->renderer.ops = &MyRenderOps;
+  renderer->renderer.is_interactive = 0;
+  renderer->renderer.interactive_ops = NULL;
+
+  renderer->file = file;
+
+  extent = &data->extents;
+
+  /* use extents */
+  DIAG_NOTE(renderer, "export_data extents %f,%f -> %f,%f\n", 
+            extent->left, extent->top, extent->right, extent->bottom);
+
+  width  = extent->right - extent->left;
+  height = extent->bottom - extent->top;
+  renderer->Scale = 0.001;
+  if (width > height)
+    while (renderer->Scale * width < 3276.7) renderer->Scale *= 10.0;
+  else
+    while (renderer->Scale * height < 3276.7) renderer->Scale *= 10.0;
+
+  renderer->Box.Width  = width * renderer->Scale;
+  renderer->Box.Height = height * renderer->Scale;
+  renderer->Box.Flag   = 0;
+  renderer->Box.Version = 0;
+
+  data_render(data, (Renderer *)renderer, NULL, NULL, NULL);
+
+  g_free(renderer);
+}
+
+#if WPG_WITH_IMPORT
+/*
+ * Import (under construction)
+ */
+static void
+import_object(MyRenderer* renderer, DiagramData *dia,
+              WPG_Type type, int iSize, guchar* pData)
+{
+  WPGPoint* pts = NULL;
+  gint16* pInt16 = NULL;
+  int    iNum = 0;
+  gint32 iPre51 = 0;
+
+  switch (type) {
+  case WPG_LINE:
+    iNum = 2;
+    pts = (WPGPoint*)pData;
+    break;
+  case WPG_POLYLINE:
+    pInt16 = (gint16*)pData;
+    iNum = pInt16[0];
+    pts = (WPGPoint*)(pData + sizeof(gint16));
+    break;
+  case WPG_RECTANGLE:
+    iNum = 2;
+    pts = (WPGPoint*)pData;
+    break;
+  case WPG_POLYGON:
+    pInt16 = (gint16*)pData;
+    iNum = pInt16[0];
+    pts = (WPGPoint*)(pData + sizeof(gint16));
+    break;
+  case WPG_ELLIPSE:
+    {
+      WPGEllipse* pEll;
+      pEll = (WPGEllipse*)pData;
+    }
+    break;
+  case WPG_POLYCURVE:
+    iPre51 = *((gint32*)pData);
+    pInt16 = (gint16*)pData;
+    iNum = pInt16[2];
+    pts = (WPGPoint*)(pData + 3*sizeof(gint16));
+    DIAG_NOTE(renderer, "POLYCURVE Num pts %d Pre51 %d\n", iNum, iPre51);
+    break;
+  } /* switch */
+  DIAG_NOTE(renderer, "Type %d Num pts %d Size %d\n", type, iNum, iSize);
+} 
+
+static gboolean
+import_data (const gchar *filename, DiagramData *dia)
+{
+  FILE* f;
+  gboolean bRet;
+  WPGHead8 rh;
+
+  f = fopen(filename, "rb");
+
+  if (NULL == f) {
+    message_error(_("Couldn't open: '%s' for reading.\n"), filename);
+    bRet = FALSE;
+  }
+  
+  /* check header */
+  if (bRet) {
+    WPGFileHead fhead;
+    bRet = ( (1 == fread(&fhead, sizeof(WPGFileHead), 1, f))
+            && fhead.fid[0] == 255 && fhead.fid[1] == 'W'
+            && fhead.fid[2] == 'P' && fhead.fid[3] == 'C'
+            && (1 == fhead.MajorVersion) && (0 == fhead.MinorVersion));
+    if (!bRet)
+      message_error(_("File: %s type/version unsupported.\n"), filename);
+  }
+
+  if (bRet) {
+    int iSize;
+    gint16 i16, iNum16;
+    guint8 i8;
+    MyRenderer ren;
+
+    ren.pPal = g_new0(WPGColorRGB, 256);
+
+    DIAG_NOTE(&ren, "Parsing: %s \n", filename);
+
+    do {
+      if (1 == fread(&rh, sizeof(WPGHead8), 1, f)) {
+        if (rh.Size < 0xFF)
+          iSize = rh.Size;
+        else {
+          bRet = (1 == fread(&i16, sizeof(guint16), 1, f));
+          if (0x8000 & i16) {
+            DIAG_NOTE(&ren, "Large Object: hi:lo %04X", (int)i16);
+            iSize = i16 << 16;
+            /* 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 
+             * object. The criteria when to stop isn't absolutely clear.
+             */
+            iSize = 0;
+            bRet = (1 == fread(&i16, sizeof(guint16), 1, f));
+            DIAG_NOTE(&ren, "Large Object: %d\n", (int)i16);
+            iSize += i16;
+#if 1
+            /* Ignore this large objec part */
+            fseek(f, iSize, SEEK_CUR);
+            continue;
+#endif
+          }
+          else
+            iSize = i16; 
+        }
+      } else
+        iSize = 0;
+
+      //DIAG_NOTE(&ren, "Type %d Size %d\n", rh.Type, iSize);
+      if (iSize > 0) {
+        switch (rh.Type) {
+        case WPG_FILLATTR:
+          bRet = (1 == fread(&ren.FillAttr, sizeof(WPGFillAttr), 1, f));
+          break;
+        case WPG_LINEATTR:
+          bRet = (1 == fread(&ren.LineAttr, sizeof(WPGLineAttr), 1, f));
+          break;
+        case WPG_START:
+          bRet = (1 == fread(&ren.Box, sizeof(WPGStartData), 1, f));
+          break;
+        case WPG_STARTWPG2:
+          /* 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(&ren, "Ignoring tag WPG_STARTWPG2, Size %d\n Type? %d Size? %d\n", 
+                    iSize, (int)i8, i16);
+          fseek(f, iSize - 3, SEEK_CUR);
+          break;
+        case WPG_LINE:
+        case WPG_POLYLINE:
+        case WPG_RECTANGLE:
+        case WPG_POLYGON:
+        case WPG_POLYCURVE:
+        case WPG_ELLIPSE:
+          {
+            guchar* pData;
+
+            pData = g_new(guchar, iSize);
+            bRet = (iSize == (int)fread(pData, 1, iSize, f));
+            import_object(&ren, dia, rh.Type, iSize, pData);
+            g_free(pData);
+          }
+          break;
+        case WPG_COLORMAP:
+          bRet &= (1 == fread(&i16, sizeof(gint16), 1, f));
+          bRet &= (1 == fread(&iNum16, sizeof(gint16), 1, f));
+          if (iNum16 != (gint16)((iSize - 2) / sizeof(WPGColorRGB)))
+            g_warning(MY_RENDERER_NAME ": colormap size/header mismatch.");
+          if (i16 >= 0 && i16 <= iSize) {
+            bRet &= (iNum16 == (int)fread(&ren.pPal[i16], sizeof(WPGColorRGB), iNum16, f));
+          }
+          else {
+            g_warning(MY_RENDERER_NAME ": start color map index out of range.");
+            bRet &= (iNum16 == (int)fread(ren.pPal, sizeof(WPGColorRGB), iNum16, f));
+          }
+          break;
+        case WPG_BITMAP2:
+          {
+            WPGBitmap2 bmp;
+
+            fread(&bmp, sizeof(WPGBitmap2), 1, f);
+            DIAG_NOTE(&ren, "Bitmap %dx%d %d bits @%d,%d %d,%d.\n", 
+                      bmp.Width, bmp.Height, bmp.Depth, 
+                      bmp.Left, bmp.Top, bmp.Right, bmp.Bottom);
+            fseek(f, iSize - sizeof(WPGBitmap2), SEEK_CUR);
+          }
+          break;
+        default:
+          fseek(f, iSize, SEEK_CUR);
+          g_warning ("Unknown Type %d Size %d.", (int)rh.Type, iSize);
+        } /* switch */
+      } /* if iSize */
+      else {
+        if (WPG_END != rh.Type)
+          g_warning("Size 0 on Type %d, expecting WPG_END\n", (int)rh.Type);
+      }
+    }
+    while ((iSize > 0) && (bRet));
+
+    if (!bRet)
+      g_warning(MY_RENDERER_NAME ": unexpected eof. Type %d, Size %d.\n",
+                rh.Type, iSize);
+    if (ren.pPal) g_free(ren.pPal);
+  } /* bRet */
+
+  if (f) fclose(f);
+  return bRet;
+}
+
+#endif /* WPG_WITH_IMPORT */
+
+static const gchar *extensions[] = { "wpg", NULL };
+static DiaExportFilter my_export_filter = {
+    N_(MY_RENDERER_NAME),
+    extensions,
+    export_data
+};
+
+#if WPG_WITH_IMPORT
+DiaImportFilter my_import_filter = {
+    N_(MY_RENDERER_NAME),
+    extensions,
+    import_data
+};
+#endif /* WPG_WITH_IMPORT */
+
+/* --- dia plug-in interface --- */
+
+DIA_PLUGIN_CHECK_INIT
+
+PluginInitResult
+dia_plugin_init(PluginInfo *info)
+{
+  if (!dia_plugin_info_init(info, "WPG",
+			          _("WordPerfect Graphics export filter"),
+			          NULL, NULL))
+    return DIA_PLUGIN_INIT_ERROR;
+
+  filter_register_export(&my_export_filter);
+#if WPG_WITH_IMPORT
+  filter_register_import(&my_import_filter);
+#endif
+
+  return DIA_PLUGIN_INIT_OK;
+}

--- a/plug-ins/wpg/wpg_defs.h
+++ b/plug-ins/wpg/wpg_defs.h
@@ -1,185 +1,185 @@
-/*
- * wpg_defs.h - WordPerfect Graphics Metafile Definitions
- *
- * Based on: "Encyclopedia of Graphics File Formats"
- *       by James D. Murray, William vanRyper, Deborah Russel
- *
- * Translated to "C" by Hans Breuer <[e-mail]>
- */
-
-typedef struct
-{
-  guchar  fid[4];
-  guint32 DataOffset;
-  guint8  ProductType;
-  guint8  FileType;
-  guint8  MajorVersion;
-  guint8  MinorVersion;
-  guint16 EncryptionKey;
-  guint16 Reserved;
-}
-WPGFileHead;
-
-typedef struct
-{
-  guint8  Type;
-  guint8  Color;
-  guint16  Width;
-}
-WPGLineAttr;
-
-typedef struct
-{
-  guint8  Type;
-  guint8  Color;
-}
-WPGFillAttr;
-
-typedef struct
-{
-  guint16  Width;
-  guint16  Height;
-  guint8  Reserved[10];
-
-  guint16 Font;
-  guint8  Reserved2;
-
-  guint8  XAlign;
-  guint8  YAlign;
-
-  guint8  Color;
-  gint16  Angle;
-}
-WPGTextStyle;
-
-typedef struct
-{
-  guint8  Version;
-  guint8  Flag;
-  guint16  Width; 
-  guint16  Height;
-}
-WPGStartData;
-
-typedef struct
-{
-  guint16  x, y;   /* center */
-  guint16  rx, ry; /* radius */
-
-  guint16  RotAngle; /* rotation */
-  guint16  StartAngle, EndAngle; /* 0 - 360ｰ */
-  guint16 Flags;
-}
-WPGEllipse;
-
-typedef struct
-{
-  guint16 Width;
-  guint16 Height;
-  guint16 BitsPerPixel;
-  guint16 Xdpi;
-  guint16 Ydpi;
-}
-WPGBitmap1;
-
-typedef struct
-{
-  guint16 Angle;
-  guint16 Left;
-  guint16 Bottom;
-  guint16 Right;
-  guint16 Top;
-  guint16 Width;
-  guint16 Height;
-  guint16 Depth;
-  guint16 Xdpi;
-  guint16 Ydpi;
-}
-WPGBitmap2;
-
-typedef struct
-{
-  guint8  Type;
-  guint8  Size;
-}
-WPGHead8;
-
-typedef struct
-{
-  guint8  Type;
-  guint8  Dummy;
-  guint16 Size;
-}
-WPGHead16;
-
-typedef struct
-{
-  guint8  Type;
-  guint8  Dummy;
-  guint32 Size;
-}
-WPGHead32;
-
-typedef struct
-{
-  guint16 x;
-  guint16 y;
-}
-WPGPoint;
-
-typedef struct
-{
-  guint8 r;
-  guint8 g;
-  guint8 b;
-}
-WPGColorRGB;
-
-typedef enum 
-{
-  WPG_FILLATTR = 1,
-  WPG_LINEATTR = 2,
-  WPG_MARKERATTR = 3,
-  WPG_POLYMARKER = 4,
-  WPG_LINE = 5,
-  WPG_POLYLINE = 6,
-  WPG_RECTANGLE = 7,
-  WPG_POLYGON = 8,
-  WPG_ELLIPSE = 9,
-  WPG_BITMAP1 = 11,
-  WPG_TEXT = 12,
-  WPG_TEXTSTYLE = 13,
-  WPG_COLORMAP = 14,
-  WPG_START = 15,
-  WPG_END = 16,
-  WPG_POSTSCRIPT1 = 17,
-  WPG_OUTPUTATTR = 18,
-  WPG_POLYCURVE = 19,
-  WPG_BITMAP2 = 20,
-  WPG_STARTFIGURE = 21,
-  WPG_STARTCHART = 22,
-  WPG_PLANPERFECT = 23,
-  WPG_GRAPHICSTEXT2 = 24,
-  WPG_STARTWPG2 = 25,
-  WPG_GRAPHICSTEXT3 = 26,
-  WPG_POSTSCRIPT2 = 27
-} WPG_Type;
-
-typedef enum
-{
-  WPG_FA_HOLLOW = 0,
-  WPG_FA_SOLID = 1
-  /* ... */
-} WPG_FillAttr;
-
-typedef enum
-{
-  WPG_LA_NONE = 0,
-  WPG_LA_SOLID,
-  WPG_LA_LONGDASH,
-  WPG_LA_DOTS,
-  WPG_LA_DASHDOT,
-  WPG_LA_MEDIUMDASH,
-  WPG_LA_DASHDOTDOT,
-  WPG_LA_SHORTDASH
-} WPG_LineAttr;
+/*
+ * wpg_defs.h - WordPerfect Graphics Metafile Definitions
+ *
+ * Based on: "Encyclopedia of Graphics File Formats"
+ *       by James D. Murray, William vanRyper, Deborah Russel
+ *
+ * Translated to "C" by Hans Breuer <[e-mail]>
+ */
+
+typedef struct
+{
+  guchar  fid[4];
+  guint32 DataOffset;
+  guint8  ProductType;
+  guint8  FileType;
+  guint8  MajorVersion;
+  guint8  MinorVersion;
+  guint16 EncryptionKey;
+  guint16 Reserved;
+}
+WPGFileHead;
+
+typedef struct
+{
+  guint8  Type;
+  guint8  Color;
+  guint16  Width;
+}
+WPGLineAttr;
+
+typedef struct
+{
+  guint8  Type;
+  guint8  Color;
+}
+WPGFillAttr;
+
+typedef struct
+{
+  guint16  Width;
+  guint16  Height;
+  guint8  Reserved[10];
+
+  guint16 Font;
+  guint8  Reserved2;
+
+  guint8  XAlign;
+  guint8  YAlign;
+
+  guint8  Color;
+  gint16  Angle;
+}
+WPGTextStyle;
+
+typedef struct
+{
+  guint8  Version;
+  guint8  Flag;
+  guint16  Width; 
+  guint16  Height;
+}
+WPGStartData;
+
+typedef struct
+{
+  guint16  x, y;   /* center */
+  guint16  rx, ry; /* radius */
+
+  guint16  RotAngle; /* rotation */
+  guint16  StartAngle, EndAngle; /* 0 - 360ｰ */
+  guint16 Flags;
+}
+WPGEllipse;
+
+typedef struct
+{
+  guint16 Width;
+  guint16 Height;
+  guint16 BitsPerPixel;
+  guint16 Xdpi;
+  guint16 Ydpi;
+}
+WPGBitmap1;
+
+typedef struct
+{
+  guint16 Angle;
+  guint16 Left;
+  guint16 Bottom;
+  guint16 Right;
+  guint16 Top;
+  guint16 Width;
+  guint16 Height;
+  guint16 Depth;
+  guint16 Xdpi;
+  guint16 Ydpi;
+}
+WPGBitmap2;
+
+typedef struct
+{
+  guint8  Type;
+  guint8  Size;
+}
+WPGHead8;
+
+typedef struct
+{
+  guint8  Type;
+  guint8  Dummy;
+  guint16 Size;
+}
+WPGHead16;
+
+typedef struct
+{
+  guint8  Type;
+  guint8  Dummy;
+  guint32 Size;
+}
+WPGHead32;
+
+typedef struct
+{
+  guint16 x;
+  guint16 y;
+}
+WPGPoint;
+
+typedef struct
+{
+  guint8 r;
+  guint8 g;
+  guint8 b;
+}
+WPGColorRGB;
+
+typedef enum 
+{
+  WPG_FILLATTR = 1,
+  WPG_LINEATTR = 2,
+  WPG_MARKERATTR = 3,
+  WPG_POLYMARKER = 4,
+  WPG_LINE = 5,
+  WPG_POLYLINE = 6,
+  WPG_RECTANGLE = 7,
+  WPG_POLYGON = 8,
+  WPG_ELLIPSE = 9,
+  WPG_BITMAP1 = 11,
+  WPG_TEXT = 12,
+  WPG_TEXTSTYLE = 13,
+  WPG_COLORMAP = 14,
+  WPG_START = 15,
+  WPG_END = 16,
+  WPG_POSTSCRIPT1 = 17,
+  WPG_OUTPUTATTR = 18,
+  WPG_POLYCURVE = 19,
+  WPG_BITMAP2 = 20,
+  WPG_STARTFIGURE = 21,
+  WPG_STARTCHART = 22,
+  WPG_PLANPERFECT = 23,
+  WPG_GRAPHICSTEXT2 = 24,
+  WPG_STARTWPG2 = 25,
+  WPG_GRAPHICSTEXT3 = 26,
+  WPG_POSTSCRIPT2 = 27
+} WPG_Type;
+
+typedef enum
+{
+  WPG_FA_HOLLOW = 0,
+  WPG_FA_SOLID = 1
+  /* ... */
+} WPG_FillAttr;
+
+typedef enum
+{
+  WPG_LA_NONE = 0,
+  WPG_LA_SOLID,
+  WPG_LA_LONGDASH,
+  WPG_LA_DOTS,
+  WPG_LA_DASHDOT,
+  WPG_LA_MEDIUMDASH,
+  WPG_LA_DASHDOTDOT,
+  WPG_LA_SHORTDASH
+} WPG_LineAttr;