moving trunk for module inkscape

(bzr r1)

1 files changed, 863 insertions, 0 deletions

diff --git a/src/sp-ellipse.cpp b/src/sp-ellipse.cpp
new file mode 100644
index 000000000..b2b0f7b05
--- /dev/null
+++ b/src/sp-ellipse.cpp
@@ -0,0 +1,863 @@
+#define __SP_ELLIPSE_C__
+
+/*
+ * SVG <ellipse> and related implementations
+ *
+ * Authors:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Mitsuru Oka
+ *   bulia byak <buliabyak@users.sf.net>
+ *
+ * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+
+#include "libnr/n-art-bpath.h"
+#include "libnr/nr-path.h"
+#include "libnr/nr-matrix-fns.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "xml/repr.h"
+#include "attributes.h"
+#include "style.h"
+#include "display/curve.h"
+#include <glibmm/i18n.h>
+
+#include "sp-ellipse.h"
+
+#include "prefs-utils.h"
+
+/* Common parent class */
+
+#define noELLIPSE_VERBOSE
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+#define SP_2PI (2 * M_PI)
+
+#if 1
+/* Hmmm... shouldn't this also qualify */
+/* Whether it is faster or not, well, nobody knows */
+#define sp_round(v,m) (((v) < 0.0) ? ((ceil((v) / (m) - 0.5)) * (m)) : ((floor((v) / (m) + 0.5)) * (m)))
+#else
+/* we do not use C99 round(3) function yet */
+static double sp_round(double x, double y)
+{
+    double remain;
+
+    g_assert(y > 0.0);
+
+    /* return round(x/y) * y; */
+
+    remain = fmod(x, y);
+
+    if (remain >= 0.5*y)
+        return x - remain + y;
+    else
+        return x - remain;
+}
+#endif
+
+static void sp_genericellipse_class_init(SPGenericEllipseClass *klass);
+static void sp_genericellipse_init(SPGenericEllipse *ellipse);
+
+static void sp_genericellipse_update(SPObject *object, SPCtx *ctx, guint flags);
+
+static void sp_genericellipse_snappoints(SPItem const *item, SnapPointsIter p);
+
+static void sp_genericellipse_set_shape(SPShape *shape);
+static Inkscape::XML::Node *sp_genericellipse_write(SPObject *object, Inkscape::XML::Node *repr,
+                                                    guint flags);
+
+static gboolean sp_arc_set_elliptical_path_attribute(SPArc *arc, Inkscape::XML::Node *repr);
+
+static SPShapeClass *ge_parent_class;
+
+GType
+sp_genericellipse_get_type(void)
+{
+    static GType type = 0;
+    if (!type) {
+        GTypeInfo info = {
+            sizeof(SPGenericEllipseClass),
+            NULL,   /* base_init */
+            NULL,   /* base_finalize */
+            (GClassInitFunc) sp_genericellipse_class_init,
+            NULL,   /* class_finalize */
+            NULL,   /* class_data */
+            sizeof(SPGenericEllipse),
+            16,   /* n_preallocs */
+            (GInstanceInitFunc) sp_genericellipse_init,
+            NULL,   /* value_table */
+        };
+        type = g_type_register_static(SP_TYPE_SHAPE, "SPGenericEllipse", &info, (GTypeFlags)0);
+    }
+    return type;
+}
+
+static void sp_genericellipse_class_init(SPGenericEllipseClass *klass)
+{
+    SPObjectClass *sp_object_class = (SPObjectClass *) klass;
+    SPItemClass *item_class = (SPItemClass *) klass;
+    SPShapeClass *shape_class = (SPShapeClass *) klass;
+
+    ge_parent_class = (SPShapeClass*) g_type_class_ref(SP_TYPE_SHAPE);
+
+    sp_object_class->update = sp_genericellipse_update;
+    sp_object_class->write = sp_genericellipse_write;
+
+    item_class->snappoints = sp_genericellipse_snappoints;
+
+    shape_class->set_shape = sp_genericellipse_set_shape;
+}
+
+static void
+sp_genericellipse_init(SPGenericEllipse *ellipse)
+{
+    ellipse->cx.unset();
+    ellipse->cy.unset();
+    ellipse->rx.unset();
+    ellipse->ry.unset();
+
+    ellipse->start = 0.0;
+    ellipse->end = SP_2PI;
+    ellipse->closed = TRUE;
+}
+
+static void
+sp_genericellipse_update(SPObject *object, SPCtx *ctx, guint flags)
+{
+    if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
+        SPGenericEllipse *ellipse = (SPGenericEllipse *) object;
+        SPStyle const *style = object->style;
+        double const d = 1.0 / NR::expansion(((SPItemCtx const *) ctx)->i2vp);
+        double const em = style->font_size.computed;
+        double const ex = em * 0.5; // fixme: get from pango or libnrtype
+        ellipse->cx.update(em, ex, d);
+        ellipse->cy.update(em, ex, d);
+        ellipse->rx.update(em, ex, d);
+        ellipse->ry.update(em, ex, d);
+        sp_shape_set_shape((SPShape *) object);
+    }
+
+    if (((SPObjectClass *) ge_parent_class)->update)
+        ((SPObjectClass *) ge_parent_class)->update(object, ctx, flags);
+}
+
+#define C1 0.552
+
+/* fixme: Think (Lauris) */
+
+static void sp_genericellipse_set_shape(SPShape *shape)
+{
+    double cx, cy, rx, ry, s, e;
+    double x0, y0, x1, y1, x2, y2, x3, y3;
+    double len;
+    gint slice = FALSE;
+    gint i;
+
+    SPGenericEllipse *ellipse = (SPGenericEllipse *) shape;
+
+    if ((ellipse->rx.computed < 1e-18) || (ellipse->ry.computed < 1e-18)) return;
+    if (fabs(ellipse->end - ellipse->start) < 1e-9) return;
+
+    sp_genericellipse_normalize(ellipse);
+
+    cx = 0.0;
+    cy = 0.0;
+    rx = ellipse->rx.computed;
+    ry = ellipse->ry.computed;
+
+    // figure out if we have a slice, guarding against rounding errors
+    len = fmod(ellipse->end - ellipse->start, SP_2PI);
+    if (len < 0.0) len += SP_2PI;
+    if (fabs(len) < 1e-8 || fabs(len - SP_2PI) < 1e-8) {
+        slice = FALSE;
+        ellipse->end = ellipse->start + SP_2PI;
+    } else {
+        slice = TRUE;
+    }
+
+    NR::Matrix aff = NR::Matrix(NR::scale(rx, ry));
+    aff[4] = ellipse->cx.computed;
+    aff[5] = ellipse->cy.computed;
+
+    NArtBpath bpath[16];
+    i = 0;
+    if (ellipse->closed) {
+        bpath[i].code = NR_MOVETO;
+    } else {
+        bpath[i].code = NR_MOVETO_OPEN;
+    }
+    bpath[i].x3 = cos(ellipse->start);
+    bpath[i].y3 = sin(ellipse->start);
+    i++;
+
+    for (s = ellipse->start; s < ellipse->end; s += M_PI_2) {
+        e = s + M_PI_2;
+        if (e > ellipse->end)
+            e = ellipse->end;
+        len = C1 * (e - s) / M_PI_2;
+        x0 = cos(s);
+        y0 = sin(s);
+        x1 = x0 + len * cos(s + M_PI_2);
+        y1 = y0 + len * sin(s + M_PI_2);
+        x3 = cos(e);
+        y3 = sin(e);
+        x2 = x3 + len * cos(e - M_PI_2);
+        y2 = y3 + len * sin(e - M_PI_2);
+#ifdef ELLIPSE_VERBOSE
+        g_print("step %d s %f e %f coords %f %f %f %f %f %f\n",
+                i, s, e, x1, y1, x2, y2, x3, y3);
+#endif
+        bpath[i].code = NR_CURVETO;
+        bpath[i].x1 = x1;
+        bpath[i].y1 = y1;
+        bpath[i].x2 = x2;
+        bpath[i].y2 = y2;
+        bpath[i].x3 = x3;
+        bpath[i].y3 = y3;
+        i++;
+    }
+
+    if (slice && ellipse->closed) {
+        bpath[i].code = NR_LINETO;
+        bpath[i].x3 = 0.0;
+        bpath[i].y3 = 0.0;
+        i++;
+        bpath[i].code = NR_LINETO;
+        bpath[i].x3 = bpath[0].x3;
+        bpath[i].y3 = bpath[0].y3;
+        i++;
+    } else if (ellipse->closed) {
+        bpath[i-1].x3 = bpath[0].x3;
+        bpath[i-1].y3 = bpath[0].y3;
+    }
+
+    bpath[i].code = NR_END;
+    SPCurve *c = sp_curve_new_from_bpath(nr_artpath_affine(bpath, aff));
+    g_assert(c != NULL);
+
+    sp_shape_set_curve_insync((SPShape *) ellipse, c, TRUE);
+    sp_curve_unref(c);
+}
+
+static void sp_genericellipse_snappoints(SPItem const *item, SnapPointsIter p)
+{
+    SPGenericEllipse const *ge = SP_GENERICELLIPSE(item);
+
+    NR::Matrix const i2d = sp_item_i2d_affine(item);
+
+    /* Add the centre */
+    *p = NR::Point(ge->cx.computed, ge->cy.computed) * i2d;
+
+    // TODO: add the ends of radii
+}
+
+void
+sp_genericellipse_normalize(SPGenericEllipse *ellipse)
+{
+    ellipse->start = fmod(ellipse->start, SP_2PI);
+    ellipse->end = fmod(ellipse->end, SP_2PI);
+
+    if (ellipse->start < 0.0)
+        ellipse->start += SP_2PI;
+    double diff = ellipse->start - ellipse->end;
+    if (diff >= 0.0)
+        ellipse->end += diff - fmod(diff, SP_2PI) + SP_2PI;
+
+    /* Now we keep: 0 <= start < end <= 2*PI */
+}
+
+static Inkscape::XML::Node *sp_genericellipse_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+{
+    SPGenericEllipse *ellipse = SP_GENERICELLIPSE(object);
+
+    if (flags & SP_OBJECT_WRITE_EXT) {
+        if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
+            repr = sp_repr_new("svg:path");
+        }
+
+        sp_repr_set_svg_double(repr, "sodipodi:cx", ellipse->cx.computed);
+        sp_repr_set_svg_double(repr, "sodipodi:cy", ellipse->cy.computed);
+        sp_repr_set_svg_double(repr, "sodipodi:rx", ellipse->rx.computed);
+        sp_repr_set_svg_double(repr, "sodipodi:ry", ellipse->ry.computed);
+
+        if (SP_IS_ARC(ellipse))
+            sp_arc_set_elliptical_path_attribute(SP_ARC(object), SP_OBJECT_REPR(object));
+    }
+
+    if (((SPObjectClass *) ge_parent_class)->write)
+        ((SPObjectClass *) ge_parent_class)->write(object, repr, flags);
+
+    return repr;
+}
+
+/* SVG <ellipse> element */
+
+static void sp_ellipse_class_init(SPEllipseClass *klass);
+static void sp_ellipse_init(SPEllipse *ellipse);
+
+static void sp_ellipse_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
+static Inkscape::XML::Node *sp_ellipse_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
+static void sp_ellipse_set(SPObject *object, unsigned int key, gchar const *value);
+static gchar *sp_ellipse_description(SPItem *item);
+
+static SPGenericEllipseClass *ellipse_parent_class;
+
+GType
+sp_ellipse_get_type(void)
+{
+    static GType type = 0;
+    if (!type) {
+        GTypeInfo info = {
+            sizeof(SPEllipseClass),
+            NULL,   /* base_init */
+            NULL,   /* base_finalize */
+            (GClassInitFunc) sp_ellipse_class_init,
+            NULL,   /* class_finalize */
+            NULL,   /* class_data */
+            sizeof(SPEllipse),
+            16,   /* n_preallocs */
+            (GInstanceInitFunc) sp_ellipse_init,
+            NULL,   /* value_table */
+        };
+        type = g_type_register_static(SP_TYPE_GENERICELLIPSE, "SPEllipse", &info, (GTypeFlags)0);
+    }
+    return type;
+}
+
+static void sp_ellipse_class_init(SPEllipseClass *klass)
+{
+    SPObjectClass *sp_object_class = (SPObjectClass *) klass;
+    SPItemClass *item_class = (SPItemClass *) klass;
+
+    ellipse_parent_class = (SPGenericEllipseClass*) g_type_class_ref(SP_TYPE_GENERICELLIPSE);
+
+    sp_object_class->build = sp_ellipse_build;
+    sp_object_class->write = sp_ellipse_write;
+    sp_object_class->set = sp_ellipse_set;
+
+    item_class->description = sp_ellipse_description;
+}
+
+static void
+sp_ellipse_init(SPEllipse *ellipse)
+{
+    /* Nothing special */
+}
+
+static void
+sp_ellipse_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+{
+    if (((SPObjectClass *) ellipse_parent_class)->build)
+        (* ((SPObjectClass *) ellipse_parent_class)->build) (object, document, repr);
+
+    sp_object_read_attr(object, "cx");
+    sp_object_read_attr(object, "cy");
+    sp_object_read_attr(object, "rx");
+    sp_object_read_attr(object, "ry");
+}
+
+static Inkscape::XML::Node *
+sp_ellipse_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+{
+    SPGenericEllipse *ellipse;
+
+    ellipse = SP_GENERICELLIPSE(object);
+
+    if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
+        repr = sp_repr_new("svg:ellipse");
+    }
+
+    sp_repr_set_svg_double(repr, "cx", ellipse->cx.computed);
+    sp_repr_set_svg_double(repr, "cy", ellipse->cy.computed);
+    sp_repr_set_svg_double(repr, "rx", ellipse->rx.computed);
+    sp_repr_set_svg_double(repr, "ry", ellipse->ry.computed);
+
+    if (((SPObjectClass *) ellipse_parent_class)->write)
+        (* ((SPObjectClass *) ellipse_parent_class)->write) (object, repr, flags);
+
+    return repr;
+}
+
+static void
+sp_ellipse_set(SPObject *object, unsigned int key, gchar const *value)
+{
+    SPGenericEllipse *ellipse;
+
+    ellipse = SP_GENERICELLIPSE(object);
+
+    switch (key) {
+        case SP_ATTR_CX:
+            ellipse->cx.readOrUnset(value);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_CY:
+            ellipse->cy.readOrUnset(value);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_RX:
+            if (!ellipse->rx.read(value) || (ellipse->rx.value <= 0.0)) {
+                ellipse->rx.unset();
+            }
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_RY:
+            if (!ellipse->ry.read(value) || (ellipse->ry.value <= 0.0)) {
+                ellipse->ry.unset();
+            }
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        default:
+            if (((SPObjectClass *) ellipse_parent_class)->set)
+                ((SPObjectClass *) ellipse_parent_class)->set(object, key, value);
+            break;
+    }
+}
+
+static gchar *sp_ellipse_description(SPItem *item)
+{
+    return g_strdup(_("<b>Ellipse</b>"));
+}
+
+
+void
+sp_ellipse_position_set(SPEllipse *ellipse, gdouble x, gdouble y, gdouble rx, gdouble ry)
+{
+    SPGenericEllipse *ge;
+
+    g_return_if_fail(ellipse != NULL);
+    g_return_if_fail(SP_IS_ELLIPSE(ellipse));
+
+    ge = SP_GENERICELLIPSE(ellipse);
+
+    ge->cx.computed = x;
+    ge->cy.computed = y;
+    ge->rx.computed = rx;
+    ge->ry.computed = ry;
+
+    ((SPObject *)ge)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+}
+
+/* SVG <circle> element */
+
+static void sp_circle_class_init(SPCircleClass *klass);
+static void sp_circle_init(SPCircle *circle);
+
+static void sp_circle_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
+static Inkscape::XML::Node *sp_circle_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
+static void sp_circle_set(SPObject *object, unsigned int key, gchar const *value);
+static gchar *sp_circle_description(SPItem *item);
+
+static SPGenericEllipseClass *circle_parent_class;
+
+GType
+sp_circle_get_type(void)
+{
+    static GType type = 0;
+    if (!type) {
+        GTypeInfo info = {
+            sizeof(SPCircleClass),
+            NULL,   /* base_init */
+            NULL,   /* base_finalize */
+            (GClassInitFunc) sp_circle_class_init,
+            NULL,   /* class_finalize */
+            NULL,   /* class_data */
+            sizeof(SPCircle),
+            16,   /* n_preallocs */
+            (GInstanceInitFunc) sp_circle_init,
+            NULL,   /* value_table */
+        };
+        type = g_type_register_static(SP_TYPE_GENERICELLIPSE, "SPCircle", &info, (GTypeFlags)0);
+    }
+    return type;
+}
+
+static void
+sp_circle_class_init(SPCircleClass *klass)
+{
+    SPObjectClass *sp_object_class = (SPObjectClass *) klass;
+    SPItemClass *item_class = (SPItemClass *) klass;
+
+    circle_parent_class = (SPGenericEllipseClass*) g_type_class_ref(SP_TYPE_GENERICELLIPSE);
+
+    sp_object_class->build = sp_circle_build;
+    sp_object_class->write = sp_circle_write;
+    sp_object_class->set = sp_circle_set;
+
+    item_class->description = sp_circle_description;
+}
+
+static void
+sp_circle_init(SPCircle *circle)
+{
+    /* Nothing special */
+}
+
+static void
+sp_circle_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+{
+    if (((SPObjectClass *) circle_parent_class)->build)
+        (* ((SPObjectClass *) circle_parent_class)->build)(object, document, repr);
+
+    sp_object_read_attr(object, "cx");
+    sp_object_read_attr(object, "cy");
+    sp_object_read_attr(object, "r");
+}
+
+static Inkscape::XML::Node *
+sp_circle_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+{
+    SPGenericEllipse *ellipse;
+
+    ellipse = SP_GENERICELLIPSE(object);
+
+    if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
+        repr = sp_repr_new("svg:circle");
+    }
+
+    sp_repr_set_svg_double(repr, "cx", ellipse->cx.computed);
+    sp_repr_set_svg_double(repr, "cy", ellipse->cy.computed);
+    sp_repr_set_svg_double(repr, "r", ellipse->rx.computed);
+
+    if (((SPObjectClass *) circle_parent_class)->write)
+        ((SPObjectClass *) circle_parent_class)->write(object, repr, flags);
+
+    return repr;
+}
+
+static void
+sp_circle_set(SPObject *object, unsigned int key, gchar const *value)
+{
+    SPGenericEllipse *ge;
+
+    ge = SP_GENERICELLIPSE(object);
+
+    switch (key) {
+        case SP_ATTR_CX:
+            ge->cx.readOrUnset(value);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_CY:
+            ge->cy.readOrUnset(value);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_R:
+            if (!ge->rx.read(value) || ge->rx.value <= 0.0) {
+                ge->rx.unset();
+            }
+            ge->ry = ge->rx;
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        default:
+            if (((SPObjectClass *) circle_parent_class)->set)
+                ((SPObjectClass *) circle_parent_class)->set(object, key, value);
+            break;
+    }
+}
+
+static gchar *sp_circle_description(SPItem *item)
+{
+    return g_strdup(_("<b>Circle</b>"));
+}
+
+/* <path sodipodi:type="arc"> element */
+
+static void sp_arc_class_init(SPArcClass *klass);
+static void sp_arc_init(SPArc *arc);
+
+static void sp_arc_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
+static Inkscape::XML::Node *sp_arc_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
+static void sp_arc_set(SPObject *object, unsigned int key, gchar const *value);
+static void sp_arc_modified(SPObject *object, guint flags);
+
+static gchar *sp_arc_description(SPItem *item);
+
+static SPGenericEllipseClass *arc_parent_class;
+
+GType
+sp_arc_get_type(void)
+{
+    static GType type = 0;
+    if (!type) {
+        GTypeInfo info = {
+            sizeof(SPArcClass),
+            NULL,   /* base_init */
+            NULL,   /* base_finalize */
+            (GClassInitFunc) sp_arc_class_init,
+            NULL,   /* class_finalize */
+            NULL,   /* class_data */
+            sizeof(SPArc),
+            16,   /* n_preallocs */
+            (GInstanceInitFunc) sp_arc_init,
+            NULL,   /* value_table */
+        };
+        type = g_type_register_static(SP_TYPE_GENERICELLIPSE, "SPArc", &info, (GTypeFlags)0);
+    }
+    return type;
+}
+
+static void
+sp_arc_class_init(SPArcClass *klass)
+{
+    SPObjectClass *sp_object_class = (SPObjectClass *) klass;
+    SPItemClass *item_class = (SPItemClass *) klass;
+
+    arc_parent_class = (SPGenericEllipseClass*) g_type_class_ref(SP_TYPE_GENERICELLIPSE);
+
+    sp_object_class->build = sp_arc_build;
+    sp_object_class->write = sp_arc_write;
+    sp_object_class->set = sp_arc_set;
+    sp_object_class->modified = sp_arc_modified;
+
+    item_class->description = sp_arc_description;
+}
+
+static void
+sp_arc_init(SPArc *arc)
+{
+    /* Nothing special */
+}
+
+static void
+sp_arc_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+{
+    if (((SPObjectClass *) arc_parent_class)->build)
+        (* ((SPObjectClass *) arc_parent_class)->build) (object, document, repr);
+
+    Inkscape::Version version = sp_object_get_sodipodi_version(object);
+
+    sp_object_read_attr(object, "sodipodi:cx");
+    sp_object_read_attr(object, "sodipodi:cy");
+    sp_object_read_attr(object, "sodipodi:rx");
+    sp_object_read_attr(object, "sodipodi:ry");
+
+    sp_object_read_attr(object, "sodipodi:start");
+    sp_object_read_attr(object, "sodipodi:end");
+    sp_object_read_attr(object, "sodipodi:open");
+}
+
+/*
+ * sp_arc_set_elliptical_path_attribute:
+ *
+ * Convert center to endpoint parameterization and set it to repr.
+ *
+ * See SVG 1.0 Specification W3C Recommendation
+ * ``F.6 Ellptical arc implementation notes'' for more detail.
+ */
+static gboolean
+sp_arc_set_elliptical_path_attribute(SPArc *arc, Inkscape::XML::Node *repr)
+{
+    gint fa, fs;
+    gdouble  dt;
+    Inkscape::SVGOStringStream os;
+
+    SPGenericEllipse *ge = SP_GENERICELLIPSE(arc);
+
+    NR::Point p1 = sp_arc_get_xy(arc, ge->start);
+    NR::Point p2 = sp_arc_get_xy(arc, ge->end);
+
+    dt = fmod(ge->end - ge->start, SP_2PI);
+    if (fabs(dt) < 1e-6) {
+        NR::Point ph = sp_arc_get_xy(arc, (ge->start + ge->end) / 2.0);
+        os << "M " << p1[NR::X] << " " <<  p1[NR::Y]
+           << " A " << ge->rx.computed << " " << ge->ry.computed
+           << " 0 1 1 " << " " << ph[NR::X] << "," << ph[NR::Y]
+           << " A " << ge->rx.computed << " " << ge->ry.computed
+           << " 0 1 1 " << " " << p2[NR::X] << " " << p2[NR::Y] << " z";
+    } else {
+        fa = (fabs(dt) > M_PI) ? 1 : 0;
+        fs = (dt > 0) ? 1 : 0;
+#ifdef ARC_VERBOSE
+        g_print("start:%g end:%g fa=%d fs=%d\n", ge->start, ge->end, fa, fs);
+#endif
+        if (ge->closed) {
+            os << "M " << p1[NR::X] << "," << p1[NR::Y]
+               << " A " << ge->rx.computed << "," << ge->ry.computed
+               << " 0 " << fa << " " << fs << " " << p2[NR::X] << "," << p2[NR::Y]
+               << " L " << ge->cx.computed << "," << ge->cy.computed << " z";
+        } else {
+            os << "M " << p1[NR::X] << "," << p1[NR::Y]
+               << " A " << ge->rx.computed << "," << ge->ry.computed
+               << " 0 " << fa << " " << fs << " " << p2[NR::X] << "," << p2[NR::Y];
+
+        }
+    }
+    repr->setAttribute("d", os.str().c_str());
+    return true;
+}
+
+static Inkscape::XML::Node *
+sp_arc_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+{
+    SPGenericEllipse *ge = SP_GENERICELLIPSE(object);
+    SPArc *arc = SP_ARC(object);
+
+    if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
+        repr = sp_repr_new("svg:path");
+    }
+
+    if (flags & SP_OBJECT_WRITE_EXT) {
+        repr->setAttribute("sodipodi:type", "arc");
+        sp_repr_set_svg_double(repr, "sodipodi:cx", ge->cx.computed);
+        sp_repr_set_svg_double(repr, "sodipodi:cy", ge->cy.computed);
+        sp_repr_set_svg_double(repr, "sodipodi:rx", ge->rx.computed);
+        sp_repr_set_svg_double(repr, "sodipodi:ry", ge->ry.computed);
+
+        // write start and end only if they are non-trivial; otherwise remove
+        gdouble len = fmod(ge->end - ge->start, SP_2PI);
+        if (len < 0.0) len += SP_2PI;
+        if (!(fabs(len) < 1e-8 || fabs(len - SP_2PI) < 1e-8)) {
+            sp_repr_set_svg_double(repr, "sodipodi:start", ge->start);
+            sp_repr_set_svg_double(repr, "sodipodi:end", ge->end);
+            repr->setAttribute("sodipodi:open", (!ge->closed) ? "true" : NULL);
+        } else {
+            repr->setAttribute("sodipodi:end", NULL);
+            repr->setAttribute("sodipodi:start", NULL);
+            repr->setAttribute("sodipodi:open", NULL);
+        }
+    }
+
+    // write d=
+    sp_arc_set_elliptical_path_attribute(arc, repr);
+
+    if (((SPObjectClass *) arc_parent_class)->write)
+        ((SPObjectClass *) arc_parent_class)->write(object, repr, flags);
+
+    return repr;
+}
+
+static void
+sp_arc_set(SPObject *object, unsigned int key, gchar const *value)
+{
+    SPGenericEllipse *ge = SP_GENERICELLIPSE(object);
+
+    switch (key) {
+        case SP_ATTR_SODIPODI_CX:
+            ge->cx.readOrUnset(value);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_SODIPODI_CY:
+            ge->cy.readOrUnset(value);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_SODIPODI_RX:
+            if (!ge->rx.read(value) || ge->rx.computed <= 0.0) {
+                ge->rx.unset();
+            }
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_SODIPODI_RY:
+            if (!ge->ry.read(value) || ge->ry.computed <= 0.0) {
+                ge->ry.unset();
+            }
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_SODIPODI_START:
+            if (value) {
+                sp_svg_number_read_d(value, &ge->start);
+            } else {
+                ge->start = 0;
+            }
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_SODIPODI_END:
+            if (value) {
+                sp_svg_number_read_d(value, &ge->end);
+            } else {
+                ge->end = 2 * M_PI;
+            }
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        case SP_ATTR_SODIPODI_OPEN:
+            ge->closed = (!value);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            break;
+        default:
+            if (((SPObjectClass *) arc_parent_class)->set)
+                ((SPObjectClass *) arc_parent_class)->set(object, key, value);
+            break;
+    }
+}
+
+static void
+sp_arc_modified(SPObject *object, guint flags)
+{
+    if (flags & SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG) {
+        sp_shape_set_shape((SPShape *) object);
+    }
+
+    if (((SPObjectClass *) arc_parent_class)->modified)
+        ((SPObjectClass *) arc_parent_class)->modified(object, flags);
+}
+
+static gchar *sp_arc_description(SPItem *item)
+{
+    SPGenericEllipse *ge = SP_GENERICELLIPSE(item);
+
+    gdouble len = fmod(ge->end - ge->start, SP_2PI);
+    if (len < 0.0) len += SP_2PI;
+    if (!(fabs(len) < 1e-8 || fabs(len - SP_2PI) < 1e-8)) {
+        if (ge->closed) {
+            return g_strdup(_("<b>Segment</b>"));
+        } else {
+            return g_strdup(_("<b>Arc</b>"));
+        }
+    } else {
+        return g_strdup(_("<b>Ellipse</b>"));
+    }
+}
+
+void
+sp_arc_position_set(SPArc *arc, gdouble x, gdouble y, gdouble rx, gdouble ry)
+{
+    g_return_if_fail(arc != NULL);
+    g_return_if_fail(SP_IS_ARC(arc));
+
+    SPGenericEllipse *ge = SP_GENERICELLIPSE(arc);
+
+    ge->cx.computed = x;
+    ge->cy.computed = y;
+    ge->rx.computed = rx;
+    ge->ry.computed = ry;
+    if (prefs_get_double_attribute("tools.shapes.arc", "start", 0.0) != 0)
+        ge->start = prefs_get_double_attribute("tools.shapes.arc", "start", 0.0);
+    if (prefs_get_double_attribute("tools.shapes.arc", "end", 0.0) != 0)
+        ge->end = prefs_get_double_attribute("tools.shapes.arc", "end", 0.0);
+    if (!prefs_get_string_attribute("tools.shapes.arc", "open"))
+        ge->closed = 1;
+    else
+        ge->closed = 0;
+
+    ((SPObject *)arc)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+}
+
+NR::Point sp_arc_get_xy(SPArc *arc, gdouble arg)
+{
+    SPGenericEllipse *ge = SP_GENERICELLIPSE(arc);
+
+    return NR::Point(ge->rx.computed * cos(arg) + ge->cx.computed,
+                     ge->ry.computed * sin(arg) + ge->cy.computed);
+}
+
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :