#define INKSCAPE_LPE_BSPLINE_C

#include <gtkmm/box.h>

#include <gtkmm/button.h>

#include <gtkmm/checkbutton.h>

#include <glib.h>

#include <glibmm/i18n.h>

#include "display/curve.h"

#include <2geom/bezier-curve.h>

#include <2geom/point.h>

#include "helper/geom-curves.h"

#include "live_effects/lpe-bspline.h"

#include "live_effects/lpeobject.h"

#include "live_effects/parameter/parameter.h"

#include "ui/widget/scalar.h"

#include "ui/tool/node.h"

#include "ui/tool/node-tool.h"

#include "ui/tool/control-point-selection.h"

#include "ui/tool/selectable-control-point.h"

#include "selection.h"

#include "xml/repr.h"

#include "svg/svg.h"

#include "sp-path.h"

#include "style.h"

#include "document-private.h"

#include "document.h"

#include "document-undo.h"

#include "desktop-handles.h"

#include "verbs.h"

#include "sp-lpe-item.h"

#include "display/sp-canvas.h"

#include <typeinfo>

#include <vector>

#include "message-stack.h"

#include "inkscape.h"

#include "desktop.h"

using Inkscape::DocumentUndo;

namespace Inkscape {

namespace LivePathEffect {

LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject) :

Effect(lpeobject),

// initialise your parameters here:

//testpointA(_("Test Point A"), _("Test A"), "ptA", &wr, this, Geom::Point(100,100)),

steps(_("Steps whith CTRL:"), _("Change number of steps whith CTRL pressed"), "steps", &wr, this, 2),

ignoreCusp(_("Ignore cusp nodes:"), _("Change ignoring cusp nodes"), "ignoreCusp", &wr, this, true),

onlySelected(_("Change only selected nodes:"), _("Change only selected nodes"), "onlySelected", &wr, this, false),

weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, 0.3334)

{

registerParameter( dynamic_cast<Parameter *>(&ignoreCusp) );

registerParameter( dynamic_cast<Parameter *>(&onlySelected) );

registerParameter( dynamic_cast<Parameter *>(&weight) );

registerParameter( dynamic_cast<Parameter *>(&steps) );

weight.param_set_range(0.0000, 1);

weight.param_set_increments(0.1, 0.1);

weight.param_set_digits(4);

steps.param_set_range(1, 10);

steps.param_set_increments(1, 1);

steps.param_set_digits(0);

}

LPEBSpline::~LPEBSpline()

{

}

LPEBSpline::createAndApply(const char* name, SPDocument *doc, SPItem *item)

{

if (!SP_IS_SHAPE(item)) {

g_warning("LPE BSpline can only be applied to shapes (not groups).");

}else{

// Path effect definition

Inkscape::XML::Document *xml_doc = doc->getReprDoc();

Inkscape::XML::Node *repr = xml_doc->createElement("inkscape:path-effect");

repr->setAttribute("effect", name);

doc->getDefs()->getRepr()->addChild(repr, NULL); // adds to <defs> and assigns the 'id' attribute

const gchar * repr_id = repr->attribute("id");

Inkscape::GC::release(repr);

gchar *href = g_strdup_printf("#%s", repr_id);

sp_lpe_item_add_path_effect(SP_LPE_ITEM(item), href, true);

g_free(href);

}

}

LPEBSpline::doEffect(SPCurve * curve)

