Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1201 insertions, 0 deletions

diff --git a/src/object/sp-offset.cpp b/src/object/sp-offset.cpp
new file mode 100644
index 0000000..a0fd171
--- /dev/null
+++ b/src/object/sp-offset.cpp
@@ -0,0 +1,1201 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** \file
+ * Implementation of <path sodipodi:type="inkscape:offset">.
+ */
+
+/*
+ * Authors: (of the sp-spiral.c upon which this file was constructed):
+ *   Mitsuru Oka <oka326@parkcity.ne.jp>
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Abhishek Sharma
+ *
+ * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "sp-offset.h"
+
+#include <cstring>
+#include <string>
+
+#include <glibmm/i18n.h>
+
+#include "bad-uri-exception.h"
+#include "svg/svg.h"
+#include "attributes.h"
+#include "display/curve.h"
+
+#include "livarot/Path.h"
+#include "livarot/Shape.h"
+
+#include "enums.h"
+#include "preferences.h"
+#include "sp-text.h"
+#include "sp-use-reference.h"
+#include "uri.h"
+
+class SPDocument;
+
+#define noOFFSET_VERBOSE
+
+/** \note
+ * SPOffset is a derivative of SPShape, much like the SPSpiral or SPRect.
+ * The goal is to have a source shape (= originalPath), an offset (= radius)
+ * and compute the offset of the source by the radius. To get it to work,
+ * one needs to know what the source is and what the radius is, and how it's
+ * stored in the xml representation. The object itself is a "path" element,
+ * to get lots of shape functionality for free. The source is the easy part:
+ * it's stored in a "inkscape:original" attribute in the path. In case of
+ * "linked" offset, as they've been dubbed, there is an additional
+ * "inkscape:href" that contains the id of an element of the svg.
+ * When built, the object will attach a listener vector to that object and
+ * rebuild the "inkscape:original" whenever the href'd object changes. This
+ * is of course grossly inefficient, and also does not react to changes
+ * to the href'd during context stuff (like changing the shape of a star by
+ * dragging control points) unless the path of that object is changed during
+ * the context (seems to be the case for SPEllipse). The computation of the
+ * offset is done in sp_offset_set_shape(), a function that is called whenever
+ * a change occurs to the offset (change of source or change of radius).
+ * just like the sp-star and other, this path derivative can make control
+ * points, or more precisely one control point, that's enough to define the
+ * radius (look in shape-editor-knotholders).
+ */
+
+static void refresh_offset_source(SPOffset* offset);
+
+static void sp_offset_start_listening(SPOffset *offset,SPObject* to);
+static void sp_offset_quit_listening(SPOffset *offset);
+static void sp_offset_href_changed(SPObject *old_ref, SPObject *ref, SPOffset *offset);
+static void sp_offset_move_compensate(Geom::Affine const *mp, SPItem *original, SPOffset *self);
+static void sp_offset_delete_self(SPObject *deleted, SPOffset *self);
+static void sp_offset_source_modified (SPObject *iSource, guint flags, SPItem *item);
+
+
+// slow= source path->polygon->offset of polygon->polygon->path
+// fast= source path->offset of source path->polygon->path
+// fast is not mathematically correct, because computing the offset of a single
+// cubic bezier patch is not trivial; in particular, there are problems with holes
+// reappearing in offset when the radius becomes too large
+//TODO: need fix for bug: #384688 with fix released in r.14156
+//but reverted because bug #1507049 seems has more priority.
+static bool   use_slow_but_correct_offset_method = false;
+
+SPOffset::SPOffset() : SPShape() {
+    this->rad = 1.0;
+    this->original = nullptr;
+    this->originalPath = nullptr;
+    this->knotSet = false;
+    this->sourceDirty=false;
+    this->isUpdating=false;
+    // init various connections
+    this->sourceHref = nullptr;
+    this->sourceRepr = nullptr;
+    this->sourceObject = nullptr;
+
+    // set up the uri reference
+    this->sourceRef = new SPUseReference(this);
+    this->_changed_connection = this->sourceRef->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_offset_href_changed), this));
+}
+
+SPOffset::~SPOffset() {
+    delete this->sourceRef;
+
+    this->_modified_connection.disconnect();
+    this->_delete_connection.disconnect();
+    this->_changed_connection.disconnect();
+    this->_transformed_connection.disconnect();
+}
+
+void SPOffset::build(SPDocument *document, Inkscape::XML::Node *repr) {
+    SPShape::build(document, repr);
+
+    //XML Tree being used directly here while it shouldn't be.
+    if (this->getRepr()->attribute("inkscape:radius")) {
+        this->readAttr(SPAttr::INKSCAPE_RADIUS);
+    } else {
+        //XML Tree being used directly here (as object->getRepr) 
+        //in all the below lines in the block while it shouldn't be.
+        gchar const *oldA = this->getRepr()->attribute("sodipodi:radius");
+        this->setAttribute("inkscape:radius", oldA);
+        this->removeAttribute("sodipodi:radius");
+
+        this->readAttr(SPAttr::INKSCAPE_RADIUS);
+    }
+
+    if (this->getRepr()->attribute("inkscape:original")) {
+        this->readAttr(SPAttr::INKSCAPE_ORIGINAL);
+    } else {
+        gchar const *oldA = this->getRepr()->attribute("sodipodi:original");
+        this->setAttribute("inkscape:original", oldA);
+        this->removeAttribute("sodipodi:original");
+
+        this->readAttr(SPAttr::INKSCAPE_ORIGINAL);
+    }
+
+    if (this->getRepr()->attribute("xlink:href")) {
+        this->readAttr(SPAttr::XLINK_HREF);
+    } else {
+        gchar const *oldA = this->getRepr()->attribute("inkscape:href");
+
+        if (oldA) {
+            size_t lA = strlen(oldA);
+            char *nA=(char*)malloc((1+lA+1)*sizeof(char));
+
+            memcpy(nA+1,oldA,lA*sizeof(char));
+
+            nA[0]='#';
+            nA[lA+1]=0;
+
+            this->setAttribute("xlink:href", nA);
+
+            free(nA);
+
+            this->removeAttribute("inkscape:href");
+        }
+
+        this->readAttr(SPAttr::XLINK_HREF);
+    }
+}
+
+Inkscape::XML::Node* SPOffset::write(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
+    if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
+        repr = xml_doc->createElement("svg:path");
+    }
+
+    if (flags & SP_OBJECT_WRITE_EXT) {
+        /** \todo
+         * Fixme: we may replace these attributes by
+         * inkscape:offset="cx cy exp revo rad arg t0"
+         */
+        repr->setAttribute("sodipodi:type", "inkscape:offset");
+        repr->setAttributeSvgDouble("inkscape:radius", this->rad);
+        repr->setAttribute("inkscape:original", this->original);
+        repr->setAttribute("inkscape:href", this->sourceHref);
+    }
+
+
+    // Make sure the offset has curve
+    if (_curve == nullptr) {
+        this->set_shape();
+    }
+
+    // write that curve to "d"
+    repr->setAttribute("d", sp_svg_write_path(this->_curve->get_pathvector()));
+
+    SPShape::write(xml_doc, repr, flags | SP_SHAPE_WRITE_PATH);
+
+    return repr;
+}
+
+void SPOffset::release() {
+    if (this->original) {
+    	free (this->original);
+    }
+
+    if (this->originalPath) {
+    	delete ((Path *) this->originalPath);
+    }
+
+    this->original = nullptr;
+    this->originalPath = nullptr;
+
+    sp_offset_quit_listening(this);
+
+    this->_changed_connection.disconnect();
+
+    g_free(this->sourceHref);
+
+    this->sourceHref = nullptr;
+    this->sourceRef->detach();
+
+    SPShape::release();
+}
+
+void SPOffset::set(SPAttr key, const gchar* value) {
+    if ( this->sourceDirty ) {
+    	refresh_offset_source(this);
+    }
+
+    /* fixme: we should really collect updates */
+    switch (key)
+    {
+        case SPAttr::INKSCAPE_ORIGINAL:
+        case SPAttr::SODIPODI_ORIGINAL:
+            if (value == nullptr) {
+            } else {
+                if (this->original) {
+                    free (this->original);
+                    delete ((Path *) this->originalPath);
+
+                    this->original = nullptr;
+                    this->originalPath = nullptr;
+                }
+
+                this->original = strdup (value);
+
+                Geom::PathVector pv = sp_svg_read_pathv(this->original);
+
+                this->originalPath = new Path;
+                reinterpret_cast<Path *>(this->originalPath)->LoadPathVector(pv);
+
+                this->knotSet = false;
+
+                if ( this->isUpdating == false ) {
+                	this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+                }
+            }
+            break;
+
+        case SPAttr::INKSCAPE_RADIUS:
+        case SPAttr::SODIPODI_RADIUS:
+            if (!sp_svg_length_read_computed_absolute (value, &this->rad)) {
+                if (fabs (this->rad) < 0.01) {
+                    this->rad = (this->rad < 0) ? -0.01 : 0.01;
+                }
+
+                this->knotSet = false; // knotset=false because it's not set from the context
+            }
+
+            if ( this->isUpdating == false ) {
+            	this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            }
+            break;
+
+        case SPAttr::INKSCAPE_HREF:
+        case SPAttr::XLINK_HREF:
+            if ( value == nullptr ) {
+                sp_offset_quit_listening(this);
+                if ( this->sourceHref ) {
+                	g_free(this->sourceHref);
+                }
+
+                this->sourceHref = nullptr;
+                this->sourceRef->detach();
+            } else {
+                if ( this->sourceHref && ( strcmp(value, this->sourceHref) == 0 ) ) {
+                } else {
+                    if ( this->sourceHref ) {
+                    	g_free(this->sourceHref);
+                    }
+
+                    this->sourceHref = g_strdup(value);
+
+                    try {
+                        this->sourceRef->attach(Inkscape::URI(value));
+                    } catch (Inkscape::BadURIException &e) {
+                        g_warning("%s", e.what());
+                        this->sourceRef->detach();
+                    }
+                }
+            }
+            break;
+            
+        default:
+            SPShape::set(key, value);
+            break;
+    }
+}
+
+void SPOffset::update(SPCtx *ctx, guint flags) {
+    this->isUpdating=true; // prevent sp_offset_set from requesting updates
+    
+    if ( this->sourceDirty ) {
+    	refresh_offset_source(this);
+    }
+    
+    if (flags &
+        (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG |
+         SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
+    	
+        this->set_shape();
+    }
+    
+    this->isUpdating=false;
+
+    SPShape::update(ctx, flags);
+}
+
+const char* SPOffset::displayName() const {
+    if ( this->sourceHref ) {
+        return _("Linked Offset");
+    } else {
+        return _("Dynamic Offset");
+    }
+}
+
+gchar* SPOffset::description() const {
+    // TRANSLATORS COMMENT: %s is either "outset" or "inset" depending on sign
+    return g_strdup_printf(_("%s by %f pt"), (this->rad >= 0) ?
+            _("outset") : _("inset"), fabs (this->rad));
+}
+
+void SPOffset::set_shape() {
+    if ( this->originalPath == nullptr ) {
+        // oops : no path?! (the offset object should do harakiri)
+        return;
+    }
+#ifdef OFFSET_VERBOSE
+    g_print ("rad=%g\n", offset->rad);
+#endif
+    // au boulot
+
+    if ( fabs(this->rad) < 0.01 ) {
+        // grosso modo: 0
+        // just put the source of this (almost-non-offsetted) object as being the actual offset, 
+        // no one will notice. it's also useless to compute the offset with a 0 radius
+
+        //XML Tree being used directly here while it shouldn't be.
+        const char *res_d = this->getRepr()->attribute("inkscape:original");
+
+        if ( res_d ) {
+            Geom::PathVector pv = sp_svg_read_pathv(res_d);
+            setCurveInsync(std::make_unique<SPCurve>(pv));
+            setCurveBeforeLPE(curve());
+        }
+
+        return;
+    }
+
+    // extra paranoiac careful check. the preceding if () should take care of this case
+    if (fabs (this->rad) < 0.01) {
+    	this->rad = (this->rad < 0) ? -0.01 : 0.01;
+    }
+
+    Path *orig = new Path;
+    orig->Copy ((Path *)this->originalPath);
+
+    if ( use_slow_but_correct_offset_method == false ) {
+        // version par outline
+        Shape *theShape = new Shape;
+        Shape *theRes = new Shape;
+        Path *originaux[1];
+        Path *res = new Path;
+        res->SetBackData (false);
+
+        // and now: offset
+        float o_width;
+        if (this->rad >= 0)
+        {
+            o_width = this->rad;
+            orig->OutsideOutline (res, o_width, join_round, butt_straight, 20.0);
+        }
+        else
+        {
+            o_width = -this->rad;
+            orig->OutsideOutline (res, -o_width, join_round, butt_straight, 20.0);
+        }
+
+        if (o_width >= 1.0)
+        {
+            //      res->ConvertForOffset (1.0, orig, offset->rad);
+            res->ConvertWithBackData (1.0);
+        }
+        else
+        {
+            //      res->ConvertForOffset (o_width, orig, offset->rad);
+            res->ConvertWithBackData (o_width);
+        }
+        res->Fill (theShape, 0);
+        theRes->ConvertToShape (theShape, fill_positive);
+        originaux[0] = res;
+
+        theRes->ConvertToForme (orig, 1, originaux);
+
+        Geom::OptRect bbox = this->documentVisualBounds();
+
+        if ( bbox ) {
+            gdouble size = L2(bbox->dimensions());
+            gdouble const exp = this->transform.descrim();
+
+            if (exp != 0) {
+                size /= exp;
+            }
+
+            orig->Coalesce (size * 0.001);
+            //g_print ("coa %g    exp %g    item %p\n", size * 0.001, exp, item);
+        }
+
+
+        //  if (o_width >= 1.0)
+        //  {
+        //    orig->Coalesce (0.1);  // small threshold, since we only want to get rid of small segments
+        // the curve should already be computed by the Outline() function
+        //   orig->ConvertEvenLines (1.0);
+        //   orig->Simplify (0.5);
+        //  }
+        //  else
+        //  {
+        //          orig->Coalesce (0.1*o_width);
+        //   orig->ConvertEvenLines (o_width);
+        //   orig->Simplify (0.5 * o_width);
+        //  }
+
+        delete theShape;
+        delete theRes;
+        delete res;
+    } else {
+        // version par makeoffset
+        Shape *theShape = new Shape;
+        Shape *theRes = new Shape;
+
+
+        // and now: offset
+        float o_width;
+        if (this->rad >= 0)
+        {
+            o_width = this->rad;
+        }
+        else
+        {
+            o_width = -this->rad;
+        }
+
+        // one has to have a measure of the details
+        if (o_width >= 1.0)
+        {
+            orig->ConvertWithBackData (0.5);
+        }
+        else
+        {
+            orig->ConvertWithBackData (0.5*o_width);
+        }
+
+        orig->Fill (theShape, 0);
+        theRes->ConvertToShape (theShape, fill_positive);
+
+        Path *originaux[1];
+        originaux[0]=orig;
+
+        Path *res = new Path;
+        theRes->ConvertToForme (res, 1, originaux);
+
+        int    nbPart=0;
+        Path** parts=res->SubPaths(nbPart,true);
+        char   *holes=(char*)malloc(nbPart*sizeof(char));
+
+        // we offset contours separately, because we can.
+        // this way, we avoid doing a unique big ConvertToShape when dealing with big shapes with lots of holes
+        {
+            Shape* onePart=new Shape;
+            Shape* oneCleanPart=new Shape;
+
+            theShape->Reset();
+
+            for (int i=0;i<nbPart;i++) {
+                double partSurf=parts[i]->Surface();
+                parts[i]->Convert(1.0);
+
+                {
+                    // raffiner si besoin
+                    double  bL,bT,bR,bB;
+                    parts[i]->PolylineBoundingBox(bL,bT,bR,bB);
+                    double  measure=((bR-bL)+(bB-bT))*0.5;
+                    if ( measure < 10.0 ) {
+                        parts[i]->Convert(0.02*measure);
+                    }
+                }
+
+                if ( partSurf < 0 ) { // inverse par rapport a la realite
+                    // plein
+                    holes[i]=0;
+                    parts[i]->Fill(oneCleanPart,0);
+                    onePart->ConvertToShape(oneCleanPart,fill_positive); // there aren't intersections in that one, but maybe duplicate points and null edges
+                    oneCleanPart->MakeOffset(onePart,this->rad,join_round,20.0);
+                    onePart->ConvertToShape(oneCleanPart,fill_positive);
+
+                    onePart->CalcBBox();
+                    double  typicalSize=0.5*((onePart->rightX-onePart->leftX)+(onePart->bottomY-onePart->topY));
+
+                    if ( typicalSize < 0.05 ) {
+                    	typicalSize=0.05;
+                    }
+
+                    typicalSize*=0.01;
+
+                    if ( typicalSize > 1.0 ) {
+                    	typicalSize=1.0;
+                    }
+
+                    onePart->ConvertToForme (parts[i]);
+                    parts[i]->ConvertEvenLines (typicalSize);
+                    parts[i]->Simplify (typicalSize);
+
+                    double nPartSurf=parts[i]->Surface();
+
+                    if ( nPartSurf >= 0 ) {
+                        // inversion de la surface -> disparait
+                        delete parts[i];
+                        parts[i]=nullptr;
+                    } else {
+                    }
+
+/*          int  firstP=theShape->nbPt;
+            for (int j=0;j<onePart->nbPt;j++) theShape->AddPoint(onePart->pts[j].x);
+            for (int j=0;j<onePart->nbAr;j++) theShape->AddEdge(firstP+onePart->aretes[j].st,firstP+onePart->aretes[j].en);*/
+                } else {
+                    // trou
+                    holes[i]=1;
+                    parts[i]->Fill(oneCleanPart,0,false,true,true);
+                    onePart->ConvertToShape(oneCleanPart,fill_positive);
+                    oneCleanPart->MakeOffset(onePart,-this->rad,join_round,20.0);
+                    onePart->ConvertToShape(oneCleanPart,fill_positive);
+//          for (int j=0;j<onePart->nbAr;j++) onePart->Inverse(j); // pas oublier de reinverser
+
+                    onePart->CalcBBox();
+                    double  typicalSize=0.5*((onePart->rightX-onePart->leftX)+(onePart->bottomY-onePart->topY));
+
+                    if ( typicalSize < 0.05 ) {
+                    	typicalSize=0.05;
+                    }
+
+                    typicalSize*=0.01;
+
+                    if ( typicalSize > 1.0 ) {
+                    	typicalSize=1.0;
+                    }
+
+                    onePart->ConvertToForme (parts[i]);
+                    parts[i]->ConvertEvenLines (typicalSize);
+                    parts[i]->Simplify (typicalSize);
+                    double nPartSurf=parts[i]->Surface();
+
+                    if ( nPartSurf >= 0 ) {
+                        // inversion de la surface -> disparait
+                        delete parts[i];
+                        parts[i]=nullptr;
+                    } else {
+                    }
+
+                    /*         int  firstP=theShape->nbPt;
+                               for (int j=0;j<onePart->nbPt;j++) theShape->AddPoint(onePart->pts[j].x);
+                               for (int j=0;j<onePart->nbAr;j++) theShape->AddEdge(firstP+onePart->aretes[j].en,firstP+onePart->aretes[j].st);*/
+                }
+//        delete parts[i];
+            }
+//      theShape->MakeOffset(theRes,offset->rad,join_round,20.0);
+            delete onePart;
+            delete oneCleanPart;
+        }
+
+        if ( nbPart > 1 ) {
+            theShape->Reset();
+
+            for (int i=0;i<nbPart;i++) {
+                if ( parts[i] ) {
+                    parts[i]->ConvertWithBackData(1.0);
+
+                    if ( holes[i] ) {
+                        parts[i]->Fill(theShape,i,true,true,true);
+                    } else {
+                        parts[i]->Fill(theShape,i,true,true,false);
+                    }
+                }
+            }
+
+            theRes->ConvertToShape (theShape, fill_positive);
+            theRes->ConvertToForme (orig,nbPart,parts);
+
+            for (int i=0;i<nbPart;i++) {
+            	if ( parts[i] ) {
+            		delete parts[i];
+            	}
+            }
+        } else if ( nbPart == 1 ) {
+            orig->Copy(parts[0]);
+
+            for (int i=0;i<nbPart;i++) {
+            	if ( parts[i] ) {
+            		delete parts[i];
+            	}
+            }
+        } else {
+            orig->Reset();
+        }
+//    theRes->ConvertToShape (theShape, fill_positive);
+//    theRes->ConvertToForme (orig);
+
+/*    if (o_width >= 1.0) {
+      orig->ConvertEvenLines (1.0);
+      orig->Simplify (1.0);
+      } else {
+      orig->ConvertEvenLines (1.0*o_width);
+      orig->Simplify (1.0 * o_width);
+      }*/
+
+        if ( parts ) {
+        	free(parts);
+        }
+
+        if ( holes ) {
+        	free(holes);
+        }
+
+        delete res;
+        delete theShape;
+        delete theRes;
+    }
+    {
+        char *res_d = nullptr;
+
+        if (orig->descr_cmd.size() <= 1)
+        {
+            // Aie.... nothing left.
+            res_d = strdup ("M 0 0 L 0 0 z");
+            //printf("%s\n",res_d);
+        }
+        else
+        {
+
+            res_d = orig->svg_dump_path ();
+        }
+
+        delete orig;
+
+        Geom::PathVector pv = sp_svg_read_pathv(res_d);
+        setCurveInsync(std::make_unique<SPCurve>(pv));
+        setCurveBeforeLPE(curve());
+
+        free (res_d);
+    }
+}
+
+void SPOffset::snappoints(std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs) const {
+    SPShape::snappoints(p, snapprefs);
+}
+
+
+// utilitaires pour les poignees
+// used to get the distance to the shape: distance to polygon give the fabs(radius), we still need
+// the sign. for edges, it's easy to determine which side the point is on, for points of the polygon
+// it's trickier: we need to identify which angle the point is in; to that effect, we take each
+// successive clockwise angle (A,C) and check if the vector B given by the point is in the angle or
+// outside.
+// another method would be to use the Winding() function to test whether the point is inside or outside
+// the polygon (it would be wiser to do so, in fact, but i like being stupid)
+
+/**
+ *
+ * \todo
+ * FIXME: This can be done using linear operations, more stably and
+ *  faster.  method: transform A and C into B's space, A should be
+ *  negative and B should be positive in the orthogonal component.  I
+ *  think this is equivalent to
+ *  dot(A, rot90(B))*dot(C, rot90(B)) == -1.
+ *    -- njh
+ */
+static bool
+vectors_are_clockwise (Geom::Point A, Geom::Point B, Geom::Point C)
+{
+    using Geom::rot90;
+    double ab_s = dot(A, rot90(B));
+    double ab_c = dot(A, B);
+    double bc_s = dot(B, rot90(C));
+    double bc_c = dot(B, C);
+    double ca_s = dot(C, rot90(A));
+    double ca_c = dot(C, A);
+
+    double ab_a = acos (ab_c);
+
+    if (ab_c <= -1.0) {
+        ab_a = M_PI;
+    }
+
+    if (ab_c >= 1.0) {
+        ab_a = 0;
+    }
+
+    if (ab_s < 0) {
+        ab_a = 2 * M_PI - ab_a;
+    }
+
+    double bc_a = acos (bc_c);
+
+    if (bc_c <= -1.0) {
+        bc_a = M_PI;
+    }
+
+    if (bc_c >= 1.0) {
+        bc_a = 0;
+    }
+
+    if (bc_s < 0) {
+        bc_a = 2 * M_PI - bc_a;
+    }
+
+    double ca_a = acos (ca_c);
+
+    if (ca_c <= -1.0) {
+        ca_a = M_PI;
+    }
+
+    if (ca_c >= 1.0) {
+        ca_a = 0;
+    }
+
+    if (ca_s < 0) {
+        ca_a = 2 * M_PI - ca_a;
+    }
+
+    double lim = 2 * M_PI - ca_a;
+
+    if (ab_a < lim) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Distance to the original path; that function is called from shape-editor-knotholders
+ * to set the radius when the control knot moves.
+ *
+ * The sign of the result is the radius we're going to offset the shape with,
+ * so result > 0 ==outset and result < 0 ==inset. thus result<0 means
+ * 'px inside source'.
+ */
+double
+sp_offset_distance_to_original (SPOffset * offset, Geom::Point px)
+{
+    if (offset == nullptr || offset->originalPath == nullptr || ((Path *) offset->originalPath)->descr_cmd.size() <= 1) {
+        return 1.0;
+    }
+
+    double dist = 1.0;
+    Shape *theShape = new Shape;
+    Shape *theRes = new Shape;
+
+    /** \todo
+     * Awfully damn stupid method: uncross the source path EACH TIME you
+     * need to compute the distance. The good way to do this would be to
+     * store the uncrossed source path somewhere, and delete it when the
+     * context is finished. Hopefully this part is much faster than actually
+     * computing the offset (which happen just after), so the time spent in
+     * this function should end up being negligible with respect to the
+     * delay of one context.
+     */
+    // move
+    ((Path *) offset->originalPath)->Convert (1.0);
+    ((Path *) offset->originalPath)->Fill (theShape, 0);
+    theRes->ConvertToShape (theShape, fill_oddEven);
+
+    if (theRes->numberOfEdges() <= 1)
+    {
+
+    }
+    else
+    {
+        double ptDist = -1.0;
+        bool ptSet = false;
+        double arDist = -1.0;
+        bool arSet = false;
+
+        // first get the minimum distance to the points
+        for (int i = 0; i < theRes->numberOfPoints(); i++)
+        {
+            if (theRes->getPoint(i).totalDegree() > 0)
+            {
+                Geom::Point nx = theRes->getPoint(i).x;
+                Geom::Point nxpx = px-nx;
+                double ndist = sqrt (dot(nxpx,nxpx));
+
+                if (ptSet == false || fabs (ndist) < fabs (ptDist))
+                {
+                    // we have a new minimum distance
+                    // now we need to wheck if px is inside or outside (for the sign)
+                    nx = px - theRes->getPoint(i).x;
+                    double nlen = sqrt (dot(nx , nx));
+                    nx /= nlen;
+                    int pb, cb, fb;
+                    fb = theRes->getPoint(i).incidentEdge[LAST];
+                    pb = theRes->getPoint(i).incidentEdge[LAST];
+                    cb = theRes->getPoint(i).incidentEdge[FIRST];
+
+                    do
+                    {
+                        // one angle
+                        Geom::Point prx, nex;
+                        prx = theRes->getEdge(pb).dx;
+                        nlen = sqrt (dot(prx, prx));
+                        prx /= nlen;
+                        nex = theRes->getEdge(cb).dx;
+                        nlen = sqrt (dot(nex , nex));
+                        nex /= nlen;
+
+                        if (theRes->getEdge(pb).en == i)
+                        {
+                            prx = -prx;
+                        }
+
+                        if (theRes->getEdge(cb).en == i)
+                        {
+                            nex = -nex;
+                        }
+
+                        if (vectors_are_clockwise (nex, nx, prx))
+                        {
+                            // we're in that angle. set the sign, and exit that loop
+                            if (theRes->getEdge(cb).st == i)
+                            {
+                                ptDist = -ndist;
+                                ptSet = true;
+                            }
+                            else
+                            {
+                                ptDist = ndist;
+                                ptSet = true;
+                            }
+                            break;
+                        }
+
+                        pb = cb;
+                        cb = theRes->NextAt (i, cb);
+                    }
+
+                    while (cb >= 0 && pb >= 0 && pb != fb);
+                }
+            }
+        }
+
+        // loop over the edges to try to improve the distance
+        for (int i = 0; i < theRes->numberOfEdges(); i++)
+        {
+            Geom::Point sx = theRes->getPoint(theRes->getEdge(i).st).x;
+            Geom::Point ex = theRes->getPoint(theRes->getEdge(i).en).x;
+            Geom::Point nx = ex - sx;
+            double len = sqrt (dot(nx,nx));
+
+            if (len > 0.0001)
+            {
+                Geom::Point   pxsx=px-sx;
+                double ab = dot(nx,pxsx);
+
+                if (ab > 0 && ab < len * len)
+                {
+                    // we're in the zone of influence of the segment
+                    double ndist = (cross(nx, pxsx)) / len;
+
+                    if (arSet == false || fabs (ndist) < fabs (arDist))
+                    {
+                        arDist = ndist;
+                        arSet = true;
+                    }
+                }
+            }
+        }
+
+        if (arSet || ptSet)
+        {
+            if (arSet == false) {
+                arDist = ptDist;
+            }
+
+            if (ptSet == false) {
+                ptDist = arDist;
+            }
+
+            if (fabs (ptDist) < fabs (arDist)) {
+                dist = ptDist;
+            } else {
+                dist = arDist;
+            }
+        }
+    }
+
+    delete theShape;
+    delete theRes;
+
+    return dist;
+}
+
+/**
+ * Computes a point on the offset;  used to set a "seed" position for
+ * the control knot.
+ *
+ * \return the topmost point on the offset.
+ */
+void
+sp_offset_top_point (SPOffset const * offset, Geom::Point *px)
+{
+    (*px) = Geom::Point(0, 0);
+
+    if (offset == nullptr) {
+        return;
+    }
+
+    if (offset->knotSet)
+    {
+        (*px) = offset->knot;
+        return;
+    }
+
+    SPCurve const *curve = offset->curve();
+
+    if (curve == nullptr)
+    {
+    	const_cast<SPOffset*>(offset)->set_shape();
+
+        curve = offset->curve();
+
+        if (curve == nullptr)
+            return;
+    }
+
+    if (curve->is_empty())
+    {
+        return;
+    }
+
+    Path *finalPath = new Path;
+    finalPath->LoadPathVector(curve->get_pathvector());
+
+    Shape *theShape = new Shape;
+
+    finalPath->Convert (1.0);
+    finalPath->Fill (theShape, 0);
+
+    if (theShape->hasPoints())
+    {
+        theShape->SortPoints ();
+        *px = theShape->getPoint(0).x;
+    }
+
+    delete theShape;
+    delete finalPath;
+}
+
+// the listening functions
+static void sp_offset_start_listening(SPOffset *offset,SPObject* to)
+{
+    if ( to == nullptr ) {
+        return;
+    }
+
+    offset->sourceObject = to;
+    offset->sourceRepr = to->getRepr();
+
+    offset->_delete_connection = to->connectDelete(sigc::bind(sigc::ptr_fun(&sp_offset_delete_self), offset));
+    offset->_transformed_connection = SP_ITEM(to)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_offset_move_compensate), offset));
+    offset->_modified_connection = to->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_offset_source_modified), offset));
+}
+
+static void sp_offset_quit_listening(SPOffset *offset)
+{
+    if ( offset->sourceObject == nullptr ) {
+        return;
+    }
+
+    offset->_modified_connection.disconnect();
+    offset->_delete_connection.disconnect();
+    offset->_transformed_connection.disconnect();
+
+    offset->sourceRepr = nullptr;
+    offset->sourceObject = nullptr;
+}
+
+static void
+sp_offset_href_changed(SPObject */*old_ref*/, SPObject */*ref*/, SPOffset *offset)
+{
+    sp_offset_quit_listening(offset);
+
+    if (offset->sourceRef) {
+        SPItem *refobj = offset->sourceRef->getObject();
+
+        if (refobj) {
+        	sp_offset_start_listening(offset,refobj);
+        }
+
+        offset->sourceDirty=true;
+        offset->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+    }
+}
+
+static void sp_offset_move_compensate(Geom::Affine const *mp, SPItem */*original*/, SPOffset *self)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    guint mode = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_PARALLEL);
+
+    Geom::Affine m(*mp);
+
+    if (!(m.isTranslation()) || mode == SP_CLONE_COMPENSATION_NONE) {
+        self->sourceDirty=true;
+        self->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        return;
+    }
+
+    // calculate the compensation matrix and the advertized movement matrix
+    self->readAttr(SPAttr::TRANSFORM);
+
+    Geom::Affine t = self->transform;
+    Geom::Affine offset_move = t.inverse() * m * t;
+
+    Geom::Affine advertized_move;
+    if (mode == SP_CLONE_COMPENSATION_PARALLEL) {
+        offset_move = offset_move.inverse() * m;
+        advertized_move = m;
+    } else if (mode == SP_CLONE_COMPENSATION_UNMOVED) {
+        offset_move = offset_move.inverse();
+        advertized_move.setIdentity();
+    } else {
+        g_assert_not_reached();
+    }
+
+    self->sourceDirty=true;
+
+    // commit the compensation
+    self->transform *= offset_move;
+    self->doWriteTransform(self->transform, &advertized_move);
+    self->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+}
+
+static void
+sp_offset_delete_self(SPObject */*deleted*/, SPOffset *offset)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    guint const mode = prefs->getInt("/options/cloneorphans/value", SP_CLONE_ORPHANS_UNLINK);
+
+    if (mode == SP_CLONE_ORPHANS_UNLINK) {
+        // leave it be. just forget about the source
+        sp_offset_quit_listening(offset);
+
+        if ( offset->sourceHref ) {
+        	g_free(offset->sourceHref);
+        }
+
+        offset->sourceHref = nullptr;
+        offset->sourceRef->detach();
+    } else if (mode == SP_CLONE_ORPHANS_DELETE) {
+        offset->deleteObject();
+    }
+}
+
+static void
+sp_offset_source_modified (SPObject */*iSource*/, guint flags, SPItem *item)
+{
+    SPOffset *offset = SP_OFFSET(item);
+    offset->sourceDirty=true;
+
+    if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG)) {
+        offset->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+    }
+}
+
+static void
+refresh_offset_source(SPOffset* offset)
+{
+    if ( offset == nullptr ) {
+    	return;
+    }
+
+    offset->sourceDirty=false;
+
+    // le mauvais cas: pas d'attribut d => il faut verifier que c'est une SPShape puis prendre le contour
+    // The bad case: no d attribute.  Must check that it's an SPShape and then take the outline.
+    SPObject *refobj=offset->sourceObject;
+
+    if ( refobj == nullptr ) {
+    	return;
+    }
+
+    SPItem  *item  = SP_ITEM (refobj);
+    std::unique_ptr<SPCurve> curve;
+
+    if (auto shape = dynamic_cast<SPShape const *>(item)) {
+        curve = SPCurve::copy(shape->curve());
+    } else if (auto text = dynamic_cast<SPText const *>(item)) {
+        curve = text->getNormalizedBpath();
+    } else {
+        return;
+    }
+
+    if (curve == nullptr) {
+        return;
+    }
+
+    Path *orig = new Path;
+    orig->LoadPathVector(curve->get_pathvector());
+
+    if (!item->transform.isIdentity()) {
+        gchar const *t_attr = item->getRepr()->attribute("transform");
+
+        if (t_attr) {
+            Geom::Affine t;
+
+            if (sp_svg_transform_read(t_attr, &t)) {
+                orig->Transform(t);
+            }
+        }
+    }
+
+    // Finish up.
+    {
+        SPCSSAttr *css;
+        const gchar *val;
+        Shape *theShape = new Shape;
+        Shape *theRes = new Shape;
+
+        orig->ConvertWithBackData (1.0);
+        orig->Fill (theShape, 0);
+
+        css = sp_repr_css_attr (offset->sourceRepr , "style");
+        val = sp_repr_css_property (css, "fill-rule", nullptr);
+
+        if (val && strcmp (val, "nonzero") == 0)
+        {
+            theRes->ConvertToShape (theShape, fill_nonZero);
+        }
+        else if (val && strcmp (val, "evenodd") == 0)
+        {
+            theRes->ConvertToShape (theShape, fill_oddEven);
+        }
+        else
+        {
+            theRes->ConvertToShape (theShape, fill_nonZero);
+        }
+
+        Path *originaux[1];
+        originaux[0] = orig;
+        Path *res = new Path;
+        theRes->ConvertToForme (res, 1, originaux);
+
+        delete theShape;
+        delete theRes;
+
+        char *res_d = res->svg_dump_path ();
+        delete res;
+        delete orig;
+
+        // TODO fix:
+        //XML Tree being used directly here while it shouldn't be.
+        offset->setAttribute("inkscape:original", res_d);
+
+        free (res_d);
+    }
+}
+
+SPItem *
+sp_offset_get_source (SPOffset *offset)
+{
+    if (offset && offset->sourceRef) {
+        SPItem *refobj = offset->sourceRef->getObject();
+
+        if (SP_IS_ITEM (refobj)) {
+            return (SPItem *) refobj;
+        }
+    }
+
+    return nullptr;
+}
+
+
+/*
+  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:fileencoding=utf-8:textwidth=99 :