Commit: 414c14ea85d8f81fbc0b3392ba3ceaaaed0486d1 - dia (git)

作図ソフト dia の改良版

Commit MetaInfo

• Revision: 414c14ea85d8f81fbc0b3392ba3ceaaaed0486d1 (tree)
• Time: 2007-03-27 05:18:26
• Author: Hans Breuer <hans@breu...>
• Commiter: Hans Breuer

Log Message

dia/lib bindings with the help of SWIG, for details see:

2007-03-26 Hans Breuer <[e-mail]>

* bindings/* : dia/lib bindings with the help of SWIG, for details
see: http://mail.gnome.org/archives/dia-list/2007-March/msg00092.html

svn path=/trunk/; revision=3651

Change Summary

• modified: ChangeLog
• add: bindings/Doxyfile
• add: bindings/dia-bindings.h
• add: bindings/dia-connections.cpp
• add: bindings/dia-connections.h
• add: bindings/dia-diagramdata.cpp
• add: bindings/dia-diagramdata.h
• add: bindings/dia-extra.cpp
• add: bindings/dia-extra.h
• add: bindings/dia-object.cpp
• add: bindings/dia-object.h
• add: bindings/dia-properties.cpp
• add: bindings/dia-properties.h
• add: bindings/dia-python-extra.cpp
• add: bindings/dia-python-extra.h
• add: bindings/dia-renderer.cpp
• add: bindings/dia-renderer.h
• add: bindings/dia.swig
• add: bindings/makefile.msc
• add: bindings/test.py

Incremental Difference

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
[phone]  Hans Breuer  <[e-mail]>
+
+	* bindings/* : dia/lib bindings with the help of SWIG, for details
+	see: http://mail.gnome.org/archives/dia-list/2007-March/msg00092.html
+
 2007-03-25  Lars Clausen  <[e-mail]>
 
 	* NEWS: 

--- /dev/null
+++ b/bindings/Doxyfile
@@ -0,0 +1,26 @@
+# Doxyfile 1.4.6
+PROJECT_NAME           = "Dia Bindings"
+OUTPUT_DIRECTORY       = .
+VERBATIM_HEADERS       = NO
+#SHOW_INCLUDE_FILES     = YES
+#GENERATE_TODOLIST      = YES
+#GENERATE_TESTLIST      = YES
+DETAILS_AT_TOP         = YES
+INPUT                  = .
+FILE_PATTERNS          = *.h *.cpp
+EXCLUDE                = dia-python.cpp
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+
+GENERATE_LATEX         = NO
+GENERATE_RTF           = NO
+GENERATE_MAN           = NO
+
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+UML_LOOK               = YES
+CALL_GRAPH             = YES
+INCLUDE_GRAPH          = NO
+INCLUDED_BY_GRAPH      = NO
+GRAPHICAL_HIERARCHY    = YES

--- /dev/null
+++ b/bindings/dia-bindings.h
@@ -0,0 +1,18 @@
+/* 
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+#ifndef DIA__BINDINGS_H
+#define DIA__BINDINGS_H
+/*!
+ * \mainpage Dia Bindings with C++ and SWIG
+ *
+ * This project provides language bindings for some <a href="http://www.gnome.org/projects/dia/">Dia</a>
+ * classes. Where ever possible/feasible the new bindings resemble the preexisting 
+ * <a href="http://www.gnome.org/projects/dia/python.html">Dia Python Bindings</a>. But other than that 
+ * this project should allow to bind Dia to various languages. Potentially supported langauges are everything 
+ * supported by <a href="http://www.swig.org">SWIG</a>.
+ *
+ * 
+ */
+ 
+#endif

--- /dev/null
+++ b/bindings/dia-connections.cpp
@@ -0,0 +1,117 @@
+/*
+ * C++ implementation of Dia Connections - just proxies
+ *
+ * Copyright (C) 2007, Hans Breuer, <[e-mail]>
+ *
+ * This 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 "object.h"
+
+#include "dia-object.h"
+
+#include "dia-connections.h"
+#include "dia-diagramdata.h"
+
+#include "diagramdata.h"
+
+dia::ConnectionPoint::ConnectionPoint (::ConnectionPoint* p) : self(p), connected(&p->connected) 
+{
+}
+
+dia::ConnectionPoint::~ConnectionPoint () 
+{ 
+}
+//! read-only attribute: placement
+::_Point 
+dia::ConnectionPoint::pos () const
+{
+    ::_Point dummy = {0, 0};
+    g_return_val_if_fail (self, dummy);
+    return self->pos;
+}
+//! the object this is belonging to. To follow a connection 
+//! you go from Handle.connected_to -> ConnectionPoint.object
+dia::Object* 
+dia::ConnectionPoint::get_object () const
+{
+    g_return_val_if_fail (self, 0);
+    return new dia::Object(self->object);
+}
+
+dia::Connections::Connections (::DiaObject* o) : object(o)
+{
+}
+dia::Connections::~Connections ()
+{
+}
+//! is there a property of this name
+int 
+dia::Connections::len () const
+{
+    if (object)
+        object->num_connections;
+    return 0;
+}
+//! return back a single property
+dia::ConnectionPoint* 
+dia::Connections::getitem (int n) const
+{
+    g_return_val_if_fail (object, 0);
+    if (n < 0 || n >= object->num_connections)
+        return 0;
+    return new dia::ConnectionPoint (object->connections[n]);
+}
+//! \todo find a way to SWIG pick up the accessors as attributes w/o
+//! remaning the accessor and
+//! %attribute(dia::Handle, dia::ConnectionPoint*, connected_to, get_connected_to);
+const dia::ConnectionPoint* 
+dia::Handle::get_connected_to() const
+{
+    g_return_val_if_fail (self, 0);
+    if (!self->connected_to)
+        return 0;
+    return new ConnectionPoint(self->connected_to);
+}
+void
+dia::Handle::connect (dia::ConnectionPoint* cp)
+{
+    g_return_if_fail (self != NULL);
+    g_return_if_fail (owner != NULL);
+    object_connect (owner, self, cp->Self());
+}
+//! construct from owner
+dia::Handles::Handles (::DiaObject* o) : object(o)
+{
+}
+//! destroy
+dia::Handles::~Handles ()
+{
+}
+//! how many contained
+int 
+dia::Handles::len () const
+{
+    g_return_val_if_fail (object != NULL, 0);
+    return object->num_handles;
+}
+//! return back a single property
+dia::Handle* 
+dia::Handles::getitem (int n) const
+{
+    g_return_val_if_fail (object, 0);
+    if (n < 0 || n >= object->num_handles)
+        return 0;
+    return new dia::Handle (object->handles[n], object);
+}

--- /dev/null
+++ b/bindings/dia-connections.h
@@ -0,0 +1,106 @@
+/*
+ * C++ interface of Dia Connections - just to have something clean to wrap
+ *
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+#ifndef DIA__CONNECTIONS_H
+#define DIA__CONNECTIONS_H
+
+#include "dia-diagramdata.h"
+
+namespace dia {
+
+// forward declare
+class Object;
+
+/*!
+ * \brief Where a connection and an object meet there is a ConnectionPoint
+ *
+ * The ConnectionPoint is one part to do a connection. The other part is Handle.
+ */
+class ConnectionPoint
+{
+public :
+    //! construct from underlying data type
+    ConnectionPoint (::ConnectionPoint* p);
+    //! destruct 
+    ~ConnectionPoint ();
+
+    //! FIXME: trying to be compatible
+    //! read-only attribute;
+    const dia::Objects connected;
+    //! read-only attribute: placement
+    _Point pos () const;
+    //! the object this is belonging to. To follow a connection you go from Handle.connected_to -> ConnectionPoint.object
+    Object* get_object () const;
+    
+    //! get on the underlying object
+    ::ConnectionPoint* Self() const { return self; }
+private :
+    ::ConnectionPoint* self;
+};
+
+/*!
+ * \brief A container for ConnectionPoints, provides array access to them
+ *
+ */
+class Connections
+{
+public :
+    //! construct from owning Object
+    Connections (::DiaObject*);
+    //! destroy the wrapper, not the underlying type
+    ~Connections ();
+    /* accessors like Python sequence */
+    //! how many contained
+    int len () const;
+    //! return back a single property
+    ConnectionPoint* getitem (int) const;
+
+private :
+    ::DiaObject* object; //!< the owner of the connections
+};
+/*!
+ * \brief With a Handle you have a grip on an Object
+ *
+ * Together with ConnectionPoint a Handle allows to connect objects.
+ */
+class Handle
+{
+public :
+    //! construct from wrapped
+    Handle (_Handle* h, _DiaObject* o) : self(h), owner(o) {}
+    //! indirectly delivers the object this is connected to, if at all
+    const ConnectionPoint* get_connected_to() const;
+    //! establish a connection to another object
+    void connect (ConnectionPoint*);
+
+    //! convert to underlying
+    ::_Handle* Self() const { return self; }    
+private :
+    ::_Handle* self;
+    ::_DiaObject* owner;
+};
+/*!
+ * \brief Collection of Handle
+ */
+class Handles
+{
+public :
+    //! construct from owner
+    Handles (::DiaObject*);
+    //! destroy
+    ~Handles ();
+
+    /* array access */
+    //! how many contained
+    int len () const;
+    //! return back a single one
+    Handle* getitem (int) const;
+    
+private :
+    ::DiaObject* object;
+};
+
+} // namespace dia
+#endif /* DIA__CONNECTIONS_H */

--- /dev/null
+++ b/bindings/dia-diagramdata.cpp
@@ -0,0 +1,176 @@
+/*
+ * C++ wrapper of DiagramData - just to have something clean to wrap
+ *
+ * Copyright (C) 2007, Hans Breuer, <[e-mail]>
+ *
+ * This 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 "object.h"
+#include "diagramdata.h"
+#include <assert.h>
+
+#include "dia-object.h"
+
+#include "dia-diagramdata.h"
+
+//! how many contained
+int 
+dia::Objects::len () const
+{
+    if (list)
+        return g_list_length(*list);
+    return 0;
+}
+//! \brief return back a single one
+//! Together with len() getitem() allows list access. The code generator needs some
+//! extra help to not making it an endless list. At least for Python the NULL return
+//! was turned into None objects, we want to have only as much list elements 
+//! as there are real objects.
+dia::Object* 
+dia::Objects::getitem (int n) const
+{
+    if (list && n >= 0 && n < g_list_length(*list))
+        return new dia::Object((::DiaObject*)g_list_nth_data(*list, n));
+    return 0;
+}
+
+//! construct with underlying list of objects
+//! \todo check ownership/lifetime of that list!
+dia::Layer::Layer (::Layer* layer) : self(layer), _found(0) 
+{
+    assert (self);
+    // todo: when we allow to change the name this needs to change
+    name = g_strdup (self->name);
+    objects = new dia::Objects(&(layer->objects));
+}
+dia::Layer::~Layer ()
+{
+    if (_found)
+        delete _found;
+    if (name)
+        g_free (const_cast<gchar*>(name));
+    if (objects)
+      delete const_cast<dia::Objects*>(objects);
+}
+void
+dia::Layer::add_object (Object* o)
+{
+    g_return_if_fail (self != NULL);
+    layer_add_object (self, o->Self());
+}
+void
+dia::Layer::update_extents ()
+{
+    g_return_if_fail (self != NULL);
+    layer_update_extents(self);
+}
+//! the object next to given point but within maxdist
+dia::Object* 
+dia::Layer::find_closest_object (::Point* pos, double maxdist) const
+{
+    g_return_val_if_fail (self != NULL, 0);
+    ::DiaObject* o = layer_find_closest_object (self, pos, maxdist);
+    if (o)
+      return new dia::Object (o);
+    return 0;
+}
+//! a list of Object in the given rectangle
+dia::Objects& 
+dia::Layer::find_objects_in_rectangle (::Rectangle* rect) const
+{
+    static GList* list = layer_find_objects_in_rectangle (self, rect);
+    if (_found)
+        delete _found;
+    const_cast<Layer*>(this)->_found = new dia::Objects (&list);
+    return *_found;
+}
+ //! objects are kept in an ordered list, this is the index of the given object
+int 
+dia::Layer::object_index (Object* o) const
+{
+    g_return_val_if_fail (self != NULL, -1);
+    return layer_object_index (self, o->Self());
+}
+
+int
+dia::Layers::len () const
+{
+    if (list)
+        return (*list)->len;
+    return 0;
+}
+dia::Layer*
+dia::Layers::getitem (int n) const
+{
+  if (list && n >= 0 && n < (*list)->len)
+    return new dia::Layer(static_cast<::Layer*>(g_ptr_array_index (*list, n)));
+  return 0;
+}
+
+/*!
+ * DiagramData is the low level Diagram, i.e. everything without an UI
+ */
+dia::DiagramData::DiagramData () : self(0), active_layer(0), _selected(0)
+{
+    // the usual GObjetc cast DIA_DIAGRAM_DATA does not work when playing games with namespaces ;)
+    self = static_cast<::DiagramData*> (g_object_new (DIA_TYPE_DIAGRAM_DATA, NULL));
+    //FIXME: grumpf
+    if (self->active_layer)
+      active_layer = new Layer(self->active_layer);
+    else if (self->layers->len > 0)
+      active_layer = new Layer((::Layer*)g_ptr_array_index(self->layers, 0));
+    layers = new Layers(&self->layers);
+}
+dia::DiagramData::~DiagramData ()
+{
+    g_object_unref (self);
+    if (_selected)
+        delete _selected;
+    if (layers)
+      delete const_cast<dia::Layers*>(layers);
+}
+
+dia::Layer*
+dia::DiagramData::add_layer (const char* name)
+{
+    int pos = -1; //TODO: make this a parameter
+    g_return_val_if_fail (self != NULL, 0);
+    ::Layer* layer = new_layer(g_strdup(name),self);
+    if (pos != -1)
+	data_add_layer_at(self, layer, pos);
+    else
+	data_add_layer(self, layer);
+
+    dia::Layer* dl = new dia::Layer (layer);
+    return dl;
+}
+void 
+dia::DiagramData::update_extents ()
+{
+    g_return_if_fail(self != NULL);
+    data_update_extents(self);
+    // conceptionally const, i.e. read-only
+    *const_cast<::Rectangle*>(&extents) = self->extents;
+}
+dia::Objects&
+dia::DiagramData::get_sorted_selected () const
+{
+    if (_selected)
+        delete _selected;
+
+    static GList* list = data_get_sorted_selected(self);
+    const_cast<DiagramData*>(this)->_selected = new dia::Objects (&list);
+    return *_selected;
+}

--- /dev/null
+++ b/bindings/dia-diagramdata.h
@@ -0,0 +1,127 @@
+/*
+ * C++ interface of DiagramData - just to have something clean to wrap
+ *
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+#ifndef DIA__DIAGRAMDATA_H
+#define DIA__DIAGRAMDATA_H
+
+#include "dia-object.h"
+
+//! every wrapping object is in the 'dia' namespace
+//! the C-Objects are only namespaced in the binding 
+namespace dia {
+
+class Object;
+
+/*!
+ * \brief A collection of objects
+ *
+ * Maybe this should be turned into a template class cause it would need different owners
+ * depending on its use. The strongest connection is between Object and Layer but there
+ * are other collections of of Objects like DiagramData::selected or even Group
+ */
+class Objects
+{
+public :
+    //! dont use
+    Objects () : list(0) {}
+
+    //! construct from Object owning objects list
+    Objects (GList** o) : list(o) {}
+    
+    /* array access */
+    //! how many contained
+    int len () const;
+    //! return back a single one
+    Object* getitem (int) const;
+private :
+    GList** list;
+};
+
+/*!
+ * \brief Proxy to the Layer object
+ *
+ * A Layer is the connection between DiagramData and Object. 
+ * DiagramData has Layers and a Layer has Objects.
+ */
+class Layer
+{
+public :
+    //! construct from underlying type: can not be created stand-alone yet.
+    explicit Layer (::Layer* layer);
+    //! destroy caches etc.
+    ~Layer ();
+    //! the underlying type - only for implementation, not visible in th elanguage binding 
+    ::Layer* Self () const { return self; }
+    //! collection of contained Object, read-only!
+    const Objects* objects;
+    //! add an object to our collection
+    void add_object (Object* o);
+    //! recalculation of every Object size and position to update the Layer extents
+    void update_extents ();
+    //! the object next to given point but within maxdist
+    Object* find_closest_object (::Point* pos, double maxdist) const;
+    //! a list of Object in the given rectangle
+    Objects& find_objects_in_rectangle (::Rectangle* rect) const;
+    //! objects are kept in an ordered list, this is the index of the given object
+    int object_index (Object* o) const;
+
+    //! again I would like easy accessor mapping in SWIG
+    const char* name;
+private :
+    ::Layer* self;
+    Objects* _found; //< backing store for find_objects_in_rectangle
+};
+
+//! \brief container for layer, needed du to msvc6 lacking partial specialization
+class Layers
+{
+public :
+    //! dont use
+    Layers () : list(0) {}
+    //! construct from Dia's container
+    Layers (GPtrArray** os) : list(os) {}
+    /* array access */
+    //! how many contained
+    int len () const;
+    //! return back a single one
+    Layer* getitem (int) const;
+private :
+    GPtrArray** list;
+};
+
+/*!
+ * \brief DiagramData is the low level Diagram, i.e. everything without an UI
+ *
+ * The base class for Diagram. The top-level object for libdia containing
+ * all the other diagram objects.
+ */
+class DiagramData
+{
+public :
+    //! the size of the diagram, from last DiagramData::update_extents();
+    const ::Rectangle extents;
+    //! trying ot be compatible, read-only
+    const Layer* active_layer;
+    //! the read-only list of layers, \todo typemap it in SWIG
+    const Layers* layers;
+    //! can be created as stand-alone object
+    DiagramData ();
+    //! done with it
+    ~DiagramData ();
+    //! get the underlying representation
+    ::DiagramData* Self () const { return self; }
+    //! factory function for Layer. They can't stand alone. TODO: decide if this should change the active_layer
+    Layer* add_layer (const char* name);
+    //! recalculation of every object to update the diagram extents
+    void update_extents ();
+    //! the currently selected objects
+    Objects& get_sorted_selected () const;
+private :
+    ::DiagramData* self;
+    Objects* _selected; //!< backing store for get_sorted_selected
+};
+
+} // namespace dia
+#endif /* DIA__DIAGRAMDATA_H */

--- /dev/null
+++ b/bindings/dia-extra.cpp
@@ -0,0 +1,88 @@
+/*
+ * C++ implementation of Dia Bindings Helper Functions
+ *
+ * Copyright (C) 2007, Hans Breuer, <[e-mail]>
+ *
+ * This 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 "dia-extra.h"
+
+#include <glib.h>
+#include "message.h"
+#include "utils.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <glib-object.h>
+#include "properties.h"
+#include "object.h"
+#include "plug-ins.h"
+
+/*
+ * copied from ../app/diaconv.c
+ */
+static void __cdecl
+stderr_message_internal(const char *title, const char *fmt,
+                        va_list *args,  va_list *args2)
+{
+  static gchar *buf = NULL;
+  static gint   alloc = 0;
+  gint len;
+
+  len = format_string_length_upper_bound (fmt, args);
+
+  if (len >= alloc) {
+    if (buf)
+      g_free (buf);
+    
+    alloc = nearest_pow (MAX(len + 1, 1024));
+    
+    buf = g_new (char, alloc);
+  }
+  
+  vsprintf (buf, fmt, *args2);
+  
+  fprintf(stderr,
+          "%s %s: %s\n", 
+          "",title,buf);
+}
+
+static void
+dia_extra_redirect (void)
+{
+  set_message_func(&stderr_message_internal);
+}
+
+/*!
+ * 
+ *
+ * \todo Dia's init function needs to be cleaned. E.g. it would be useful
+ * to just initialize the plug-ins needed and not everything. Also this
+ * function may be split to be partially called at bindings initialization
+ * time.
+ */
+void dia::register_plugins ()
+{
+    g_type_init();
+    dia_extra_redirect();
+    printf ("ATTENTION: crashing may be caused by the other pydia extension picked up here.");
+    //FIXME: Dia's init functions need to be cleaned - and made aware of multiple calls ...
+    stdprops_init();
+
+    object_registry_init();
+    dia_register_plugins ();
+}

--- /dev/null
+++ b/bindings/dia-extra.h
@@ -0,0 +1,11 @@
+/*
+ * C++ implementation of Dia Bindings Helper Functions
+ *
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+
+
+namespace dia {
+  //! register plug-ins, beware of double bindings
+  void register_plugins (void);
+}

--- /dev/null
+++ b/bindings/dia-object.cpp
@@ -0,0 +1,208 @@
+/*
+ * C++ interface of DiaObject - just to have something clean to wrap
+ *
+ * Copyright (C) 2007, Hans Breuer, <[e-mail]>
+ *
+ * This 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 "object.h"
+#include <assert.h>
+
+#include "dia-object.h"
+
+dia::ObjectType::ObjectType (DiaObjectType* ot) : self(ot), version(ot ? ot->version : -1)
+{
+    assert (self);
+    // read-only which also wont change
+    name = self->name;
+}
+/*! Factory function to create Object of a given type.
+ *
+ * \return not only the new Object* but also two 'appropriate' Handle to e.g. connect 
+ * to some other Object
+ */
+dia::Object* 
+dia::ObjectType::create(double x, double y, dia::Handle** h1, dia::Handle** h2) const
+{
+    ::_Handle *_h1, *_h2;
+    dia::Object* o;
+    Point p = {x, y};
+    void* user_data = 0; //TODO: as parameter ???
+    if (!self)
+        return 0;
+    o = new dia::Object (self->ops->create(&p, user_data ? user_data : self->default_user_data, &_h1, &_h2));
+    if (h1) *h1 = new dia::Handle (_h1, o->Self());
+    if (h2) *h2 = new dia::Handle (_h2, o->Self());
+    return o;
+}
+/*! 
+ * Allows to load an object from storage. Not sure if this becomes useful for language bindings.
+ */
+dia::Object* 
+dia::ObjectType::load (ObjectNode node, int version, const char* filename) const
+{
+    assert (self);
+    return new dia::Object (self->ops->load (node, version, filename));
+}
+/*! Allows to save an Object to ObjectNode file filename.
+ * . Not sure if this becomes useful for language bindings.
+ */
+void 
+dia::ObjectType::save (Object* o, ObjectNode node, const char* filename) const
+{
+    assert (self);
+    self->ops->save (o->Self(), node, filename);
+}
+//! OPTIONAL: opens the defaults dialog
+GtkWidget* 
+dia::ObjectType::get_defaults () const
+{
+    assert (self);
+    if (!self->ops->get_defaults)
+        return 0;
+    return self->ops->get_defaults ();
+}
+//! OPTIONAL: apply changed defaults
+void 
+dia::ObjectType::apply_defaults ()
+{
+    assert (self);
+    self->ops->apply_defaults ();
+}
+
+//! create an object wrapper - object previously registered from a plug-in
+dia::Object::Object (DiaObject* o) : self(o), properties(o), connections(o), handles(o), type(o->type)
+{
+}
+//! destroy the right thing - usually not the underlying object
+dia::Object::~Object ()
+{
+}
+//! accessor to deliver the objects bounding box
+::_Rectangle*
+dia::Object::bbox () const
+{
+    return &self->bounding_box;
+}
+//! real destruction
+void 
+dia::Object::destroy ()
+{
+    assert (self);
+    self->ops->destroy (self);
+}
+//! drawing the object on the renderer
+void 
+dia::Object::draw (Renderer* r) const
+{
+    assert (self);
+#if 0 //FIXME: need to think about delegation
+    self->ops->draw (self, r);
+#endif
+}
+//! calculate the distance betwenn the object and the point
+double 
+dia::Object::distance_from (Point* p) const
+{
+    assert (self);
+    return self->ops->distance_from (self, p);
+}
+//! react on selection (e.g. may change the drawing state)
+void
+dia::Object::select (Point* clicked_point, DiaRenderer* interactive_renderer)
+{
+    assert (self);
+    self->ops->selectf (self, clicked_point, interactive_renderer);
+}
+//! create a deep copy
+dia::Object* dia::Object::copy () const
+{
+    assert (self);
+    return new dia::Object (self->ops->copy (self));
+}
+//! change position of the whole object
+ObjectChange* 
+dia::Object::move (double x, double y)
+{
+    assert (self);
+    Point p = {x, y};
+    return self->ops->move (self, &p);
+}
+//! change position of an object handle - this is usually  a resize (Attention: does *not* match the C prototype)
+ObjectChange* 
+dia::Object::move_handle (dia::Handle* h, double x, double y, HandleMoveReason reason, ModifierKeys modifiers)
+{
+    assert (self);
+    Point p = {x, y};
+    return self->ops->move_handle (self, h->Self(), &p, NULL, reason, modifiers);
+}
+//! OPTIONAL: provide a property dialog to change the object proeprties
+GtkWidget* 
+dia::Object::get_properties (bool is_default) const
+{
+    assert (self);
+    return self->ops->get_properties (self, is_default);
+}
+//! OPTIONAL: apply the properties changed in the dialog
+ObjectChange* 
+dia::Object::apply_properties (GtkWidget* w)
+{
+    assert (self);
+    return self->ops->apply_properties (self, w);
+}
+//! OPTIONAL: provide a context menu to change the object states
+DiaMenu* 
+dia::Object::get_object_menu (Point* pos) const
+{
+    assert (self);
+    return self->ops->get_object_menu (self, pos);
+}
+    
+//! StdProps: descibe properties accessible via standard properties API
+const PropDescription* 
+dia::Object::describe_props () const
+{
+    assert (self);
+    return self->ops->describe_props (self);
+}
+//! StdProps: return a list of properties describing the object state
+void 
+dia::Object::get_props (GPtrArray *props) const
+{
+    assert (self);
+    self->ops->get_props (self, props);
+}
+//! StdProps: apply a list of object properties to change the objects state
+void 
+dia::Object::set_props (GPtrArray *props)
+{
+    assert (self);
+    self->ops->set_props (self, props);
+}
+
+/*!
+ * \brief factory function for ObjectType (Object factories)
+ *
+ * Before this function can return anything useful the ObjectType registry needs to be filled,
+ * e.g. by dia::register_plugins()
+ */
+dia::ObjectType*
+dia::get_object_type (const char* name)
+{
+    ::DiaObjectType* ot = object_get_type(const_cast<char*>(name));
+    if (ot)
+        return new dia::ObjectType (ot);
+    return 0;
+}

--- /dev/null
+++ b/bindings/dia-object.h
@@ -0,0 +1,111 @@
+/*
+ * C++ interface of DiaObject - just to have something clean to wrap
+ *
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+#ifndef DIA__OBJECT_H
+#define DIA__OBJECT_H
+
+#include "dia-properties.h"
+#include "dia-connections.h"
+
+namespace dia {
+
+//! forward declare
+class Object;
+class Renderer;
+
+/*!
+ * \brief ObjectType is the factoy to create Object
+ *
+ * To get on all registered ObjectType use dia::registered_types() to create one specific Object 
+ * factory use dia::get_object_type()
+ */
+class ObjectType
+{
+public :
+    //! one-time initialized read-only
+    const char* name;
+    //! instead of doing this I'd like better accessor support in SWIG
+    const int version;
+
+    //! construct from underlying type
+    ObjectType (::DiaObjectType* ot);
+    //! create a default initialized object 
+    Object* create (double x, double y, dia::Handle** h1 = 0, dia::Handle** h2 = 0) const;
+    //! load an object from storage
+    Object* load (ObjectNode node, int version, const char* filename) const;
+    //! save an object to file filename
+    void save (Object* o, ObjectNode node, const char* filename) const;
+    //! OPTIONAL: open the defaults dialog
+    GtkWidget* get_defaults () const;
+    //! OPTIONAL: apply changed defaults
+    void apply_defaults ();
+private :
+    ::DiaObjectType* self;     
+};
+
+/*!
+ * \brief The basic building block of diagrams
+ *
+ * This is a proxy class to objects coming from Dia's object factory. The latter is populate by all the objecct
+ * implementations from objects/*
+ */
+class Object
+{
+public :
+    //! trying to be compatible
+    const Properties properties;
+    //! access to this objects connection points
+    const Connections connections;
+    //! access to this objects Handles
+    const Handles handles;
+    //! the wrapped type (factory)
+    const ObjectType type;
+
+    //! direct property access
+    ::_Rectangle* bbox () const;
+    
+    //! create an object wrapper - object previously registered from a plug-in
+    Object (DiaObject*);
+    //! destroying the proxy, not the underlying object
+    ~Object ();
+    //! not to be wrapped - just used internally
+    DiaObject* Self() const { return self; }
+    //! real destruction
+    void destroy ();
+    //! drawing the object on the renderer
+    void draw (Renderer* r) const;
+    //! calculate the distance betwenn the object and the point
+    double distance_from (Point* p) const;
+    //! react on selection (e.g. may change the drawing state)
+    void select (Point* clicked_point, DiaRenderer* interactive_renderer);
+    //! create a deep copy
+    Object* copy () const;
+    //! change position of the whole object
+    ObjectChange* move (double x, double y);
+    //! change position of an object handle - this is usually  a resize (Attention: does *not* match the C prototype)
+    ObjectChange* move_handle (Handle* h, double x, double y, HandleMoveReason reason, ModifierKeys modifiers);
+
+    //! OPTIONAL: provide a property dialog to change the object proeprties
+    GtkWidget* get_properties (bool is_default) const;
+    //! OPTIONAL: apply the properties changed in the dialog
+    ObjectChange* apply_properties (GtkWidget*);
+    //! OPTIONAL: provide a context menu to change the object states
+    DiaMenu* get_object_menu (Point* pos) const;
+    
+    //! StdProps: descibe properties accessible via standard properties API
+    const PropDescription* describe_props () const;
+    //! StdProps: return a list of properties describing the object state
+    void get_props (GPtrArray *props) const;
+    //! StdProps: apply a list of object properties to change the objects state
+    void set_props (GPtrArray *props);
+private :
+   DiaObject* self;
+};
+
+//! factory function to get on the ObjectType
+ObjectType* get_object_type (const char* name);
+
+} // namespace dia
+#endif /* DIA__OBJECT_H */

--- /dev/null
+++ b/bindings/dia-properties.cpp
@@ -0,0 +1,525 @@
+/*
+ * C++ implementation of Dia Properties - just to have something clean to wrap
+ *
+ * Copyright (C) 2007, Hans Breuer, <[e-mail]>
+ *
+ * This 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 "properties.h"
+// need access to property internals
+#include "prop_inttypes.h"
+#include "prop_geomtypes.h"
+#include "prop_attr.h"
+#include "prop_text.h"
+#include "prop_sdarray.h"
+
+#include "object.h"
+#include <assert.h>
+#include <string>
+
+#include "dia-properties.h"
+#include "dia-object.h"
+
+dia::Property<::Property*>::Property (::Property* p) : self(p) 
+{
+}
+
+//! read-only attribute; the name of the property; at least unique within an object, but supposed to be unique global 
+const char* 
+dia::Property<::Property*>::get_name () const
+{
+    if (self)
+        return self->name;
+    return "<null>::name";
+}
+//! read-only attribute giving the data type represented
+const char* 
+dia::Property<::Property*>::get_type () const
+{
+    if (self)
+        return self->type;
+    return "<null>::type";
+}
+/*!
+ * \brief getter depending on the type of the property
+ *
+ * This is supposed to deliver very different types - which is not possible in a strongly type language.
+ * We could either have various accessors like:
+ *     template<class T> bool Property::get_value<T>(T*);
+ * an wrap them into one Property.value for runtime typed languages or ... ?
+ */
+bool 
+dia::Property<::Property*>::get (int* v) const
+{
+    g_return_val_if_fail (self != NULL, false);
+    bool ret = true;
+    
+    if (strcmp (self->type, PROP_TYPE_BOOL) == 0)
+	*v = ((BoolProperty *)self)->bool_data;
+    else if (strcmp (self->type, PROP_TYPE_INT) == 0)
+	*v = ((IntProperty *)self)->int_data;
+    else if (strcmp (self->type, PROP_TYPE_ENUM) == 0)
+	*v = ((EnumProperty *)self)->enum_data;
+    else
+        ret = false;
+
+    return ret;
+}
+//! getter for double
+bool 
+dia::Property<::Property*>::get (double* v) const
+{
+    g_return_val_if_fail (self != NULL, false);
+    if (strcmp (self->type, PROP_TYPE_REAL) == 0) {
+	*v = ((RealProperty *)self)->real_data;
+	return true;
+    }
+    return false;
+}
+//! getter for string
+bool 
+dia::Property<::Property*>::get (const char** v) const
+{
+    g_return_val_if_fail (self != NULL, false);
+    if (strcmp (self->type, PROP_TYPE_STRING) == 0) {
+	*v = ((StringProperty*)self)->string_data;
+	if (*v == NULL)
+	  *v = "";
+	return true;
+    }
+    return false;
+}
+//! Now it starts to become ugly: isn't there a better way with SWIG to map one to may types?
+bool 
+dia::Property<::Property*>::get (::_Point* v) const 
+{ 
+    g_return_val_if_fail (self != NULL, false);
+    if (strcmp (self->type, PROP_TYPE_POINT) == 0) {
+	*v = ((PointProperty *)self)->point_data;
+	return true;
+    }
+    return false; 
+}
+//! almost complete ;)
+bool
+dia::Property<::Property*>::get (::_Rectangle* v) const 
+{ 
+    g_return_val_if_fail (self != NULL, false);
+    if (strcmp (self->type, PROP_TYPE_RECT) == 0) {
+	*v = ((RectProperty *)self)->rect_data;
+	return true;
+    }
+    return false; 
+}
+//! the final one
+bool
+dia::Property<::Property*>::get (const std::vector<IProperty*>** v) const 
+{ 
+    g_return_val_if_fail (self != NULL, false);
+    if (strcmp (self->type, PROP_TYPE_DARRAY) == 0) {
+	// remove everything from an earlier call
+	std::vector<IProperty*>::iterator it;
+	// remove const from our cache
+	std::vector<IProperty*>& vec = const_cast< std::vector<IProperty*>& >(_vec);
+	for (it = vec.begin(); it != vec.end(); ++it)
+	    delete *it;
+	vec.clear();
+
+	::ArrayProperty *prop = (::ArrayProperty *)self;
+
+	// now build with new values
+	int num_props = num_props = prop->ex_props->len;
+	for (int i = 0; i < prop->records->len; ++i) {
+	  ::Property* p = 0;
+	  vec.push_back (new dia::Property <Property*> (0));
+	}
+	*v = &vec;
+	return true;
+    }
+    return false; 
+}
+dia::Property<::Property*>::~Property ()
+{
+    std::vector<IProperty*>::iterator it;
+    for (it = _vec.begin(); it != _vec.end(); ++it)
+	delete *it;
+}
+
+/*!
+ * If there is still a property conversion missing it needs to be added
+ * in four places. In the implmentation dia-properties.cpp, in the 
+ * interface of this class and IProperty: dia-properties.h and finally 
+ * in the .swig file.
+ */
+bool
+dia::Property<::Property*>::get (::_Color* v) const 
+{ 
+    g_return_val_if_fail (self != NULL, false);
+    if (strcmp (self->type, PROP_TYPE_COLOUR) == 0) {
+	*v = ((ColorProperty *)self)->color_data;
+	return true;
+    }
+    return false; 
+}
+
+//! if the property is to be shown (in a dialog)
+bool 
+dia::Property<::Property*>::visible () const
+{
+    g_return_val_if_fail (self != NULL, false);
+    return !!(self->descr->flags & PROP_FLAG_VISIBLE);
+}
+
+dia::Properties::Properties (::DiaObject* o) : object(o)
+{
+}
+dia::Properties::~Properties ()
+{
+}
+
+//! is there a property of this name
+bool 
+dia::Properties::has_key (const char* name) const
+{
+    g_return_val_if_fail (object != NULL, false);
+    if (!object->ops->get_props)
+        return false;
+    ::Property *p = object_prop_by_name (object, name);
+    bool ret = (p != NULL);
+    if (p)
+      p->ops->free(p);
+    return ret;
+}
+static bool
+set_prop (::Property* p, int v)
+{
+    if (strcmp (p->type, PROP_TYPE_BOOL) == 0)
+	((BoolProperty *)p)->bool_data = (v != 0);
+    else if (strcmp (p->type, PROP_TYPE_INT) == 0)
+	((IntProperty *)p)->int_data = v;
+    else if (strcmp (p->type, PROP_TYPE_ENUM) == 0)
+	((EnumProperty *)p)->enum_data = v;
+    else
+        return false;
+    return true;
+}
+static bool
+set_prop (::Property* p, double v)
+{
+    if (strcmp (p->type, PROP_TYPE_REAL) == 0)
+	((RealProperty *)p)->real_data = v;
+    else
+        return false;
+    return true;
+}
+static bool
+set_prop (::Property* p, const char* v)
+{
+    if (strcmp (p->type, PROP_TYPE_COLOUR) == 0) {
+	PangoColor color;
+	if (pango_color_parse(&color, v)) {
+            ((ColorProperty*)p)->color_data.red = color.red / 65535.0; 
+            ((ColorProperty*)p)->color_data.green = color.green / 65535.0; 
+            ((ColorProperty*)p)->color_data.blue = color.blue / 65535.0;
+        }
+    }
+    else if (strcmp (p->type, PROP_TYPE_STRING) == 0) {
+	g_free (((StringProperty*)p)->string_data);
+        ((StringProperty*)p)->string_data = v ? g_strdup (v) : g_strdup ("");
+        ((StringProperty*)p)->num_lines = 1;
+    }
+    else if (strcmp (p->type, PROP_TYPE_TEXT) == 0) {
+	g_free (((TextProperty*)p)->text_data);
+        ((TextProperty*)p)->text_data = v ? g_strdup (v) : g_strdup ("");
+        /* XXX: update size calculation ? */
+    }
+    else
+        return false;
+    return true;
+}
+static bool
+set_prop (::Property* p, char* v)
+{
+    return set_prop (p, (const char*)v);
+}
+
+static bool
+set_prop (GPtrArray* to, ::ArrayProperty* kinds, int num, const std::vector<dia::IProperty*>&v)
+{
+    for (int i = 0; i < v.size() && i < num; ++i) { 
+        ::Property *ex = (::Property*)g_ptr_array_index(kinds->ex_props, i);
+	::Property* inner = ex->ops->copy(ex);
+	dia::IProperty *from = v[i];
+	int vi;
+	double vd;
+	const char* vcs;
+	char* vs;
+	const std::vector<dia::IProperty*>* vv;
+	
+	if (!from)
+	    /* nothing to do, alread initialized */;
+	else if (from->get (&vi))
+	    set_prop (inner, vi);
+	else if (from->get (&vd))
+	    set_prop (inner, vi);
+	else if (from->get (&vcs))
+	    set_prop (inner, vcs);
+	else if (from->get (&vs))
+	    set_prop (inner, vs);
+	else if (from->get (&vv)) {
+	    ArrayProperty* ap = (ArrayProperty*)inner;
+	    GPtrArray* record = g_ptr_array_new ();
+	    if (!ap->ex_props) { //FIXME: bug in bindings?
+	        // not sure if this is the right thing to do, reusing kinds
+		if (!set_prop (to, kinds, vv->size(), *vv))
+		{
+		    g_warning ("Type mismatch vector<>[%d] '%s'", vv->size(), ap->common.name);
+		    g_ptr_array_free (record, TRUE);
+		    return false;
+		}
+		return true;
+	    } else {
+	        set_prop (record, ap, ap->ex_props->len, *vv);
+	        g_ptr_array_add(ap->records, record);
+	    }
+	}
+        g_ptr_array_add(to, inner);
+    }
+    return true;
+}
+//! add a property of type int
+int 
+dia::Properties::setitem (const char* s, int n)
+{
+    g_return_val_if_fail (object != NULL, -1);
+    ::Property *p = object_prop_by_name (object, s);
+    if (p) {
+        bool apply = true;
+        if (!set_prop (p, n))
+            printf ("dia::Properties::setitem (%s, %d) type mismatch (%s)\n", s, n, p->type), apply = false;
+	if (apply) {
+	    GPtrArray *plist = prop_list_from_single (p);
+	    object->ops->set_props(object, plist);
+            prop_list_free (plist);
+	}
+	return 0;
+    }
+    printf ("dia::Properties::setitem (%s, %d) none such\n", s, n);
+    return -1;
+}
+//! add a property of type double
+int
+dia::Properties::setitem (const char* s, double n)
+{
+    g_return_val_if_fail (object != NULL, -1);
+    ::Property *p = object_prop_by_name (object, s);
+    if (p) {
+        bool apply = true;
+        if (!set_prop (p, n))
+            printf ("dia::Properties::setitem (%s, %f) type mismatch (%s)\n", s, n, p->type), apply = false;
+	if (apply) {
+	    GPtrArray *plist = prop_list_from_single (p);
+	    object->ops->set_props(object, plist);
+            prop_list_free (plist);
+	}
+	return 0;
+    }
+    printf ("dia::Properties::setitem (%s, %f) none such\n", s, n);
+    return -1;
+}
+//! add a property of type string
+int 
+dia::Properties::setitem (const char* s, const char* v)
+{
+    g_return_val_if_fail (object != NULL, -1);
+    //printf ("0x%08X->properties['%s'] = '%s'\n", object, s, v);
+    ::Property *p = object_prop_by_name (object, s);
+    if (p) {
+        bool apply = true;
+        if (!set_prop (p, v))
+            printf ("dia::Properties::setitem (%s, %s) type mismatch (%s)\n", s, v, p->type), apply = false;
+
+	if (apply) {
+	    GPtrArray *plist = prop_list_from_single (p);
+	    object->ops->set_props(object, plist);
+            prop_list_free (plist);
+	}
+	return 0;
+    }
+    printf ("dia::Properties::setitem (%s, %s) none such\n", s, v);
+    return -1;
+}
+//! add a property of type double list
+int 
+dia::Properties::setitem (const char* s, const std::vector<double>& v)
+{
+    g_return_val_if_fail (object != NULL, -1);
+    ::Property *p = object_prop_by_name (object, s);
+    if (p) {
+        bool apply = true;
+        if (strcmp (p->type, PROP_TYPE_COLOUR) == 0 && v.size() == 3) {
+            ((ColorProperty*)p)->color_data.red   = v[0]; 
+            ((ColorProperty*)p)->color_data.green = v[1]; 
+            ((ColorProperty*)p)->color_data.blue  = v[2];
+	}
+	else if (strcmp (p->type, PROP_TYPE_LINESTYLE) == 0 && v.size() == 2) {
+	    ((LinestyleProperty *)p)->style = (::LineStyle)(int)v[0];
+	    ((LinestyleProperty *)p)->dash = v[1];
+	}
+	else if (strcmp (p->type, PROP_TYPE_POINT) == 0 && v.size() == 2) {
+	    ((PointProperty *)p)->point_data.x = v[0];
+	    ((PointProperty *)p)->point_data.y = v[1];
+	}
+	else if (strcmp (p->type, PROP_TYPE_POINTARRAY) == 0) {
+	    PointarrayProperty *ptp = (PointarrayProperty *)p;
+	    int len = v.size() / 2;
+            g_array_set_size(ptp->pointarray_data,len);
+	    for (int i = 0; i < len; ++i) {
+	        ::Point pt = {v[(i<<1)], v[(i<<1)+1]};
+		g_array_index(ptp->pointarray_data,Point,i) = pt;
+	    }
+	}
+	else if (strcmp (p->type, PROP_TYPE_BEZPOINTARRAY) == 0) {
+            BezPointarrayProperty *ptp = (BezPointarrayProperty *)p;
+	    // in the folded list the (variable size!) data is packed. So we need to calculate the real length during unpacking
+	    int i = 0;
+	    g_array_set_size(ptp->bezpointarray_data, v.size() / 3); // worst case
+	    std::vector<double>::const_iterator it;
+	    for (it = v.begin(); it != v.end(); ++it) {
+	        ::BezPoint bpt;
+		g_return_val_if_fail ((int)(*it) >= ::BezPoint::BEZ_MOVE_TO && (int)(*it) <= ::BezPoint::BEZ_CURVE_TO, -1);
+		bpt.type = (int)(*it) == ::BezPoint::BEZ_MOVE_TO ? ::BezPoint::BEZ_MOVE_TO :
+		           (int)(*it) == ::BezPoint::BEZ_LINE_TO ? ::BezPoint::BEZ_LINE_TO : ::BezPoint::BEZ_CURVE_TO;
+		++it; bpt.p1.x = *it;
+		++it; bpt.p1.y = *it;
+	        if (bpt.type == ::BezPoint::BEZ_CURVE_TO) {
+		    ++it; bpt.p2.x = *it;
+		    ++it; bpt.p2.y = *it;
+		    ++it; bpt.p3.x = *it;
+		    ++it; bpt.p3.y = *it;
+		}
+		else {
+		    if (0 == i && bpt.type != ::BezPoint::BEZ_MOVE_TO)
+		        g_warning("First bezpoint must be BEZ_MOVE_TO");
+                    if (0 < i && bpt.type != ::BezPoint::BEZ_LINE_TO)
+                        g_warning("Further bezpoint must be BEZ_LINE_TO or BEZ_CURVE_TO");
+		    bpt.p2 = bpt.p3 = bpt.p1; // not strictly needed
+		}
+		g_array_index(ptp->bezpointarray_data,BezPoint,i) = bpt;
+		++i;
+	    }
+	    g_array_set_size(ptp->bezpointarray_data, i); // worst case
+	}
+	else
+            printf ("dia::Properties::setitem (%s, std::vector<double>) type or size (%d) mismatch (%s)\n", 
+	            s, static_cast<int>(v.size()), p->type), apply = false;
+	if (apply) {
+	    GPtrArray *plist = prop_list_from_single (p);
+	    object->ops->set_props(object, plist);
+            prop_list_free (plist);
+	}
+        return 0;
+    }
+    printf ("dia::Properties::setitem (%s, std::vector<double>&) none such\n", s);
+    return -1;
+}
+/*!
+ * \brief set a list of IProperty* which in itself may have std::vector<dia::IProperty*>
+ *
+ */
+int
+dia::Properties::setitem (const char* s, const std::vector<dia::IProperty*>& vec)
+{
+    g_return_val_if_fail (object != NULL, -1);
+    ::ArrayProperty *pvec = (ArrayProperty *)object_prop_by_name (object, s);
+    if (pvec) {
+        guint i, num_props = pvec->ex_props->len;
+	// clean the previos records
+	for (i = 0; i < pvec->records->len; ++i) {
+	    GPtrArray* record = (GPtrArray*)g_ptr_array_index(pvec->records, i);
+            for (int j = 0; j < num_props; ++j) {
+	        ::Property* inner = (::Property*)g_ptr_array_index(record,j);
+	        inner->ops->free(inner);
+            }
+            g_ptr_array_free(record, TRUE);
+        }
+        g_ptr_array_set_size(pvec->records, 0);
+        // and fill with new values
+        for (i = 0; i < vec.size(); ++i) {
+	    // we can only get lists here, every list gives a record and must match in size
+	    const std::vector<dia::IProperty*>* vv;
+	     
+	    if (vec[i]->get (&vv)) {
+	        if (vv->size() != num_props)
+	            g_warning ("dia::Properties::setitem() inner list of wrong size");
+		GPtrArray *record = g_ptr_array_new();
+		set_prop (record, pvec, num_props, *vv);
+                g_ptr_array_add(pvec->records, record);
+	     }
+	}
+	GPtrArray *plist = prop_list_from_single ((::Property*)pvec);
+        object->ops->set_props(object, plist);
+        prop_list_free (plist);
+
+	return true;
+    }
+    printf ("dia::Properties::setitem (%s, std::vector<std::IProperty*>&) none such\n", s);
+    return -1;
+}
+/*!
+ * \brief dictionary lookup for a property given by name
+ *
+ * It may be desired to make all these properties directly
+ * available as attribute, so instead of (Python)
+ * \code
+ *   w = o.properties["elem_width"].value
+ * \endcode
+ * one could write
+ * \code
+ *   w = o.elem_height
+ * \endcode
+ * OTOH this would remove the possibility to do reflection on 
+ * the properties, e.g. asking them for type and name. Also it 
+ * may produce namespace clashes for more common property names
+ * like 'name'.
+ */
+dia::IProperty* 
+dia::Properties::getitem (const char* name) const
+{
+    g_return_val_if_fail (object != NULL, 0);
+    ::Property *p = object_prop_by_name (object, name);
+    if (p)
+        return new dia::Property<::Property*>(p);
+    return 0;
+}
+
+//! give all the keys in this map
+std::vector<char*>
+dia::Properties::keys () const
+{
+    g_return_val_if_fail (object != NULL, _keys);
+    
+    if (!_keys.empty())
+        return _keys;
+    if (object->ops->describe_props) {
+        const PropDescription *desc = object->ops->describe_props(object);
+        for (int i = 0; desc[i].name; i++) {
+             if ((desc[i].flags & PROP_FLAG_WIDGET_ONLY) == 0)
+	         // conceptionally const, just building our cache
+	         const_cast<Properties*>(this)->_keys.push_back (const_cast<char*>(desc[i].name));
+	}
+    }
+    return _keys;
+}

