2N/A#define __SP_OFFSET_C__

2N/A

2N/A

2N/A

2N/A#ifdef HAVE_CONFIG_H

2N/A# include "config.h"

2N/A#endif

2N/A

2N/A#include <cstring>

2N/A#include <string>

2N/A

2N/A#include "svg/svg.h"

2N/A#include "attributes.h"

2N/A#include "display/curve.h"

2N/A#include <glibmm/i18n.h>

2N/A

2N/A#include "livarot/Path.h"

2N/A#include "livarot/Shape.h"

2N/A

2N/A#include "enums.h"

2N/A#include "preferences.h"

2N/A#include "sp-text.h"

2N/A#include "sp-offset.h"

2N/A#include "sp-use-reference.h"

2N/A#include "uri.h"

2N/A

2N/A#include <libnr/nr-matrix-fns.h>

2N/A#include <2geom/pathvector.h>

2N/A

2N/A#include "xml/repr.h"

2N/A

2N/Aclass SPDocument;

2N/A

2N/A#define noOFFSET_VERBOSE

2N/A

2N/A

2N/Astatic void sp_offset_class_init (SPOffsetClass * klass);

2N/Astatic void sp_offset_init (SPOffset * offset);

2N/Astatic void sp_offset_finalize(GObject *obj);

2N/A

2N/Astatic void sp_offset_build (SPObject * object, SPDocument * document,

2N/A Inkscape::XML::Node * repr);

2N/Astatic Inkscape::XML::Node *sp_offset_write (SPObject * object, Inkscape::XML::Document *doc, Inkscape::XML::Node * repr,

2N/A guint flags);

2N/Astatic void sp_offset_set (SPObject * object, unsigned int key,

2N/A const gchar * value);

2N/Astatic void sp_offset_update (SPObject * object, SPCtx * ctx, guint flags);

2N/Astatic void sp_offset_release (SPObject * object);

2N/A

2N/Astatic gchar *sp_offset_description (SPItem * item);

2N/Astatic void sp_offset_snappoints(SPItem const *item, std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs);

2N/Astatic void sp_offset_set_shape (SPShape * shape);

2N/A

2N/Astatic void refresh_offset_source(SPOffset* offset);

2N/A

2N/Astatic void sp_offset_start_listening(SPOffset *offset,SPObject* to);

2N/Astatic void sp_offset_quit_listening(SPOffset *offset);

2N/Astatic void sp_offset_href_changed(SPObject *old_ref, SPObject *ref, SPOffset *offset);

2N/Astatic void sp_offset_move_compensate(Geom::Matrix const *mp, SPItem *original, SPOffset *self);

2N/Astatic void sp_offset_delete_self(SPObject *deleted, SPOffset *self);

2N/Astatic void sp_offset_source_modified (SPObject *iSource, guint flags, SPItem *item);

2N/A

2N/A

2N/Astatic bool use_slow_but_correct_offset_method=false;

2N/A

2N/A

2N/Astatic SPShapeClass *parent_class;

2N/A

2N/Asp_offset_get_type (void)

2N/A{

2N/A static GType offset_type = 0;

2N/A

2N/A if (!offset_type)

2N/A {

2N/A GTypeInfo offset_info = {

2N/A sizeof (SPOffsetClass),

2N/A NULL, /* base_init */

2N/A NULL, /* base_finalize */

2N/A (GClassInitFunc) sp_offset_class_init,

2N/A NULL, /* class_finalize */

2N/A NULL, /* class_data */

2N/A sizeof (SPOffset),

2N/A 16, /* n_preallocs */

2N/A (GInstanceInitFunc) sp_offset_init,

2N/A NULL, /* value_table */

2N/A };

2N/A offset_type =

2N/A g_type_register_static (SP_TYPE_SHAPE, "SPOffset", &offset_info,

2N/A (GTypeFlags) 0);

2N/A }

2N/A return offset_type;

2N/A}

2N/A

2N/Astatic void

2N/Asp_offset_class_init(SPOffsetClass *klass)