{

if(curve->get_segment_count() < 2)

return;

// Make copy of old path as it is changed during processing

Geom::PathVector const original_pathv = curve->get_pathvector();

curve->reset();

//Recorremos todos los paths a los que queremos aplicar el efecto, hasta el penúltimo

for(Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {

//Si está vacío...

if (path_it->empty())

continue;

//Itreadores

Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve

Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); // outgoing curve

Geom::Path::const_iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop

//Creamos las lineas rectas que unen todos los puntos del trazado y donde se calcularán

//los puntos clave para los manejadores.

//Esto hace que la curva BSpline no pierda su condición aunque se trasladen

//dichos manejadores

SPCurve *nCurve = new SPCurve();

Geom::Point previousNode(0,0);

Geom::Point node(0,0);

Geom::Point pointAt1(0,0);

Geom::Point pointAt2(0,0);

Geom::Point nextPointAt1(0,0);

Geom::Point nextPointAt2(0,0);

Geom::Point nextPointAt3(0,0);

Geom::D2< Geom::SBasis > SBasisIn;

Geom::D2< Geom::SBasis > SBasisOut;

Geom::D2< Geom::SBasis > SBasisHelper;

Geom::CubicBezier const *cubic = NULL;

if (path_it->closed()) {

// if the path is closed, maybe we have to stop a bit earlier because the closing line segment has zerolength.

const Geom::Curve &closingline = path_it->back_closed(); // the closing line segment is always of type Geom::LineSegment.

if (are_near(closingline.initialPoint(), closingline.finalPoint())) {

// closingline.isDegenerate() did not work, because it only checks for *exact* zero length, which goes wrong for relative coordinates and rounding errors...

// the closing line segment has zero-length. So stop before that one!

curve_endit = path_it->end_open();

}

}

//Si la curva está cerrada calculamos el punto donde

//deveria estar el nodo BSpline de cierre/inicio de la curva

//en posible caso de que se cierre con una linea recta creando un nodo BSPline

nCurve->moveto(curve_it1->initialPoint());

//Recorremos todos los segmentos menos el último

while ( curve_it2 != curve_endit )

{

//previousPointAt3 = pointAt3;

//Calculamos los puntos que dividirían en tres segmentos iguales el path recto de entrada y de salida

SPCurve * in = new SPCurve();

in->moveto(curve_it1->initialPoint());

in->lineto(curve_it1->finalPoint());

cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);

if(cubic){

SBasisIn = in->first_segment()->toSBasis();

pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1],*in->first_segment()));

pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2],*in->first_segment()));

}else{

pointAt1 = in->first_segment()->initialPoint();

pointAt2 = in->first_segment()->finalPoint();

}

in->reset();

delete in;

//Y hacemos lo propio con el path de salida

//nextPointAt0 = curveOut.valueAt(0);

SPCurve * out = new SPCurve();

out->moveto(curve_it2->initialPoint());

out->lineto(curve_it2->finalPoint());

cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it2);

if(cubic){

SBasisOut = out->first_segment()->toSBasis();

nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1],*out->first_segment()));

nextPointAt2 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[2],*out->first_segment()));;

nextPointAt3 = out->first_segment()->finalPoint();

}else{

nextPointAt1 = out->first_segment()->initialPoint();

nextPointAt2 = out->first_segment()->finalPoint();

nextPointAt3 = out->first_segment()->finalPoint();

}

out->reset();

delete out;

//La curva BSpline se forma calculando el centro del segmanto de unión

//de el punto situado en las 2/3 partes de el segmento de entrada

//con el punto situado en la posición 1/3 del segmento de salida

//Estos dos puntos ademas estan posicionados en el lugas correspondiente de

//los manejadores de la curva

SPCurve *lineHelper = new SPCurve();

lineHelper->moveto(pointAt2);

lineHelper->lineto(nextPointAt1);

SBasisHelper = lineHelper->first_segment()->toSBasis();

lineHelper->reset();

delete lineHelper;

//almacenamos el punto del anterior bucle -o el de cierre- que nos hara de principio de curva

previousNode = node;

//Y este hará de final de curva

node = SBasisHelper.valueAt(0.5);

nCurve->curveto(pointAt1, pointAt2, node);

//aumentamos los valores para el siguiente paso en el bucle

++curve_it1;

++curve_it2;

}

//Si está cerrada la curva, la cerramos sobre el valor guardado previamente

//Si no finalizamos en el punto final

Geom::Point startNode(0,0);

if (path_it->closed()) {

SPCurve * start = new SPCurve();

start->moveto(path_it->begin()->initialPoint());

start->lineto(path_it->begin()->finalPoint());

Geom::D2< Geom::SBasis > SBasisStart = start->first_segment()->toSBasis();

SPCurve *lineHelper = new SPCurve();

cubic = dynamic_cast<Geom::CubicBezier const*>(&*path_it->begin());

if(cubic){

lineHelper->moveto(SBasisStart.valueAt(Geom::nearest_point((*cubic)[1],*start->first_segment())));

}else{

lineHelper->moveto(start->first_segment()->initialPoint());

}

start->reset();

delete start;

SPCurve * end = new SPCurve();

end->moveto(curve_it1->initialPoint());

end->lineto(curve_it1->finalPoint());

Geom::D2< Geom::SBasis > SBasisEnd = end->first_segment()->toSBasis();

//Geom::BezierCurve const *bezier = dynamic_cast<Geom::BezierCurve const*>(&*curve_endit);

cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);

if(cubic){

lineHelper->lineto(SBasisEnd.valueAt(Geom::nearest_point((*cubic)[2],*end->first_segment())));

}else{

lineHelper->lineto(end->first_segment()->finalPoint());

}

end->reset();

delete end;

SBasisHelper = lineHelper->first_segment()->toSBasis();

lineHelper->reset();

delete lineHelper;

startNode = SBasisHelper.valueAt(0.5);

nCurve->curveto(nextPointAt1, nextPointAt2, startNode);

nCurve->move_endpoints(startNode,startNode);

}else{

SPCurve * start = new SPCurve();

start->moveto(path_it->begin()->initialPoint());

start->lineto(path_it->begin()->finalPoint());

startNode = start->first_segment()->initialPoint();

start->reset();

delete start;

nCurve->curveto(nextPointAt1, nextPointAt2, nextPointAt3);

nCurve->move_endpoints(startNode,nextPointAt3);

}

//y cerramos la curva

if (path_it->closed()) {

nCurve->closepath_current();

}

curve->append(nCurve,false);

nCurve->reset();

delete nCurve;

}

}

Gtk::Widget *

LPEBSpline::newWidget()

{

// use manage here, because after deletion of Effect object, others might still be pointing to this widget.

Gtk::VBox * vbox = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );

vbox->set_border_width(5);

std::vector<Parameter *>::iterator it = param_vector.begin();

while (it != param_vector.end()) {

if ((*it)->widget_is_visible) {

Parameter * param = *it;

Gtk::Widget * widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());

if(param->param_key == "weight"||param->param_key == "steps"){

Inkscape::UI::Widget::Scalar * widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));

widgRegistered->signal_value_changed().connect(sigc::mem_fun (*this,&LPEBSpline::toWeight));

widg = dynamic_cast<Gtk::Widget *>(widgRegistered);

}

if(param->param_key == "onlySelected"){

Gtk::CheckButton * widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));

widg = dynamic_cast<Gtk::Widget *>(widgRegistered);

}

if(param->param_key == "ignoreCusp"){

Gtk::CheckButton * widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));

widg = dynamic_cast<Gtk::Widget *>(widgRegistered);

}

Glib::ustring * tip = param->param_getTooltip();

if (widg) {

vbox->pack_start(*widg, true, true, 2);

if (tip) {

widg->set_tooltip_text(*tip);

} else {

widg->set_tooltip_text("");

widg->set_has_tooltip(false);

}

}

}

++it;

}

Gtk::Button* defaultWeight = Gtk::manage(new Gtk::Button(Glib::ustring(_("Default weight 0.3334"))));

defaultWeight->set_alignment(0.0, 0.5);

defaultWeight->signal_clicked().connect(sigc::mem_fun (*this,&LPEBSpline::toDefaultWeight));

Gtk::Widget* defaultWeightWidget = dynamic_cast<Gtk::Widget *>(defaultWeight);

vbox->pack_start(*defaultWeightWidget, true, true,2);

Gtk::Button* makeCusp = Gtk::manage(new Gtk::Button(Glib::ustring(_("Make cusp"))));

makeCusp->set_alignment(0.0, 0.5);

makeCusp->signal_clicked().connect(sigc::mem_fun (*this,&LPEBSpline::toMakeCusp));

Gtk::Widget* makeCuspWidget = dynamic_cast<Gtk::Widget *>(makeCusp);

vbox->pack_start(*makeCuspWidget, true, true,2);

return dynamic_cast<Gtk::Widget *>(vbox);

}

LPEBSpline::toDefaultWeight(){

changeWeight(0.3334);

}

LPEBSpline::toMakeCusp(){

changeWeight(0.0000);

}

LPEBSpline::toWeight(){

changeWeight(weight);

}

LPEBSpline::changeWeight(double weightValue)