--- /dev/null
+++ b/bindings/dia-properties.h
@@ -0,0 +1,225 @@
+/*
+ * C++ interface of Dia Properties - just to have something clean to wrap
+ *
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+#ifndef DIA__PROPERTIES_H
+#define DIA__PROPERTIES_H
+
+#include <string>
+#include <vector>
+
+#include "properties.h"
+
+namespace dia {
+
+/*!
+ * \brief Property is the representation of one attribute of an Object
+ *
+ * The abstract interface is needed to build a vector of Property. Real properties
+ * are implemented as template
+ */
+class IProperty
+{
+public :
+    //! to make delete delete the real thing
+    virtual ~IProperty () {}
+    //! getter depending on the type of the property
+    virtual bool get (int*) const { return false; }
+    //! the concrete implementation must deliver the underlying type
+    virtual bool get (double*) const { return false; }
+    //! and return true just for that one
+    virtual bool get (const char**) const { return false; }
+    //! \todo this seems to be needed due to SWIG's code generattion?
+    //! It gives: dia-properties.h(30): Warning(509): Overloaded get(char **) const is shadowed by
+    //! get(char const **) const at dia-properties.h:28.
+    //! but without it the setting of UMLClass:attributes and members does not work.
+    //! so before removing it check 'test.py --doc'
+    virtual bool get (char**) const { return false; }
+    //! Now it starts to become ugly: isn't there a better way with SWIG to map one to many types?
+    virtual bool get (::_Point* p) const { return false; }
+    //! one more ;)
+    virtual bool get (::_Rectangle* p) const { return false; }
+    //! and this one ...
+    virtual bool get (::_Color* p) const { return false; }
+
+    //! we can also handle vector<IProperty*>
+    virtual bool get (const std::vector<IProperty*>**) const { return false; }
+    
+    //! read-only attribute; the name of the property; at least unique within an object, but supposed to be unique global 
+    virtual const char* get_name () const = 0;
+    //! read-only attribute giving the data type represented
+    virtual const char* get_type () const = 0;
+    //! if the property is to be shown
+    virtual bool visible () const = 0;
+};
+/*!
+ * \brief To construct any Property type from its underlying type.
+ *
+ * This class is used to construct a more complex property and put it into a container of 
+ * properties without having access to the underlying ::Property type.
+ */
+template <class T>
+class Property : public IProperty
+{
+public :
+    //! construct from underlying data type
+    Property<T> (T v) : self(v) {}
+    //! the on get function which returns true, 
+    //! because the underlying type matches
+    virtual bool get (T* p) const { *p = self; return true; }
+    
+    //! read-only attribute; the name of the property; at least unique within an object, 
+    //! but supposed to be unique globally 
+    const char* get_name () const { return "<name>"; }
+    //! read-only attribute giving the data type represented
+    const char* get_type () const { return "<type>"; }
+    //! if the property is to be shown
+    bool visible () const { return false; }
+private :
+    T self;
+};
+
+inline bool Property<int>::get (int* p) const 
+{ 
+  *p = self; return true; 
+}
+inline bool Property<double>::get (double* p) const 
+{ 
+  *p = self; return true; 
+}
+inline Property<const char*>::Property (const char* v) 
+{ 
+  self = v ? g_strdup (v) : g_strdup(""); 
+}
+inline bool Property<const char*>::get (const char** p) const 
+{ 
+  *p = self; return true; 
+}
+inline Property<char*>::Property (char* v) 
+{ 
+  self = v ? g_strdup (v) : g_strdup(""); 
+}
+inline bool Property<char*>::get (char** p) const 
+{ 
+  *p = self; return true; 
+}
+
+/*!
+ * \brief specialization for getter; a Property from underlying ::Property
+ *
+ * The Dia Property System can handle various kinds of properties from simple int
+ * over Point and Rectangle up to whole Property lists and trees. This class is 
+ * used to get or read a property from its underlying type.
+ */
+template<>
+class Property<::Property*> : public IProperty
+{
+public :
+    //! construct from underlying object
+    Property (::Property* p);
+    //! destroy chache
+    ~Property ();
+
+    //! getter depending on the type of the property
+    virtual bool get (int*) const;
+    //! the concrete implementation must deliver the underlying type
+    virtual bool get (double*) const;
+    //! and return true just for that one
+    virtual bool get (const char**) const;
+    //! just one wrapper too much ;)
+    virtual bool get (::_Point* p) const;
+    //! one more ;)
+    virtual bool get (::_Rectangle* p) const;
+    //! and this one ...
+    virtual bool get (::_Color* p) const;
+    //! we can also handle vector<IProperty*>
+    virtual bool get (const std::vector<IProperty*>**) const;
+
+
+    //! read-only attribute; the name of the property; at least unique within an object, but supposed to be unique global 
+    const char* get_name () const;
+    //! read-only attribute giving the data type represented
+    const char* get_type () const;
+    //! if the property is to be shown
+    bool visible () const;
+private :
+    ::Property* self;
+    // this is ugly but otherwise we would have an unbound leak
+    std::vector<IProperty*> _vec;
+};
+/*!
+ * \brief a list of properties; can contain list again so in fact it can be a tree
+ *
+ * Some Object Properties consist of Property lists or even property trees. This is the basic 
+ * building block for these complex properties. See 'UML - Class'::operations for an example.
+ */
+template<>
+class Property< std::vector<IProperty*> > : public IProperty, public std::vector<IProperty*>
+{
+public :
+    //! create an empty list
+    Property () {}
+    //! empty our list knd of 'deep delete'
+    ~Property ()
+    {
+	std::vector<IProperty*>::iterator it;
+
+	for (it = begin(); it != end(); ++it)
+		delete *it;
+    }
+    //! get us self
+    virtual bool get (const std::vector<IProperty*>** p) const 
+    {
+        *p = this;
+	return true;
+    }
+    //! read-only attribute; the name of the property; at least unique within an object, but supposed to be unique global 
+    const char* get_name () const { return ""; }
+    //! read-only attribute giving the data type represented
+    const char* get_type () const { return "vector<IProperty*>"; }
+    //! if the property is to be shown
+    bool visible () const { return false; }
+};
+/*!
+ * \brief A container for Property, merely a fassade to make a group of properties more accessible
+ *
+ * In Python this is mapped to the dictionary type, accessing a specific property is done by
+ * a key lookup with it's name.
+ *
+ * To modify an objects property it is needed to modify it's dictionary. This is due to the fact
+ * that single properties don't have a connection to a specific object but the property map has.
+ */
+class Properties
+{
+public :
+    //! construct with/from owning object
+    Properties (::DiaObject*);
+    //! destroy the wrapper
+    ~Properties ();
+    /* accessors like Python dictionary */
+    //! is there a property of this name
+    bool has_key (const char*) const;
+    
+    //! add a property of type int
+    int setitem (const char*, int);
+    //! add a property of type double
+    int setitem (const char*, double);
+    //! add a property of type string
+    int setitem (const char*, const char*);
+    //! add a property of type double list
+    int setitem (const char*, const std::vector<double>&);
+    //! add a property list - intented as final falback
+    int setitem (const char* s, const std::vector<IProperty*>& vec);
+    //! return back a single property
+    IProperty* getitem (const char*) const;
+    //! give all the keys in this map
+    std::vector<char*> keys () const;
+private :
+    ::DiaObject* object; //!< the owner of the properties
+    
+    std::vector<char*> _keys; //!< lazy created
+};
+
+} // namespace dia
+#endif /* DIA__PROPERTIES_H */

--- /dev/null
+++ b/bindings/dia-python-extra.cpp
@@ -0,0 +1,125 @@
+/* 
+ * some helper function not to pollute the multilingual dia.swig file 
+ *
+ * Implementation Note: this file should not deal with Dia's Type's but only with some
+ * conversions from complex Python types to std::types 
+ *
+ * Copyright (C) 2007, Hans Breuer, <[e-mail]>
+ *
+ * This 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 <Python.h>
+#include <assert.h>
+
+#include "dia-python-extra.h"
+
+/* 
+ * \brief Try to convert a 'nested' Python Object into a flat vector.
+ *
+ * With templates not working that well betwenn SWIG and msvc6 here's some manual conversion.
+ * Basically this is 'unrolling' tuples and lists to a flat std::vector and delegating that 
+ * to the C++ object, which than converts again to the concrete properties type.
+ * As a short-cut int is converted to double if the first or last element is a double.
+ * Yes I know this code is ugly. Let's see if other language binders do better ;)
+  */
+bool 
+DiaPythonExtra_ToVector (PyObject* v, std::vector<double>& vec)
+{
+    if ((PyList_Check(v) && PyList_Size(v) > 0) || (PyTuple_Check(v) && PyTuple_Size(v) > 0)) {
+        bool isList = PyList_Check(v);
+	int size = isList ? PyList_Size(v) : PyTuple_Size (v);
+	
+	for (int i = 0; i < size; ++i) {
+	    PyObject *a = isList ? PyList_GetItem(v, i) : PyTuple_GetItem (v, i);
+	    if (PyFloat_Check(a) || PyInt_Check(a))
+	        vec.push_back (PyFloat_Check(a) ? PyFloat_AsDouble(a) : PyInt_AsLong(a));
+	    else if (PyTuple_Check (a)) {
+	        for (int j = 0; j < PyTuple_Size (a); ++j) {
+	            PyObject* b = PyTuple_GetItem (a, j);
+		    if (!PyFloat_Check(b) && !PyInt_Check (b))
+		        return false; // wrong type
+	            vec.push_back (PyFloat_Check(b) ? PyFloat_AsDouble(b) : PyInt_AsLong(b));
+	        }
+	    } else {
+	        return false; // only one level of nesting supported
+	    }
+	}
+	return true;
+    }
+    return false;
+}
+
+/*!
+ * \brief recursive function doing the real conversion work for tree<IProperty*>
+ *
+ * \return false on no vector input
+ */
+static bool
+_ToVector (PyObject* v, std::vector<dia::IProperty*>& vec)
+{
+    bool isList = PyList_Check(v);
+    bool isTuple = PyTuple_Check(v);
+ 
+    if (isList || isTuple) {
+	int len = isList ? PyList_Size(v): PyTuple_Size(v);
+
+	for (int i = 0; i < len; ++i) {
+            PyObject *o = isList ? PyList_GetItem(v, i) : PyTuple_GetItem(v, i);
+	    if (PyString_Check (o))
+		vec.push_back (new dia::Property<char*>(PyString_AsString (o)));
+	    else if (PyUnicode_Check (o)) 
+	    {
+		PyObject *uval = PyUnicode_AsUTF8String (o);
+		vec.push_back (new dia::Property<char*>(PyString_AsString(uval)));
+		Py_DECREF (uval); 
+	    }
+	    else if (PyList_Check(o) || PyTuple_Check(o)) {
+	        // dive into
+	        dia::Property< std::vector<dia::IProperty*> >* inner = 
+			new dia::Property< std::vector<dia::IProperty*> >();
+	        _ToVector (o, *inner); 
+		vec.push_back (inner);
+	    } else if (PyInt_Check(o))
+		vec.push_back (new dia::Property<int>(PyInt_AsLong (o)));
+	    else if (PyFloat_Check (o))
+		vec.push_back (new dia::Property<double>(PyFloat_AsDouble (o)));
+	    else if (Py_None == o)
+		vec.push_back (0);
+	    else
+	    {
+		PyObject* s = PyObject_Str (o);
+		printf ("_ToVector() : no conversion for '%s'\n", PyString_AsString (s));
+	    }
+	}
+	return true;
+    }
+    return false;
+}
+
+/*!
+ * \brief Generic way to create a property vector/tree
+ *
+ * To allow the assignment of complex properties built from native language
+ * types some binding language specific support is needed.
+ */
+bool 
+DiaPythonExtra_ToVector (PyObject* v, std::vector<dia::IProperty*>& vec)
+{
+    // we can deal handle empty lists/tuples as well
+    if (PyList_Check(v) || PyTuple_Check(v))
+        return _ToVector (v, vec);
+    return false;
+}

--- /dev/null
+++ b/bindings/dia-python-extra.h
@@ -0,0 +1,17 @@
+/*
+ * some helper function not to pollute the multilingual dia.swig file 
+ *
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+#ifndef DIA__PYTHON_EXTRA_H
+#define DIA__PYTHON_EXTRA_H
+
+#include <vector>
+#include <string>
+
+#include "dia-properties.h"
+
+bool DiaPythonExtra_ToVector (PyObject*, std::vector<double>& vec);
+bool DiaPythonExtra_ToVector (PyObject*, std::vector<dia::IProperty*>& vec);
+
+#endif /* DIA__PYTHON_EXTRA_H */
\ No newline at end of file

--- /dev/null
+++ b/bindings/dia-renderer.cpp
@@ -0,0 +1,283 @@
+/*
+ * C++ interface of DiaRenderer - just to have something clean to wrap
+ *
+ * Copyright (C) 2007, Hans Breuer, <[e-mail]>
+ *
+ * This 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 "diarenderer.h"
+#include <assert.h>
+
+#include "object.h"
+#include "dia-object.h"
+
+#include "dia-renderer.h"
+
+// return width in pixels, only for interactive renderers
+int 
+dia::Renderer::get_width_pixels () const
+{
+    assert (self);
+    return DIA_RENDERER_GET_CLASS(self)->get_width_pixels (self);
+}
+//  return width in pixels, only for interactive renderers
+int 
+dia::Renderer::get_height_pixels () const
+{
+    assert (self);
+    return DIA_RENDERER_GET_CLASS(self)->get_height_pixels (self);
+}
+// simply calls the objects draw function, which calls this again
+void 
+dia::Renderer::draw_object (Object* o)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_object (self, o->Self());
+}
+// Returns the EXACT width of text in cm, using the current font.
+double 
+dia::Renderer::get_text_width (const gchar *text, int length) const
+{
+    assert (self);
+    return DIA_RENDERER_GET_CLASS(self)->get_text_width (self, text, length);
+}
+// called before any rendering takes palce
+void 
+dia::Renderer::begin_render ()
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->begin_render (self);
+}
+// finished rendering
+void 
+dia::Renderer::end_render ()
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->end_render (self);
+}
+// set current linewidth
+void 
+dia::Renderer::set_linewidth (double w)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->set_linewidth (self, w);
+}
+// set current linecaps
+void 
+dia::Renderer::set_linecaps (LineCaps mode)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->set_linecaps (self, mode);
+}
+// set current linejoin
+void 
+dia::Renderer::set_linejoin (LineJoin join)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->set_linejoin (self, join);
+}
+// set current linestyle
+void 
+dia::Renderer::set_linestyle (LineStyle style)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->set_linestyle (self, style);
+}
+// set current dashlength
+void 
+dia::Renderer::set_dashlength (double length)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->set_dashlength (self, length);
+}
+// set current font
+void 
+dia::Renderer::set_font (Font* font, double height)
+{
+    assert (self);
+    //FIXME: implement
+}
+// Draw a line from start to end, using color and the current line style
+void 
+dia::Renderer::draw_line (Point *start, Point *end, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_line (self, start, end, color);
+}
+// Fill a rectangle, given its upper-left and lower-right corners
+void 
+dia::Renderer::fill_rect (Point *ul_corner, Point *lr_corner, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->fill_rect (self, ul_corner, lr_corner, color);
+}
+// the polygon is filled using the current fill type, no border is drawn
+void 
+dia::Renderer::fill_polygon (Point *points, int num_points, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->fill_polygon (self, points, num_points, color);
+}
+// Draw an arc, given its center, the bounding box (widget, height), the start angle and the end angle
+void 
+dia::Renderer::draw_arc (Point *center, double width, double height,
+		         double angle1, double angle2,
+		         Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_arc (self, center, width, height, angle1, angle2, color);
+}
+// Same a DrawArcFunc except the arc is filled (a pie-chart)
+void 
+dia::Renderer::fill_arc (Point *center, double width, double height,
+		         double angle1, double angle2,
+		         Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->fill_arc (self, center, width, height, angle1, angle2, color);
+}
+// Draw an ellipse, given its center and the bounding box
+void 
+dia::Renderer::draw_ellipse (Point *center, double width, double height, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_ellipse (self, center, width, height, color);
+}
+// Same a DrawEllipse, except the ellips is filled
+void 
+dia::Renderer::fill_ellipse (Point *center, double width, double height, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->fill_ellipse (self, center, width, height, color);
+}
+// Print a string at pos, using the current font
+void 
+dia::Renderer::draw_string (const gchar *text, Point *pos, Alignment alignment, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_string (self, text, pos, alignment, color);
+}
+// Draw an image, given its bounding box
+void 
+dia::Renderer::draw_image (Point *point, double width, double height, Image* image)
+{
+    assert (self);
+    //FIXME: DIA_RENDERER_GET_CLASS(self)->draw_image (self, point, width, height, image);
+}
+
+// draw a bezier line - possibly as approximation consisting of straight lines
+void 
+dia::Renderer::draw_bezier (BezPoint *points, int numpoints, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_bezier (self, points, numpoints, color);
+}
+// fill a bezier line - possibly as approximation consisting of a polygon
+void 
+dia::Renderer::fill_bezier (BezPoint *points, int numpoints, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->fill_bezier (self, points, numpoints, color);
+}
+// drawing a polyline - or fallback to single line segments
+void 
+dia::Renderer::draw_polyline (Point *points, int num_points, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_polyline (self, points, num_points, color);
+}
+// Draw a polygone, using the current line style
+void 
+dia::Renderer::draw_polygon (Point *points, int num_points, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_polygon (self, points, num_points, color);
+}
+// draw a Text.  It holds its own information like position, style, ...
+void 
+dia::Renderer::draw_text (Text* text)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_text (self, text);
+}
+// Draw a rectangle, given its upper-left and lower-right corners
+void 
+dia::Renderer::draw_rect (Point *ul_corner, Point *lr_corner, Color *color)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_rect (self, ul_corner, lr_corner, color);
+}
+// a polyline with round coners
+void 
+dia::Renderer::draw_rounded_polyline (Point *points, int num_points, Color *color, double radius )
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_rounded_polyline (self, points, num_points, color, radius);
+}
+// specialized draw_rect() with round corners
+void 
+dia::Renderer::draw_rounded_rect (Point *ul_corner, Point *lr_corner, Color *color, real radius)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_rounded_rect (self, ul_corner, lr_corner, color, radius);
+}
+// specialized draw_rect() with round corners
+void 
+dia::Renderer::fill_rounded_rect (Point *ul_corner, Point *lr_corner, Color *color, real radius)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->fill_rounded_rect (self, ul_corner, lr_corner, color, radius);
+}
+// specialized draw_line() for renderers with an own concept of Arrow
+void 
+dia::Renderer::draw_line_with_arrows  (Point *start, Point *end, real line_width, Color *line_color, 
+                                       Arrow *start_arrow, Arrow *end_arrow)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_line_with_arrows (self, start, end, line_width, line_color, start_arrow, end_arrow);
+}
+// specialized draw_line() for renderers with an own concept of Arrow
+void 
+dia::Renderer::draw_arc_with_arrows  (Point *start, Point *end, Point *midpoint, real line_width, Color *color,
+                                      Arrow *start_arrow, Arrow *end_arrow)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_arc_with_arrows (self, start, end, midpoint, line_width, color, start_arrow, end_arrow);
+}
+// specialized draw_polyline() for renderers with an own concept of Arrow
+void 
+dia::Renderer::draw_polyline_with_arrows (Point *points, int num_points, real line_width, Color *color,
+                                          Arrow *start_arrow, Arrow *end_arrow)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_polyline_with_arrows (self, points, num_points, line_width, color, start_arrow, end_arrow);
+}
+// specialized draw_rounded_polyline() for renderers with an own concept of Arrow
+void 
+dia::Renderer::draw_rounded_polyline_with_arrows (Point *points, int num_points, real line_width, Color *color,
+					          Arrow *start_arrow, Arrow *end_arrow, real radius)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_rounded_polyline_with_arrows (self, points, num_points, line_width, color, start_arrow, end_arrow, radius);
+}
+// specialized draw_bezier() for renderers with an own concept of Arrow
+void 
+dia::Renderer::draw_bezier_with_arrows (BezPoint *points, int num_points, real line_width, Color *color,
+                                        Arrow *start_arrow, Arrow *end_arrow)
+{
+    assert (self);
+    DIA_RENDERER_GET_CLASS(self)->draw_bezier_with_arrows (self, points, num_points, line_width, color, start_arrow, end_arrow);
+}

--- /dev/null
+++ b/bindings/dia-renderer.h
@@ -0,0 +1,170 @@
+/*
+ * C++ interface of DiaRenderer - just to have something clean to wrap
+ *
+ * Copyright 2007, Hans Breuer, GPL, see COPYING
+ */
+#ifndef DIA__RENDERER_H
+#define DIA__RENDERER_H
+
+namespace dia {
+
+//! forward declare
+class Object;
+class Image;
+class Font;
+
+/*!
+ * \brief Renderer provides functions to draw Object by their simple geometrics
+ *
+ * This class is not very useful until one wants to implement an Object in the target
+ * language. Than it is needed to abstract away the the real drawing to different
+ * backends from the drawing code in Object::draw(Renderer*).
+ * Another use-case may be a unit test where single renderers functions chould be
+ * tested. For both cases a renderer factory function would be needed.
+ */
+class Renderer
+{
+public :
+    /// \defgroup InteractiveRenderer The 'interactive' renderer interface
+    /// IIRC this functions are only supported by interactive renderers
+
+    //! return width in pixels, only for interactive renderers
+    //! \ingroup InteractiveRenderer
+    virtual int get_width_pixels () const;
+    //!  return width in pixels, only for interactive renderers
+    //! \ingroup InteractiveRenderer
+    virtual int get_height_pixels () const;
+    
+    /// \defgroup RendererRequired Functions to be implemented by every Renderer
+    /// Not sure about this ;)
+
+    //! simply calls the objects draw function, which calls this again
+    //! \ingroup RendererRequired
+    virtual void draw_object (Object*);
+    //! Returns the EXACT width of text in cm, using the current font.
+    //! There has been some confusion as to the definition of this.
+    //! It used to say the width was in pixels, but actual width returned
+    //! was cm.  You shouldn't know about pixels anyway.
+    //! \ingroup RendererRequired
+    virtual double get_text_width (const gchar *text, int length) const;
+
+    //! called before any rendering takes palce
+    //! \ingroup RendererRequired
+    virtual void begin_render ();
+    //! finished rendering
+    //! \ingroup RendererRequired
+    virtual void end_render ();
+    //! set current line width
+    //! \ingroup RendererRequired
+    virtual void set_linewidth (double w);
+    //! set current ends
+    //! \ingroup RendererRequired
+    virtual void set_linecaps (LineCaps mode);
+    //! set current joining
+    //! \ingroup RendererRequired
+    virtual void set_linejoin (LineJoin join);
+    //! set current line style (dottet, dashed, solid)
+    //! \ingroup RendererRequired
+    virtual void set_linestyle (LineStyle style);
+    //! set current length for dashes
+    //! \ingroup RendererRequired
+    virtual void set_dashlength (double length);
+    //! set current font
+    //! \ingroup RendererRequired
+    //! \todo wrap font objecs ?
+    virtual void set_font (Font* font, double height);
+    //! Draw a line from start to end, using color and the current line style
+    //! \ingroup RendererRequired
+    virtual void draw_line (Point *start, Point *end, Color *color);
+    //! Fill a rectangle, given its upper-left and lower-right corners
+    //! \ingroup RendererRequired
+    virtual void fill_rect (Point *ul_corner, Point *lr_corner, Color *color);
+    //! the polygon is filled using the current fill type, no border is drawn
+    //! \ingroup RendererRequired
+    virtual void fill_polygon (Point *points, int num_points, Color *color);
+    //! Draw an arc, given its center, the bounding box (widget, height), the start angle and the end angle
+    //! \ingroup RendererRequired
+    virtual void draw_arc (Point *center, double width, double height,
+                           double angle1, double angle2,
+                           Color *color);
+    //! Same a DrawArcFunc except the arc is filled (a pie-chart)
+    //! \ingroup RendererRequired
+    virtual void fill_arc (Point *center, double width, double height,
+                           double angle1, double angle2,
+                           Color *color);
+    //! Draw an ellipse, given its center and the bounding box
+    //! \ingroup RendererRequired
+    virtual void draw_ellipse (Point *center, double width, double height, Color *color);
+    //! Same a DrawEllipse, except the ellips is filled
+    //! \ingroup RendererRequired
+    virtual void fill_ellipse (Point *center, double width, double height, Color *color);
+    //! Print a string at pos, using the current font
+    //! \ingroup RendererRequired
+    virtual void draw_string (const gchar *text, Point *pos, Alignment alignment, Color *color);
+    //! Draw an image, given its bounding box
+    //! \ingroup RendererRequired
+    virtual void draw_image (Point *point, double width, double height, Image* image);
+    
+    /// \defgroup RenderMedium Renderer Should Implemement This
+    /// Functions which SHOULD be implemented by specific renderer, but
+    /// have a default implementation based on the above functions
+
+    //! draw a bezier line - possibly as approximation consisting of straight lines
+    //! \ingroup RenderMedium
+    virtual void draw_bezier (BezPoint *points, int numpoints, Color *color);
+    //! fill a bezier line - possibly as approximation consisting of a polygon
+    //! \ingroup RenderMedium
+    virtual void fill_bezier (BezPoint *points, int numpoints, Color *color);
+    //! drawing a polyline - or fallback to single line segments
+    //! \ingroup RenderMedium
+    virtual void draw_polyline (Point *points, int num_points, Color *color);
+    //! Draw a polygone, using the current line style
+    //! \ingroup RenderMedium
+    virtual void draw_polygon (Point *points, int num_points, Color *color);
+    //! draw a Text.  It holds its own information like position, style, ...
+    //! \ingroup RenderMedium
+    virtual void draw_text (Text* text);
+    //! Draw a rectangle, given its upper-left and lower-right corners
+    //! \ingroup RenderMedium
+    virtual void draw_rect (Point *ul_corner, Point *lr_corner, Color *color);
+    
+    /// \defgroup RenderHigh Renderer Can Implement This
+    //! Highest level functions, probably only to be implemented by 
+    //! special 'high level' renderers which have a concept of arrows or rounded drawings
+
+    //! a polyline with round coners
+    //! \ingroup RenderHigh
+    virtual void draw_rounded_polyline (Point *points, int num_points, Color *color, double radius );
+    //! specialized draw_rect() with round corners
+    //! \ingroup RenderHigh
+    virtual void draw_rounded_rect (Point *ul_corner, Point *lr_corner, Color *color, real radius);
+    //! specialized draw_rect() with round corners
+    //! \ingroup RenderHigh
+    virtual void fill_rounded_rect (Point *ul_corner, Point *lr_corner, Color *color, real radius);
+    //! specialized draw_line() for renderers with an own concept of Arrow
+    //! \ingroup RenderHigh
+    virtual void draw_line_with_arrows  (Point *start, Point *end, real line_width, Color *line_color, 
+					 Arrow *start_arrow, Arrow *end_arrow);
+    //! specialized draw_line() for renderers with an own concept of Arrow
+    //! \ingroup RenderHigh
+    virtual void draw_arc_with_arrows  (Point *start, Point *end, Point *midpoint, real line_width, Color *color,
+					Arrow *start_arrow, Arrow *end_arrow);
+    //! specialized draw_polyline() for renderers with an own concept of Arrow
+    //! \ingroup RenderHigh
+    virtual void draw_polyline_with_arrows (Point *points, int num_points, real line_width, Color *color,
+					    Arrow *start_arrow, Arrow *end_arrow);
+    //! specialized draw_rounded_polyline() for renderers with an own concept of Arrow
+    //! \ingroup RenderHigh
+    virtual void draw_rounded_polyline_with_arrows (Point *points, int num_points, real line_width, Color *color,
+						    Arrow *start_arrow, Arrow *end_arrow, real radius);
+    //! specialized draw_bezier() for renderers with an own concept of Arrow
+    //! \ingroup RenderHigh
+    virtual void draw_bezier_with_arrows (BezPoint *points, int num_points, real line_width, Color *color,
+					  Arrow *start_arrow, Arrow *end_arrow);
+    
+private :
+    DiaRenderer* self;     
+};
+
+} // namespace dia
+#endif /* DIA__RENDERER_H */