2N/A{

2N/A GObjectClass *gobject_class = (GObjectClass *) klass;

2N/A SPObjectClass *sp_object_class = (SPObjectClass *) klass;

2N/A SPItemClass *item_class = (SPItemClass *) klass;

2N/A SPShapeClass *shape_class = (SPShapeClass *) klass;

2N/A

2N/A parent_class = (SPShapeClass *) g_type_class_ref (SP_TYPE_SHAPE);

2N/A

2N/A gobject_class->finalize = sp_offset_finalize;

2N/A

2N/A sp_object_class->build = sp_offset_build;

2N/A sp_object_class->write = sp_offset_write;

2N/A sp_object_class->set = sp_offset_set;

2N/A sp_object_class->update = sp_offset_update;

2N/A sp_object_class->release = sp_offset_release;

2N/A

2N/A item_class->description = sp_offset_description;

2N/A item_class->snappoints = sp_offset_snappoints;

2N/A

2N/A shape_class->set_shape = sp_offset_set_shape;

2N/A}

2N/A

2N/Astatic void

2N/Asp_offset_init(SPOffset *offset)

2N/A{

2N/A offset->rad = 1.0;

2N/A offset->original = NULL;

2N/A offset->originalPath = NULL;

2N/A offset->knotSet = false;

2N/A offset->sourceDirty=false;

2N/A offset->isUpdating=false;

2N/A // init various connections

2N/A offset->sourceHref = NULL;

2N/A offset->sourceRepr = NULL;

2N/A offset->sourceObject = NULL;

2N/A new (&offset->_modified_connection) sigc::connection();

2N/A new (&offset->_delete_connection) sigc::connection();

2N/A new (&offset->_changed_connection) sigc::connection();

2N/A new (&offset->_transformed_connection) sigc::connection();

2N/A // set up the uri reference

2N/A offset->sourceRef = new SPUseReference(SP_OBJECT(offset));

2N/A offset->_changed_connection = offset->sourceRef->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_offset_href_changed), offset));

2N/A}

2N/A

2N/Astatic void

2N/Asp_offset_finalize(GObject *obj)

2N/A{

2N/A SPOffset *offset = (SPOffset *) obj;

2N/A

2N/A delete offset->sourceRef;

2N/A

2N/A offset->_modified_connection.disconnect();

2N/A offset->_modified_connection.~connection();

2N/A offset->_delete_connection.disconnect();

2N/A offset->_delete_connection.~connection();

2N/A offset->_changed_connection.disconnect();

2N/A offset->_changed_connection.~connection();

2N/A offset->_transformed_connection.disconnect();

2N/A offset->_transformed_connection.~connection();

2N/A}

2N/A

2N/Astatic void

2N/Asp_offset_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)

2N/A{

2N/A if (((SPObjectClass *) parent_class)->build)

2N/A ((SPObjectClass *) parent_class)->build (object, document, repr);

2N/A

2N/A //XML Tree being used directly here while it shouldn't be.

2N/A if (object->getRepr()->attribute("inkscape:radius")) {

2N/A object->readAttr( "inkscape:radius");

2N/A } else {

2N/A

2N/A

2N/A //XML Tree being used directly here (as object->getRepr)

2N/A //in all the below lines in the block while it shouldn't be.

2N/A gchar const *oldA = object->getRepr()->attribute("sodipodi:radius");

2N/A object->getRepr()->setAttribute("inkscape:radius",oldA);

2N/A object->getRepr()->setAttribute("sodipodi:radius",NULL);

2N/A

2N/A object->readAttr( "inkscape:radius");

2N/A }

2N/A if (object->getRepr()->attribute("inkscape:original")) {

2N/A object->readAttr( "inkscape:original");

2N/A } else {

2N/A gchar const *oldA = object->getRepr()->attribute("sodipodi:original");

2N/A object->getRepr()->setAttribute("inkscape:original",oldA);

2N/A object->getRepr()->setAttribute("sodipodi:original",NULL);

2N/A

2N/A object->readAttr( "inkscape:original");

2N/A }

2N/A if (object->getRepr()->attribute("xlink:href")) {

2N/A object->readAttr( "xlink:href");

2N/A } else {

2N/A gchar const *oldA = object->getRepr()->attribute("inkscape:href");

2N/A if (oldA) {

2N/A size_t lA = strlen(oldA);

2N/A char *nA=(char*)malloc((1+lA+1)*sizeof(char));

2N/A memcpy(nA+1,oldA,lA*sizeof(char));

2N/A nA[0]='#';

2N/A nA[lA+1]=0;

2N/A object->getRepr()->setAttribute("xlink:href",nA);

2N/A free(nA);

2N/A object->getRepr()->setAttribute("inkscape:href",NULL);

2N/A }

2N/A object->readAttr( "xlink:href");

2N/A }

2N/A}

2N/A

2N/Astatic Inkscape::XML::Node *