{

SPDesktop *desktop = inkscape_active_desktop();

Inkscape::Selection *selection = sp_desktop_selection(desktop);

GSList *items = (GSList *) selection->itemList();

SPItem *item = (SPItem *)g_slist_nth(items,0)->data;

SPPath *path = SP_PATH(item);

SPCurve *curve = path->get_curve_for_edit();

LPEBSpline::doBSplineFromWidget(curve,weightValue);

gchar *str = sp_svg_write_path(curve->get_pathvector());

path->getRepr()->setAttribute("inkscape:original-d", str);

if(INK_IS_NODE_TOOL(desktop->event_context)){

InkNodeTool *nt = INK_NODE_TOOL(desktop->event_context);

nt->desktop->updateNow();

}

g_free(str);

curve->unref();

desktop->clearWaitingCursor();

DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_LPE,

_("Modified the weight of the BSpline"));

}

LPEBSpline::nodeIsSelected(Geom::Point nodePoint){

if(points.size() > 0){

for(std::vector<Geom::Point>::iterator i = points.begin(); i != points.end();){

Geom::Point p = static_cast<Geom::Point>(*i);

if(Geom::are_near(p, nodePoint)){

return true;

points.erase(i);

}

i++;

}

}

return false;

}

LPEBSpline::doBSplineFromWidget(SPCurve * curve, double weightValue)