--- /dev/null
+++ b/bindings/dia.swig
@@ -0,0 +1,369 @@
+%module dia
+%{
+#include "object.h"
+#include "diarenderer.h"
+#include "diagramdata.h"
+#include "filter.h"
+#include "plug-ins.h"
+#include "properties.h"
+
+// helper functions
+#ifdef SWIGPYTHON
+#include "dia-python-extra.h"
+#endif
+#include "dia-extra.h"
+
+// the wrapper headers
+#include "dia-properties.h"
+#include "dia-object.h"
+#include "dia-renderer.h"
+#include "dia-diagramdata.h"
+%}
+
+#define G_GNUC_CONST
+#define G_BEGIN_DECLS
+#define G_END_DECLS
+#define G_INLINE_FUNC
+// for SWIG these are the same types
+typedef char gchar;
+
+%ignore TYPES_H;
+%include "diatypes.h"
+
+// the renaming needs to be done before SWIG sees the declarations
+%rename(Rectangle) _Rectangle;
+// this should be merged with rectangle somehow
+%rename(IntRectangle) _IntRectangle;
+%rename(Point) _Point;
+%rename(BezPoint) _BezPoint;
+
+%ignore GEOMETRY_H;
+// and a bunch of other stuff not yet needed
+%ignore point_add;
+%ignore point_sub;
+%ignore point_dot;
+%ignore point_len;
+%ignore point_scale;
+%ignore point_rotate;
+%ignore point_normalize;
+%ignore point_get_perp;
+%ignore point_copy;
+%ignore point_add_scaled;
+%ignore point_convex;
+%ignore point_get_normed;
+%ignore point_copy_add_scaled;
+%ignore point_in_rectangle;
+%ignore rectangle_in_rectangle;
+%ignore rectangle_union;
+%ignore int_rectangle_union;
+%ignore rectangle_intersection;
+%ignore rectangle_intersects;
+%ignore rectangle_add_point;
+%ignore rectangle_equals;
+%ignore closest_to;
+%ignore distance_bez_seg_point;
+%ignore distance_point_point;
+%ignore distance_point_point_manhattan;
+%ignore distance_rectangle_point;
+%ignore distance_line_point;
+%ignore distance_polygon_point;
+%ignore distance_bez_line_point;
+%ignore distance_bez_shape_point;
+%ignore distance_ellipse_point;
+%ignore identity_matrix;
+%ignore mult_matrix;
+%ignore translate_matrix;
+%ignore rotate_matrix;
+%ignore transform_point;
+%ignore scale_matrix;
+%ignore xshear_matrix;
+%ignore yshear_matrix;
+%ignore dot2;
+%ignore line_coef;
+%ignore line_to_point;
+%ignore point_perp;
+%ignore fillet;
+%ignore point_cross;
+%ignore calculate_object_edge;
+%include "geometry.h"
+
+// again using the original header
+%nodefaultctor;        // Don't create default constructors
+%rename(ImportFilter) _DiaImportFilter;
+%rename(ExportFilter) _DiaExportFilter;
+%rename(CallbackFilter) _DiaCallbackFilter;
+%immutable; // the following are all read-only
+%include "filter.h"
+%clearnodefaultctor;   // Re-enable default constructors
+%mutable;
+
+%rename(Color) _Color;
+// redefinition - the original header 'color.h' is too ugly to parse
+struct _Color
+{
+   float red;
+   float green;
+   float blue;
+};
+
+#if 0 /* works for vc7.1, but not with vc6 and *not* for const char* ? 
+       * All the partial specialization needs to be avoided with vc6, no compiler support!
+       */
+%include "std_vector.i"
+using namespace std;
+namespace std {
+    %template(vectorString) vector<char*>;
+}
+#else
+#  ifdef SWIGPYTHON
+// after hours of trying starting with 'const std::vector<const char*>&' this one seems to work ...
+%typemap (out) std::vector<char*> {
+    int size = $1.size();
+    $result = PyList_New(size);
+    for (int i=0; i<size; i++)
+        PyList_SetItem($result,i,PyString_FromString ($1[i]));
+}
+#  endif
+#endif
+
+// hide the internal helper of all our wrapper clsses
+%ignore *::Self;
+
+%ignore dia::Property;
+%rename(Property) dia::IProperty;
+%include attribute.i
+%attribute(dia::IProperty, char*, type, get_type);
+%attribute(dia::IProperty, char*, name, get_name);
+%nodefaultctor;        // Don't create default constructors
+%include "dia-properties.h"
+%clearnodefaultctor;   // Re-enable default constructors
+
+// in general we can't handle any of our objects being NULL
+%include "constraints.i"
+%apply Pointer NONNULL { dia::IProperty * };
+%apply Pointer NONNULL { dia::Object * };
+%apply Pointer NONNULL { dia::Layer * };
+%apply Pointer NONNULL { dia::DiagramData * };
+
+// this is needed to make iteration via __getitem__ work, i.e. not returning None objects.
+// It tells SWIG to check every such pointer return and set/do the appropriate error/return.
+%typemap(ret) dia::Object*, dia::Handle*, dia::ConnectionPoint*, dia::Layer* {
+  if ($1 == NULL) {
+    PyErr_SetString (PyExc_IndexError, "not in list");
+    return NULL;
+  }
+}
+%typemap(ret) dia::IProperty*, dia::ObjectType* {
+  if ($1 == NULL) {
+    PyErr_SetString (PyExc_KeyError, "none such");
+    return NULL;
+  }
+}
+
+#ifdef SWIGPYTHON
+%extend dia::IProperty {
+   %immutable; 
+   PyObject* value;
+   %mutable;
+};
+%inline %{
+PyObject* dia_IProperty_value_get (dia::IProperty* self) {
+     int vi;
+     if (self->get (&vi)) return PyInt_FromLong(vi);
+     double vd;
+     if (self->get (&vd)) return PyFloat_FromDouble(vd);
+     const char* vcs;
+     if (self->get (&vcs)) return PyString_FromString(vcs);
+     char* vs; // not sure if this duplication const char* vs. char* is really needed
+     if (self->get (&vs)) return PyString_FromString(vs);
+     ::_Point vp;
+     if (self->get (&vp)) return SWIG_NewPointerObj(&vp, SWIGTYPE_p__Point, 0);
+     ::_Rectangle vr;
+     if (self->get (&vr)) return SWIG_NewPointerObj(&vr, SWIGTYPE_p__Rectangle, 0);
+     ::_Color vc;
+     if (self->get (&vc)) return SWIG_NewPointerObj(&vc, SWIGTYPE_p__Color, 0);
+     const std::vector<dia::IProperty*>* vecProp;
+     if (self->get (&vecProp)) {
+       const n = vecProp->size();
+       PyObject* ret = PyTuple_New(n);
+       for (int i = 0; i < n; ++i)
+         PyTuple_SetItem(ret, i, SWIG_NewPointerObj((*vecProp)[i], SWIGTYPE_p_dia__IProperty, 0));
+       return ret;
+     }
+
+     // generic fallback - not of much use if one is interested in value
+     return SWIG_NewPointerObj(self, SWIGTYPE_p_dia__IProperty, 0);
+}
+%}
+#endif
+
+// must do this 'by hand' cause all the std::map stuff doesn't work with msvc6
+%extend dia::Properties {
+  dia::IProperty* __getitem__(const char* s) { return self->getitem(s); }
+
+  void __setitem__(const char* s, int v) { self->setitem(s, v); }
+  void __setitem__(const char* s, double v) { self->setitem(s, v); }
+  void __setitem__(const char* s, const char* v) { self->setitem(s, v); }
+#ifdef SWIGPYTHON
+  void __setitem__(const char* s, PyObject* v) {
+    std::vector<double> vecDouble;
+    std::vector<dia::IProperty*> vecProp;
+    if (DiaPythonExtra_ToVector (v, vecDouble))
+	self->setitem (s, vecDouble);
+    else if (DiaPythonExtra_ToVector (v, vecProp))
+	self->setitem (s, vecProp);
+    else {
+        PyObject* vs = PyObject_Str (v);
+        printf ("NOT assigning '%s' = %s\n", s, PyString_AsString (vs));
+    }
+  }
+#endif
+};
+
+%nodefaultctor;        // Don't create default constructors
+%include "dia-connections.h"
+%clearnodefaultctor;   // Re-enable default constructors
+// again by hand: provide a Python compatible sequence interface
+%extend dia::Connections {
+  int __len__ () { return self->len(); }
+  dia::ConnectionPoint* __getitem__ (int n) { return self->getitem(n); }
+};
+%extend dia::Handles {
+  int __len__ () { return self->len(); }
+  dia::Handle* __getitem__ (int n) { return self->getitem(n); }
+};
+
+%attribute(dia::Handle, dia::ConnectionPoint*, connected_to, get_connected_to);
+%attribute(dia::ConnectionPoint, dia::Object*, object, get_object);
+%extend dia::Objects {
+  int __len__ () { return self->len(); }
+  dia::Object* __getitem__ (int n) { return self->getitem(n); }
+};
+
+%nodefaultctor;        // Don't create default constructors
+%ignore dia::Object::bbox;
+%include "dia-object.h"
+%clearnodefaultctor;   // Re-enable default constructors
+#ifdef SWIGPYTHON
+// there may be a target language independent way to do this but not w/o understanding typemaps ;)
+%extend dia::ObjectType {
+  // not only creates the object but also two handles to be returned
+  PyObject* create (double x, double y) {
+    PyObject* ret = PyTuple_New(3);
+    dia::Handle *h1, *h2;
+    dia::Object *o = self->create (x,y, &h1, &h2);
+    PyTuple_SetItem(ret,0,SWIG_NewPointerObj(o, SWIGTYPE_p_dia__Object, 0));
+    PyTuple_SetItem(ret,1,SWIG_NewPointerObj(h1, SWIGTYPE_p_dia__Handle, 0));
+    PyTuple_SetItem(ret,2,SWIG_NewPointerObj(h2, SWIGTYPE_p_dia__Handle, 0));
+    return ret;
+  }
+};
+%include attribute.i
+%attribute(dia::Object, _Rectangle, bounding_box, bbox);
+%extend dia::Object {
+  // convenience/compatibility taking the position as tuple
+  PyObject* move_handle (dia::Handle* h, PyObject* pos, int reason, int modifiers)
+  {
+    double x = PyFloat_AsDouble(PyTuple_GetItem (pos, 0));
+    double y = PyFloat_AsDouble(PyTuple_GetItem (pos, 1));
+    self->move_handle (h, x, y, (HandleMoveReason)reason, (ModifierKeys)modifiers);
+    Py_INCREF(Py_None);
+    return Py_None;
+  }
+};
+#endif
+
+%nodefaultctor;        // Don't create default constructors
+%include "dia-diagramdata.h"
+%clearnodefaultctor;   // Re-enable default constructors
+
+#if 0 // again no partial templates with msvc6
+%include "std_vector.i"
+%template(Layers) std::vector<const dia::Layer*>;
+#else
+%extend dia::Layers {
+  int __len__ () { return self->len(); }
+  dia::Layer* __getitem__ (int n) { return self->getitem(n); }
+};
+#endif
+
+%nodefaultctor;        // Don't create default constructors
+%include "dia-renderer.h"
+%clearnodefaultctor;   // Re-enable default constructors
+
+// afaik SWIG does not support cross language callbacks; so let's build one
+// NOTE: although renamed above we need to use the old name here
+%extend _DiaExportFilter {
+  // don't use 'export' as this produces nothing w/o warning
+  void do_export (dia::DiagramData *dia, const gchar *filename) {
+    self->export_func (dia->Self(), filename, filename, self->user_data);
+  }
+};
+
+%include "dia-extra.h"
+
+%ignore _ot_item;
+#ifdef SWIGPYTHON
+%inline %{
+// compatibility functions, just to leave the original plug-ins unchanged
+void register_import (const char* name, const char* ext, PyObject* user)
+{
+    printf ("dia.register_import ('%s', '%s', ...) faked.\n", name, ext);
+}
+void register_callback (const char* desc, const char* menu, PyObject* user)
+{
+    printf ("dia.register_import ('%s', '%s', ...) faked.\n", desc, menu);
+}
+void register_action (const char* desc, const char* action, const char* menu, PyObject* user)
+{
+    printf ("dia.register_action ('%s', <%s>'%s', ...) faked.\n", desc, action, menu);
+}
+//! callback to be applied on every object in the map
+static void
+_ot_item (gpointer key,
+          gpointer value,
+          gpointer user_data)
+{
+    gchar *name = (gchar *)key;
+    DiaObjectType *type = (DiaObjectType *)value;
+    PyObject *dict = (PyObject *)user_data;
+    PyObject *k, *v;
+
+    k = PyString_FromString(name);
+    v = SWIG_NewPointerObj(type, SWIGTYPE_p_dia__ObjectType, 0);
+    if (k && v)
+        PyDict_SetItem(dict, k, v);
+    Py_XDECREF(k);
+    Py_XDECREF(v);
+}
+PyObject* registered_types () 
+{
+    PyObject *dict = PyDict_New();
+    
+    object_registry_foreach(_ot_item, dict);
+
+    return dict;
+}
+%}
+#endif
+
+// as long as we are not dependending on app/* - which we dont want! - we need to 
+// fake Display to some extent to make old pydia plug-ins work
+%pythoncode %{
+class Display :
+    def add_update_all (self) :
+        pass
+class Diagram :
+    def __init__ (self) :
+        self.data = DiagramData ()
+    def display (self) :
+	return Display ()
+    def update_extents (self) :
+        self.data.update_extents ()
+    def flush (self) :
+        pass
+def new (s) :
+    return Diagram()
+def active_display () :
+    return Display()
+%}

--- /dev/null
+++ b/bindings/makefile.msc
@@ -0,0 +1,84 @@
+TOP = ..\..
+
+!INCLUDE $(TOP)\glib\build\win32\make.msc
+
+!IFNDEF DEBUG
+PYTHON = ..\..\..\python23
+#PYTHON = ..\..\..\python25
+EXTRALIBS = $(PYTHON)\libs\python23.lib user32.lib
+#EXTRALIBS = $(PYTHON)\Python-2.5\PC\VC6\python25.lib user32.lib
+!ELSE
+PYTHON = ..\..\..\python25
+EXTRALIBS = $(PYTHON)\Python-2.5\PC\VC6\python25_d.lib user32.lib
+!ENDIF
+
+INCLUDES = \
+	-I.. \
+	-I..\lib \
+	-I..\app
+
+SWIG_FLAGS = $(INCLUDES)
+
+# we don't depend on Gtk at runtime, but some dia headers need it at compile time
+CFLAGS = -FImsvc_recommended_pragmas.h \
+!IFDEF DEBUG
+	-D_DEBUG=1 \
+!ENDIF
+	-DHAVE_CONFIG_H $(INCLUDES) \
+	-I$(PYTHON)\include $(GLIB_CFLAGS) $(GTK2_CFLAGS) $(INTL_CFLAGS) \
+	$(LIBXML2_CFLAGS)
+
+CPPFLAGS = $(CFLAGS) -GX -GR -Zi
+
+EXTRALIBS = $(EXTRALIBS) $(LIBXML2_LIBS) $(INTL_LIBS) $(PANGO_LIBS) \
+	..\lib\libdia.lib ..\app\dia-app.lib
+
+GENERATED = \
+	dia-python.cpp \
+#	csharp\dia-csharp.cpp \
+#	csharp\*.cs \
+
+INTERFACES = \
+	dia.swig \
+	dia-properties.h \
+	dia-object.h \
+	dia-renderer.h \
+	dia-diagramdata.h \
+	dia-connections.h \
+
+OBJECTS = \
+        dia-connections.obj \
+	dia-properties.obj \
+	dia-object.obj \
+	dia-renderer.obj \
+	dia-diagramdata.obj \
+	\
+	dia-extra.obj \
+	\
+	dia-python-extra.obj
+
+all : \
+	_dia.pyd \
+	
+other : \
+	dia-csharp.cpp \
+	dia-xml.cpp \
+	dia-perl.cpp \
+
+dia-python.cpp : $(INTERFACES)
+	swig $(SWIG_FLAGS) -python -modern -extranative -c++ -o $*.cpp dia.swig
+
+dia-csharp.cpp : $(INTERFACES)
+	swig $(SWIG_FLAGS) -csharp -c++ -o csharp\$*.cpp dia.swig
+
+dia-xml.cpp : $(INTERFACES)
+	swig $(SWIG_FLAGS) -xml -c++ -o xml\$*.cpp dia.swig
+
+dia-perl.cpp : $(INTERFACES)
+	swig $(SWIG_FLAGS) -perl -c++ -o perl\$*.cpp dia.swig
+
+_dia.pyd : $(OBJECTS) dia-python.obj
+	$(CC) $(CFLAGS) -LD -Fe$@ $(OBJECTS) dia-python.obj $(LDFLAGS) $(EXTRALIBS) $(GLIB_LIBS)
+
+clean::
+	del _dia.pyd dia.py dia.pyc $(GENERATED)

--- /dev/null
+++ b/bindings/test.py
@@ -0,0 +1,133 @@
+import dia
+# a global object to make it changeable by main()
+format_extensions = ["wmf", "svg", "png"]
+
+def Dump () :
+	print dir(dia)
+
+	r = dia.Rectangle
+	print r, dir(r)
+	o = dia.Object
+	print o, dir(o)
+	rd = dia.Renderer
+	print rd, dir(rd)
+
+import sys
+sys.path.insert(0, r'd:\graph\dia2\python')
+sys.path.insert(0, r'..\plug-ins\python')
+
+import os
+os.environ["DIA_LIB_PATH"] = r"d:\graph\dia2\dia"
+dia.register_plugins()
+
+def Export (name, data) :
+	# write data to file, the format is choosen here
+	for ext in format_extensions :
+		ef = dia.filter_guess_export_filter (name + "." + ext)
+		if ef :
+			ef.do_export (data, name + "." + ext)
+			break
+	
+def Import () :
+	data = dia.DiagramData()
+	import diasvg_import
+	diasvg_import.import_svg (r"D:\graph\dia2\render-test.svg", data)
+
+	filename = "render-test-swig.svg"
+	ef = dia.filter_get_by_name ("svg")
+	if not ef :
+		print "Guessing ..."
+		ef = dia.filter_guess_export_filter ("dummy.png")
+		filename = "render-test-swig.png"
+
+	print ef, "\n", ef.description, "\n", dir(ef)
+
+	ef.do_export (data, filename)
+
+def Gx () :
+	data = dia.DiagramData()
+
+	import diagx
+	diagx.ImportXml (r'D:\data\work\camera\Dp70Camera.xml', data)
+	Export ("gx-test", data)
+
+def Doc () :
+	data = dia.DiagramData()
+
+	import pydiadoc
+	data = pydiadoc.autodoc_cb (data, 0)
+	Export ("pydiadoc", data)
+
+def Dox () :
+	data = dia.DiagramData()
+
+	import doxrev
+	#doxrev.import_file (r'D:\data\work\dev\include\obscam\xml\classOBS_1_1ICamera.xml', data)
+	doxrev.import_files (r'D:\data\work\dev\include\obscam\xml\classOBS_1_1ICamera.xml', data)
+	data.update_extents()
+	Export ("doxrev-test", data)
+
+def Types () :
+	data = dia.DiagramData()
+
+	import otypes
+	data = otypes.otypes_cb (data, 0)
+	Export ("otypes", data)
+
+def AObj () :
+	data = dia.DiagramData()
+
+	import aobjects
+	data = aobjects.aobjects_cb (data, 0)
+	Export ("aobjs", data)
+
+def Gen () :
+	data = dia.DiagramData()
+
+	import gendia
+	data = gendia.dia_generate_dia_cb (data, 0)
+	Export ("gendia", data)
+def DRaw () :
+	data = dia.DiagramData()
+	# create something interesting to save
+	if 0 :
+		import aobjects
+		data = aobjects.aobjects_cb (data, 0)
+	else :
+		import pydiadoc
+		data = pydiadoc.autodoc_cb (data, 0)
+	import diaraw
+	r = diaraw.DiaOutRenderer()
+	r.begin_render (data, "diaraw.dia")
+	r.end_render ()
+
+def Self () :
+	data = dia.DiagramData()
+	r = data.extents
+	try :
+		data.extents = r
+	except AttributeError, s :
+		print "Expected except", s, r.top, r.left
+
+for arg in sys.argv :
+	if '--dump' == arg : Dump ()
+	elif '--import' == arg : Import ()
+	elif '--gx' == arg : Gx ()
+	elif '--doc' == arg : Doc ()
+	elif '--dox' == arg : Dox ()
+	elif '--types' == arg : Types ()
+	elif '--aobj' == arg : AObj ()
+	elif '--gen' == arg : Gen ()
+	elif '--self' == arg : Self ()
+	elif '--draw' == arg : DRaw ()
+	elif '--all' == arg :
+		Dump()
+		Import()
+		Gx()
+		Doc()
+		Dox()
+		Types()
+		AObj ()
+		Gen()
+		DRaw()
+	else : format_extensions.insert(0, arg)