2N/Asp_offset_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)

2N/A{

2N/A SPOffset *offset = SP_OFFSET (object);

2N/A

2N/A if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {

2N/A repr = xml_doc->createElement("svg:path");

2N/A }

2N/A

2N/A if (flags & SP_OBJECT_WRITE_EXT) {

2N/A /** \todo

2N/A repr->setAttribute("sodipodi:type", "inkscape:offset");

2N/A sp_repr_set_svg_double(repr, "inkscape:radius", offset->rad);

2N/A repr->setAttribute("inkscape:original", offset->original);

2N/A repr->setAttribute("inkscape:href", offset->sourceHref);

2N/A }

2N/A

2N/A

2N/A // Make sure the object has curve

2N/A SPCurve *curve = SP_SHAPE (offset)->getCurve();

2N/A if (curve == NULL) {

2N/A sp_offset_set_shape (SP_SHAPE (offset));

2N/A }

2N/A

2N/A // write that curve to "d"

2N/A char *d = sp_svg_write_path (((SPShape *) offset)->curve->get_pathvector());

2N/A repr->setAttribute("d", d);

2N/A g_free (d);

2N/A

2N/A if (((SPObjectClass *) (parent_class))->write)

2N/A ((SPObjectClass *) (parent_class))->write (object, xml_doc, repr,

2N/A flags | SP_SHAPE_WRITE_PATH);

2N/A

2N/A return repr;

2N/A}

2N/A

2N/Astatic void

2N/Asp_offset_release(SPObject *object)

2N/A{

2N/A SPOffset *offset = (SPOffset *) object;

2N/A

2N/A if (offset->original) free (offset->original);

2N/A if (offset->originalPath) delete ((Path *) offset->originalPath);

2N/A offset->original = NULL;

2N/A offset->originalPath = NULL;

2N/A

2N/A sp_offset_quit_listening(offset);

2N/A

2N/A offset->_changed_connection.disconnect();

2N/A g_free(offset->sourceHref);

2N/A offset->sourceHref = NULL;

2N/A offset->sourceRef->detach();

2N/A

2N/A if (((SPObjectClass *) parent_class)->release) {

2N/A ((SPObjectClass *) parent_class)->release (object);

2N/A }

2N/A

2N/A}

2N/A

2N/Astatic void

2N/Asp_offset_set(SPObject *object, unsigned key, gchar const *value)

2N/A{

2N/A SPOffset *offset = SP_OFFSET (object);

2N/A

2N/A if ( offset->sourceDirty ) refresh_offset_source(offset);

2N/A

2N/A /* fixme: we should really collect updates */

2N/A switch (key)

2N/A {

2N/A case SP_ATTR_INKSCAPE_ORIGINAL:

2N/A case SP_ATTR_SODIPODI_ORIGINAL:

2N/A if (value == NULL) {

2N/A } else {

2N/A if (offset->original) {

2N/A free (offset->original);

2N/A delete ((Path *) offset->originalPath);

2N/A offset->original = NULL;

2N/A offset->originalPath = NULL;

2N/A }

2N/A

2N/A offset->original = strdup (value);

2N/A

2N/A Geom::PathVector pv = sp_svg_read_pathv(offset->original);

2N/A offset->originalPath = new Path;

2N/A reinterpret_cast<Path *>(offset->originalPath)->LoadPathVector(pv);

2N/A

2N/A offset->knotSet = false;

2N/A if ( offset->isUpdating == false ) object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

2N/A }

2N/A break;

2N/A case SP_ATTR_INKSCAPE_RADIUS:

2N/A case SP_ATTR_SODIPODI_RADIUS:

2N/A if (!sp_svg_length_read_computed_absolute (value, &offset->rad)) {

2N/A if (fabs (offset->rad) < 0.01)

2N/A offset->rad = (offset->rad < 0) ? -0.01 : 0.01;

2N/A offset->knotSet = false; // knotset=false because it's not set from the context

2N/A }

2N/A if ( offset->isUpdating == false ) object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

2N/A break;

2N/A case SP_ATTR_INKSCAPE_HREF:

2N/A case SP_ATTR_XLINK_HREF:

2N/A if ( value == NULL ) {

2N/A sp_offset_quit_listening(offset);

2N/A if ( offset->sourceHref ) g_free(offset->sourceHref);

2N/A offset->sourceHref = NULL;

2N/A offset->sourceRef->detach();

2N/A } else {

2N/A if ( offset->sourceHref && ( strcmp(value, offset->sourceHref) == 0 ) ) {

2N/A } else {

2N/A if ( offset->sourceHref ) g_free(offset->sourceHref);

2N/A offset->sourceHref = g_strdup(value);

2N/A try {

2N/A offset->sourceRef->attach(Inkscape::URI(value));

2N/A } catch (Inkscape::BadURIException &e) {

2N/A g_warning("%s", e.what());

2N/A offset->sourceRef->detach();

2N/A }

2N/A }

2N/A }

2N/A break;

2N/A default:

2N/A if (((SPObjectClass *) parent_class)->set)

2N/A ((SPObjectClass *) parent_class)->set (object, key, value);

2N/A break;

2N/A }

2N/A}

2N/A

2N/Astatic void

2N/Asp_offset_update(SPObject *object, SPCtx *ctx, guint flags)

2N/A{

2N/A SPOffset* offset = SP_OFFSET(object);

2N/A offset->isUpdating=true; // prevent sp_offset_set from requesting updates

2N/A if ( offset->sourceDirty ) refresh_offset_source(offset);

2N/A if (flags &

2N/A (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG |

2N/A SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {

2N/A ((SPShape *) object)->setShape ();

2N/A }

2N/A offset->isUpdating=false;

2N/A

2N/A if (((SPObjectClass *) parent_class)->update)

2N/A ((SPObjectClass *) parent_class)->update (object, ctx, flags);

2N/A}

2N/A

2N/Astatic gchar *

2N/Asp_offset_description(SPItem *item)

2N/A{

2N/A SPOffset *offset = SP_OFFSET (item);

2N/A

2N/A if ( offset->sourceHref ) {

2N/A // TRANSLATORS COMMENT: %s is either "outset" or "inset" depending on sign

2N/A return g_strdup_printf(_("<b>Linked offset</b>, %s by %f pt"),

2N/A (offset->rad >= 0)? _("outset") : _("inset"), fabs (offset->rad));

2N/A } else {

2N/A // TRANSLATORS COMMENT: %s is either "outset" or "inset" depending on sign

2N/A return g_strdup_printf(_("<b>Dynamic offset</b>, %s by %f pt"),

2N/A (offset->rad >= 0)? _("outset") : _("inset"), fabs (offset->rad));

2N/A }

2N/A}

2N/A

static void

sp_offset_set_shape(SPShape *shape)

{

SPOffset *offset = SP_OFFSET (shape);

if ( offset->originalPath == NULL ) {

// 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(offset->rad) < 0.01 ) {

// grosso modo: 0

// just put the source shape as the offseted one, 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 = SP_OBJECT(shape)->getRepr()->attribute("inkscape:original");

if ( res_d ) {

Geom::PathVector pv = sp_svg_read_pathv(res_d);

SPCurve *c = new SPCurve(pv);

g_assert(c != NULL);

((SPShape *) offset)->setCurveInsync (c, TRUE);

c->unref();

}

return;

}

// extra paraniac careful check. the preceding if () should take care of this case

if (fabs (offset->rad) < 0.01)

offset->rad = (offset->rad < 0) ? -0.01 : 0.01;

Path *orig = new Path;

orig->Copy ((Path *) offset->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 (offset->rad >= 0)

{

o_width = offset->rad;

orig->OutsideOutline (res, o_width, join_round, butt_straight, 20.0);

}

else

{

o_width = -offset->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);

SPItem *item = shape;

Geom::OptRect bbox = item->getBboxDesktop ();

if ( bbox ) {

gdouble size = L2(bbox->dimensions());

gdouble const exp = item->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 treshhold, 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 (offset->rad >= 0)

{

o_width = offset->rad;

}

else

{

o_width = -offset->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 mesure=((bR-bL)+(bB-bT))*0.5;

if ( mesure < 10.0 ) {

parts[i]->Convert(0.02*mesure);

}

}

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,offset->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]=NULL;

} else {

}

} else {

// trou

holes[i]=1;

parts[i]->Fill(oneCleanPart,0,false,true,true);

onePart->ConvertToShape(oneCleanPart,fill_positive);

oneCleanPart->MakeOffset(onePart,-offset->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]=NULL;

} else {

}

/* int firstP=theShape->nbPt;

}

}

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();

}

if ( parts ) free(parts);

if ( holes ) free(holes);

delete res;

delete theShape;

delete theRes;

}

{

char *res_d = NULL;

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);

SPCurve *c = new SPCurve(pv);

g_assert(c != NULL);

((SPShape *) offset)->setCurveInsync (c, TRUE);

c->unref();

free (res_d);

}

}

static void sp_offset_snappoints(SPItem const *item, std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs)

{

if (((SPItemClass *) parent_class)->snappoints) {

((SPItemClass *) parent_class)->snappoints (item, p, snapprefs);

}

}

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;

}

sp_offset_distance_to_original (SPOffset * offset, Geom::Point px)

{

if (offset == NULL || offset->originalPath == NULL

|| ((Path *) offset->originalPath)->descr_cmd.size() <= 1)

return 1.0;

double dist = 1.0;

Shape *theShape = new Shape;

Shape *theRes = new Shape;

/** \todo

// 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 - to_2geom(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(pxsx,nx)) / 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;

}

sp_offset_top_point (SPOffset * offset, Geom::Point *px)

{

(*px) = Geom::Point(0, 0);

if (offset == NULL)

return;

if (offset->knotSet)

{

(*px) = offset->knot;

return;

}

SPCurve *curve = SP_SHAPE (offset)->getCurve();

if (curve == NULL)

{

sp_offset_set_shape (SP_SHAPE (offset));

curve = SP_SHAPE (offset)->getCurve();

if (curve == NULL)

return;

}

if (curve->is_empty())

{

curve->unref();

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;

curve->unref();

}

static void sp_offset_start_listening(SPOffset *offset,SPObject* to)

{

if ( to == NULL )

return;

offset->sourceObject = to;

offset->sourceRepr = SP_OBJECT_REPR(to);

offset->_delete_connection = SP_OBJECT(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 = SP_OBJECT(to)->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_offset_source_modified), offset));

}

static void sp_offset_quit_listening(SPOffset *offset)

{

if ( offset->sourceObject == NULL )

return;

offset->_modified_connection.disconnect();

offset->_delete_connection.disconnect();

offset->_transformed_connection.disconnect();

offset->sourceRepr = NULL;

offset->sourceObject = NULL;

}

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;

SP_OBJECT(offset)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

}

}

static void

sp_offset_move_compensate(Geom::Matrix const *mp, SPItem */*original*/, SPOffset *self)

{

Inkscape::Preferences *prefs = Inkscape::Preferences::get();

guint mode = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_PARALLEL);

if (mode == SP_CLONE_COMPENSATION_NONE) return;

Geom::Matrix m(*mp);

if (!(m.isTranslation())) return;

// calculate the compensation matrix and the advertized movement matrix

SPItem *item = SP_ITEM(self);

Geom::Matrix compensate;

Geom::Matrix advertized_move;

if (mode == SP_CLONE_COMPENSATION_UNMOVED) {

compensate = Geom::identity();

advertized_move.setIdentity();

} else if (mode == SP_CLONE_COMPENSATION_PARALLEL) {

compensate = m;

advertized_move = m;

} else {

g_assert_not_reached();

}

item->transform *= compensate;

// commit the compensation

item->doWriteTransform(SP_OBJECT_REPR(item), item->transform, &advertized_move);

SP_OBJECT(item)->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 = NULL;

offset->sourceRef->detach();

} else if (mode == SP_CLONE_ORPHANS_DELETE) {

SP_OBJECT(offset)->deleteObject();

}

}

static void

sp_offset_source_modified (SPObject */*iSource*/, guint /*flags*/, SPItem *item)

{

SPOffset *offset = SP_OFFSET(item);

offset->sourceDirty=true;

refresh_offset_source(offset);

((SPShape *) offset)->setShape ();

}

static void

refresh_offset_source(SPOffset* offset)

{

if ( offset == NULL ) 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 == NULL ) return;

SPItem *item = SP_ITEM (refobj);

SPCurve *curve=NULL;

if (!SP_IS_SHAPE (item) && !SP_IS_TEXT (item)) return;

if (SP_IS_SHAPE (item)) {

curve = SP_SHAPE (item)->getCurve ();

if (curve == NULL)

return;

}

if (SP_IS_TEXT (item)) {

curve = SP_TEXT (item)->getNormalizedBpath ();

if (curve == NULL)

return;

}

Path *orig = new Path;

orig->LoadPathVector(curve->get_pathvector());

curve->unref();

// 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", NULL);

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;

//XML Tree being used diectly here while it shouldn't be.

SP_OBJECT (offset)->getRepr()->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 NULL;

}