{

using Geom::X;

using Geom::Y;

SPDesktop *desktop = inkscape_active_desktop();

if(INK_IS_NODE_TOOL(desktop->event_context)){

InkNodeTool *nt = INK_NODE_TOOL(desktop->event_context);

Inkscape::UI::ControlPointSelection::Set &selection = nt->_selected_nodes->allPoints();

points.clear();

std::vector<Geom::Point>::iterator pbegin;

for (Inkscape::UI::ControlPointSelection::Set::iterator i = selection.begin(); i != selection.end(); ++i){

if ((*i)->selected()) {

Inkscape::UI::Node *n = static_cast<Inkscape::UI::Node*>(*i);

pbegin = points.begin();

points.insert(pbegin,desktop->doc2dt(n->position()));

}

}

}

//bool hasNodesSelected = LPEBspline::hasNodesSelected();

if(curve->get_segment_count() < 2)

return;

// Make copy of old path as it is changed during processing

Geom::PathVector const original_pathv = curve->get_pathvector();

curve->reset();

//Recorremos todos los paths a los que queremos aplicar el efecto, hasta el penúltimo

for(Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {

//Si está vacío...

if (path_it->empty())

continue;

//Itreadores

Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve

Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); // outgoing curve

Geom::Path::const_iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop

//Creamos las lineas rectas que unen todos los puntos del trazado y donde se calcularán

//los puntos clave para los manejadores.

//Esto hace que la curva BSpline no pierda su condición aunque se trasladen

//dichos manejadores

SPCurve *nCurve = new SPCurve();

Geom::Point pointAt0(0,0);

Geom::Point pointAt1(0,0);

Geom::Point pointAt2(0,0);

Geom::Point pointAt3(0,0);

Geom::Point nextPointAt0(0,0);

Geom::Point nextPointAt1(0,0);

Geom::Point nextPointAt2(0,0);

Geom::Point nextPointAt3(0,0);

Geom::D2< Geom::SBasis > SBasisIn;

Geom::D2< Geom::SBasis > SBasisOut;

Geom::CubicBezier const *cubic = NULL;

if (path_it->closed()) {

// if the path is closed, maybe we have to stop a bit earlier because the closing line segment has zerolength.

const Geom::Curve &closingline = path_it->back_closed(); // the closing line segment is always of type Geom::LineSegment.

if (are_near(closingline.initialPoint(), closingline.finalPoint())) {

// closingline.isDegenerate() did not work, because it only checks for *exact* zero length, which goes wrong for relative coordinates and rounding errors...

// the closing line segment has zero-length. So stop before that one!

curve_endit = path_it->end_open();

}

}

//Si la curva está cerrada calculamos el punto donde

//deveria estar el nodo BSpline de cierre/inicio de la curva

//en posible caso de que se cierre con una linea recta creando un nodo BSPline

nCurve->moveto(curve_it1->initialPoint());

//Recorremos todos los segmentos menos el último

while ( curve_it2 != curve_endit )

{

//previousPointAt3 = pointAt3;

//Calculamos los puntos que dividirían en tres segmentos iguales el path recto de entrada y de salida

SPCurve * in = new SPCurve();

in->moveto(curve_it1->initialPoint());

in->lineto(curve_it1->finalPoint());

cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);

pointAt0 = in->first_segment()->initialPoint();

pointAt3 = in->first_segment()->finalPoint();

SBasisIn = in->first_segment()->toSBasis();

if(!onlySelected){

if(cubic){

if(!ignoreCusp || !Geom::are_near((*cubic)[1],pointAt0)){

pointAt1 = SBasisIn.valueAt(weightValue);

if(weightValue !=0.0000){

pointAt1 = Geom::Point(pointAt1[X] + 0.0001,pointAt1[Y] + 0.0001);

}

}else{

pointAt1 = in->first_segment()->initialPoint();

}

if(!ignoreCusp || !Geom::are_near((*cubic)[2],pointAt3)){

pointAt2 = SBasisIn.valueAt(1-weightValue);

if(weightValue !=0.0000){

pointAt2 = Geom::Point(pointAt2[X] + 0.0001,pointAt2[Y] + 0.0001);

}

}else{

pointAt2 = in->first_segment()->finalPoint();

}

}else{

if(!ignoreCusp && weightValue !=0.0000){

pointAt1 = SBasisIn.valueAt(weightValue);

if(weightValue !=0.0000){

pointAt1 = Geom::Point(pointAt1[X] + 0.0001,pointAt1[Y] + 0.0001);

}

pointAt2 = SBasisIn.valueAt(1-weightValue);

if(weightValue !=0.0000){

pointAt2 = Geom::Point(pointAt2[X] + 0.0001,pointAt2[Y] + 0.0001);

}

}else{

pointAt1 = in->first_segment()->initialPoint();

pointAt2 = in->first_segment()->finalPoint();

}

}

}else{

if(cubic){

if(!ignoreCusp || !Geom::are_near((*cubic)[1],pointAt0)){

if(nodeIsSelected(pointAt0)){

pointAt1 = SBasisIn.valueAt(weightValue);

if(weightValue !=0.0000){

pointAt1 = Geom::Point(pointAt1[X] + 0.0001,pointAt1[Y] + 0.0001);

}

}else{

pointAt1 = (*cubic)[1];

}

}else{

pointAt1 = in->first_segment()->initialPoint();

}

if(!ignoreCusp || !Geom::are_near((*cubic)[2],pointAt3)){

if(nodeIsSelected(pointAt3)){

pointAt2 = SBasisIn.valueAt(1-weightValue);

if(weightValue !=0.0000){

pointAt2 = Geom::Point(pointAt2[X] + 0.0001,pointAt2[Y] + 0.0001);

}

}else{

pointAt2 = (*cubic)[2];

}

}else{

pointAt2 = in->first_segment()->finalPoint();

}

}else{

if(!ignoreCusp && weightValue !=0.000){

if(nodeIsSelected(pointAt0)){

pointAt1 = SBasisIn.valueAt(weightValue);

pointAt1 = Geom::Point(pointAt1[X] + 0.0001,pointAt1[Y] + 0.0001);

}else{

pointAt1 = in->first_segment()->initialPoint();

}

if(nodeIsSelected(pointAt3)){

pointAt2 = SBasisIn.valueAt(weightValue);

pointAt2 = Geom::Point(pointAt2[X] + 0.0001,pointAt2[Y] + 0.0001);

}else{

pointAt2 = in->first_segment()->finalPoint();

}

}else{

pointAt1 = in->first_segment()->initialPoint();

pointAt2 = in->first_segment()->finalPoint();

}

}

}

in->reset();

delete in;

//La curva BSpline se forma calculando el centro del segmanto de unión

//de el punto situado en las 2/3 partes de el segmento de entrada

//con el punto situado en la posición 1/3 del segmento de salida

//Estos dos puntos ademas estan posicionados en el lugas correspondiente de

//los manejadores de la curva

nCurve->curveto(pointAt1, pointAt2, pointAt3);

//aumentamos los valores para el siguiente paso en el bucle

++curve_it1;

++curve_it2;

}

SPCurve * out = new SPCurve();

out->moveto(curve_it1->initialPoint());

out->lineto(curve_it1->finalPoint());

SBasisOut = out->first_segment()->toSBasis();

nextPointAt0 = out->first_segment()->initialPoint();

nextPointAt3 = out->first_segment()->finalPoint();

cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);

if(!onlySelected){

if(cubic){

if(!ignoreCusp || !Geom::are_near((*cubic)[1],nextPointAt0)){

nextPointAt1 = SBasisOut.valueAt(weightValue);

if(weightValue !=0.0000){

nextPointAt1 = Geom::Point(nextPointAt1[X] + 0.0001,nextPointAt1[Y] + 0.0001);

}

}else{

nextPointAt1 = out->first_segment()->initialPoint();

}

if(!ignoreCusp || !Geom::are_near((*cubic)[2],nextPointAt3)){

nextPointAt2 = SBasisOut.valueAt(1-weightValue);

if(weightValue !=0.0000){

nextPointAt2 = Geom::Point(nextPointAt2[X] + 0.0001,nextPointAt2[Y] + 0.0001);

}

}else{

nextPointAt2 = out->first_segment()->finalPoint();

}

}else{

if(!ignoreCusp && weightValue !=0.0000){

nextPointAt1 = SBasisOut.valueAt(weightValue);

nextPointAt1 = Geom::Point(nextPointAt1[X] + 0.0001,nextPointAt1[Y] + 0.0001);

nextPointAt2 = SBasisOut.valueAt(1-weightValue);

nextPointAt2 = Geom::Point(nextPointAt2[X] + 0.0001,nextPointAt2[Y] + 0.0001);

}else{

nextPointAt1 = out->first_segment()->initialPoint();

nextPointAt2 = out->first_segment()->finalPoint();

}

}

}else{

if(cubic){

if(!ignoreCusp || !Geom::are_near((*cubic)[1],nextPointAt0)){

if(nodeIsSelected(nextPointAt0)){

nextPointAt1 = SBasisOut.valueAt(weightValue);

if(weightValue !=0.0000){

nextPointAt1 = Geom::Point(nextPointAt1[X] + 0.0001,nextPointAt1[Y] + 0.0001);

}

}else{

nextPointAt1 = (*cubic)[1];

}

}else{

nextPointAt1 = out->first_segment()->initialPoint();

}

if(!ignoreCusp || !Geom::are_near((*cubic)[2],nextPointAt3)){

if(nodeIsSelected(nextPointAt3)){

nextPointAt2 = SBasisOut.valueAt(1-weightValue);

if(weightValue !=0.0000){

nextPointAt2 = Geom::Point(nextPointAt2[X] + 0.0001,nextPointAt2[Y] + 0.0001);

}

}else{

nextPointAt2 = (*cubic)[2];

}

}else{

nextPointAt2 = out->first_segment()->finalPoint();

}

}else{

if(!ignoreCusp && weightValue !=0.0000){

if(nodeIsSelected(nextPointAt0)){

nextPointAt1 = SBasisOut.valueAt(weightValue);

nextPointAt1 = Geom::Point(nextPointAt1[X] + 0.0001,nextPointAt1[Y] + 0.0001);

}else{

nextPointAt1 = out->first_segment()->initialPoint();

}

if(nodeIsSelected(nextPointAt3)){

nextPointAt2 = SBasisOut.valueAt(weightValue);

nextPointAt2 = Geom::Point(nextPointAt2[X] + 0.0001,nextPointAt2[Y] + 0.0001);

}else{

nextPointAt2 = out->first_segment()->finalPoint();

}

}else{

nextPointAt1 = out->first_segment()->initialPoint();

nextPointAt2 = out->first_segment()->finalPoint();

}

}

}

out->reset();

delete out;

//Aberiguamos la ultima parte de la curva correspondiente al último segmento

//Y hacemos lo propio con el path de salida

//nextPointAt0 = curveOut.valueAt(0);

if (path_it->closed()) {

nCurve->curveto(nextPointAt1, nextPointAt2, path_it->begin()->initialPoint());

nCurve->move_endpoints(path_it->begin()->initialPoint(),path_it->begin()->initialPoint());

}else{

nCurve->curveto(nextPointAt1, nextPointAt2, nextPointAt3);

nCurve->move_endpoints(path_it->begin()->initialPoint(),nextPointAt3);

}

//y cerramos la curva

if (path_it->closed()) {

nCurve->closepath_current();

}

curve->append(nCurve,false);

nCurve->reset();

delete nCurve;

}

}

}; //namespace LivePathEffect

}; /* namespace Inkscape */