Merge lp:~inkscape.dev/inkscape/fillet-chamfer into lp:~inkscape.dev/inkscape/trunk

[Jabiertxof]

Add fillet and chanfer LPE, here is a video working: https://www.youtube.com/watch?v=wJKzGhJULfc

[lp:~inkscape.dev/inkscape/fillet-chamfer]

13422. By Jabiertxof <email address hidden> on 2014-05-30

Fixed a bug that advert Josh Andler. Also fixed calculations in non straight lines

13423. By Jabiertxof <email address hidden> on 2014-05-30

update to trunk

13424. By Jabiertxof <email address hidden> on 2014-05-30

Overlaping knots/radius removed to more beauty result

[njh (njh-njhurst)]

A very nice piece of work, congratulations. The video is great too. I've put a lot of comments in, I don't expect you to fix them all in this commit, but I want you to understand them all and work out which you are going to do in your next iteration. The biggest changes I see are around changing from storing data in an array of points to building a separate Pointwise abstract class similar to Piecewise which manages all of the slicing and search operations you currently have scattered through your code.

The main area you need to work on is learning to use more abstract concepts - it's great to understand how the mathematics works at the bottom level, but to become a great programmer/mathematician you need to practice refactoring your code/ideas into simpler, more elegant forms. That way you can level-up to write more in less time.

[Jabiertxof (jabiertxof)]

Hi Nathan i go on:
Think the first is solve the class substitute to the vector<point>.
In my mind there is a object, like you say Pointwise that handles:

########################
Pointwise<
        enum typeof /*handle the type of fillet,chamfer.. and can be extended
for other uses*/,
        bool active /**/,
        bool hidden /**/,
        ?double time /**/
        double size /*one, time or size need to be 0 to get the other value,
you know the right way to handle this? Now is handled negative values
are size and positive times.*/
>
########################

Where is the better place for the class? Im not sure if is correct
create a class like that. Please tell me your opinion. Also we can
expand it.

For the moment thats all, I read all your comments, thanks for the time
on it! I correct all i can while refactor with the new class.

Regards, Jabier.

[Jabiertxof (jabiertxof)]

Also have a question about handle subpaths.
Is ok something like: std::vector<Pointwise>?
There is a standar way to apply this data to svg string?
I need 3 separators and i only see 2 ", and |", can use for example + or #?

Regards,Jabier.

[njh (njh-njhurst)]

On Sat, May 31, 2014 at 06:45:40PM -0000, Jabiertxof wrote:
> Hi Nathan i go on:
> Think the first is solve the class substitute to the vector<point>.
> In my mind there is a object, like you say Pointwise that handles:
>
> ########################
> Pointwise<
> enum typeof /*handle the type of fillet,chamfer.. and can be extended
> for other uses*/,
> bool active /**/,
> bool hidden /**/,
> ?double time /**/
> double size /*one, time or size need to be 0 to get the other value,
> you know the right way to handle this? Now is handled negative values
> are size and positive times.*/

You just want an extra bit to specify the correct choice.

> >
> ########################
>
> Where is the better place for the class? Im not sure if is correct
> create a class like that. Please tell me your opinion. Also we can
> expand it.

So I think Pointwise itself should go in 2geom, because it is a common
thing to do relating to paths and geometry. The class that you put in
the <T> is much like you say, but you might like to do the
polymorphism using a disjuntive type. In C++ you do this like in the
Path class, you make a base class (like Curve), and everything that
goes into pointwise is a reference to a subclass of it. The advantage
of this is that you can mix and match, your dispatch can handle a lot
of the selection problem (which method to call for which code). The
main downside is that it has a much higher memory management
overhead. Otherwise put everything you need in a single class.

I'll ask around and see if there are any other good choices.

> For the moment thats all, I read all your comments, thanks for the time
> on it! I correct all i can while refactor with the new class.

That's ok, I was up and didn't have anything important to do, so I
think it was time well spent (it took me about 2 hours total, which
goes to show how important good code readability is - I've spent much
more time reading your code than writing it :)

njh

[MenTaLguY (mental-deactivatedaccount)]

Rather than an enum template parameter, consider a policy. https://en.wikipedia.org/wiki/Policy-based_design

[Jabiertxof (jabiertxof)]

> Rather than an enum template parameter, consider a policy.
> https://en.wikipedia.org/wiki/Policy-based_design

Thanks very much, I consider it.

[Jabiertxof (jabiertxof)]

> So I think Pointwise itself should go in 2geom

OK

> you make a base class (like Curve) [...]
> Otherwise put everything you need in a single class.

Not sure whats better, i like the first one but no have real expertize.

> I'll ask around and see if there are any other good choices.

Perfect, please tell me about, im waiting if yes or not.

> it was time well spent

Thanks!

[Jabiertxof (jabiertxof)]

Another question, maybe this class can be used also in the bspline branch, it remove all extra staff of the node related tool. And maybe simplify the pen related staff.

[njh (njh-njhurst)]

> Also have a question about handling subpaths.
> Is something like: std::vector<Pointwise> ok?

Sure, you might call it PointwiseVector like PathVector.

> There is a standard way to apply this data to an svg string?
> I need 3 separators and I only see 2 ", and |", can I use, for example, + or #?

I'm not quite sure what you're asking for, do you want to store the data in an attribute in svg with your own namespace? Then you can use any xml valid string you like. You could use Aaron's ragel parser that he wrote for svg d attribute parsing as a starting point. You will need to check that inkscape correctly maintains namespaced attributes (I'm pretty sure it does).

I don't think you should store anything in the svg:d attribute itself.

[njh (njh-njhurst)]

> > So I think Pointwise itself should go in 2geom
>
> OK
>
> > you make a base class (like Curve) [...]
> > Otherwise put everything you need in a single class.
>
> Not sure whats better, i like the first one but no have real expertize.

The first is a good option. But before you commit to a design, can you write up a class with exactly the data you want to store so I can take a look?

> > I'll ask around and see if there are any other good choices.
>
> Perfect, please tell me about, im waiting if yes or not.

I asked Mental to take a look, he thinks the first option is good.

[njh (njh-njhurst)]

> Another question, maybe this class can be used also in the bspline branch, it
> remove all extra staff of the node related tool. And maybe simplify the pen
> related staff.

That's a great idea, if you know those pieces of code well you should try porting all of them to use your pointwise class. I would suggest you get it working for fillet-chamfer first, then look at what needs to be added for each of the others. That way you won't spend the rest of your life trying to cover every possible case.

It's certainly something that we've thought about a lot when we were working on 2geom - how to attach 'sidecar data' to paths. I think your pointwise class is a very nice start to solving that problem.

(grandpa story time:) When I was thinking about this and related problems I could only think about representing the data as a row-store. That is, all the data for the pen size, markers etc had to be stored in the same Curve object. This is how databases are often implemented. But it's very hard for paths because of things like ranges and functions of arclength. I've since realised that a column store representation is the right solution. The hard part is making sure that all edits are correctly applied to all columns. We can talk about that once you've got the basic Pointwise stuff done. The more I think about this, the more I'm convinced this is the right solution!

[Jabiertxof (jabiertxof)]

> > Also have a question about handling subpaths.
> > Is something like: std::vector<Pointwise> ok?
>
> Sure, you might call it PointwiseVector like PathVector.

OK.

> > There is a standard way to apply this data to an svg string?
> > I need 3 separators and I only see 2 ", and |", can I use, for example, + or
> #?
>
> I'm not quite sure what you're asking for, do you want to store the data in an
> attribute in svg with your own namespace? Then you can use any xml valid
> string you like. You could use Aaron's ragel parser that he wrote for svg d
> attribute parsing as a starting point. You will need to check that inkscape
> correctly maintains namespaced attributes (I'm pretty sure it does).
>
> I don't think you should store anything in the svg:d attribute itself.

I want to strore a paremeter LPE.

[njh (njh-njhurst)]

> I want to strore a paremeter LPE.

Ask on the inkscape-devel mailing list. Johan might have an idea, I don't know anything about that stuff.

[Jabiertxof (jabiertxof)]

> The first is a good option. But before you commit to a design, can you write
> up a class with exactly the data you want to store so I can take a look?

Yes send you soon.

> I asked Mental to take a look, he thinks the first option is good.

Ok Thanks

[Jabiertxof (jabiertxof)]

> > I want to strore a paremeter LPE.
>
> Ask on the inkscape-devel mailing list. Johan might have an idea, I don't
> know anything about that stuff.

OK , i ask soon.
Regards.

[Jabiertxof (jabiertxof)]

One question im on the tree of the class and have a question.
How many "SPoints" "have a node", think 2 are enougth but maybe is beter make it flexible inside a vector.

[njh (njh-njhurst)]

> One question im on the tree of the class and have a question.
> How many "SPoints" "have a node", think 2 are enougth but maybe is beter make
> it flexible inside a vector.

What are SPoints? how do you maintain the relationship between them and the curve? Keeping things in sorted order makes merging much easier (like you already have).

The two obvious ways to me are a) have a 1:1 mapping between curve nodes and these SPoints (that's a fairly poor name btw, it doesn't mean anything to me at all). b) include the corresponding node index in the SPoint.

[Jabiertxof (jabiertxof)]

Spoint -> NodePointExtender... Fell free to sugest other better.
I think can be cases with more than required two "extenders" per node, so, if i undertand it well, i prefear the second one.

[lp:~inkscape.dev/inkscape/fillet-chamfer]

13425. By Jabiertxof <email address hidden> on 2014-06-29

update to trunk

13426. By Jabiertxof <email address hidden> on 2014-07-01

Fixed problems in Nathan review, todo: add PointWise class

13427. By Jabiertxof <email address hidden> on 2014-07-01

update to trunk

13428. By Jabiertxof <email address hidden> on 2014-07-01

Full remove knot doubleclick

13429. By Jabiertxof <email address hidden> on 2014-07-01

change isDegenerate by are_near

[Jabiertxof (jabiertxof)]

Saving diff reply comments

[lp:~inkscape.dev/inkscape/fillet-chamfer]

13430. By Jabiertxof <email address hidden> on 2014-07-02

remove percent const

13431. By Jabiertxof <email address hidden> on 2014-07-02

update to trunk

13432. By Jabiertxof <email address hidden> on 2014-07-02

Fixed CMakeLists.txt pointed by Liam

13433. By Jabiertxof <email address hidden> on 2014-07-02

Put correctly doubles in a function

13434. By Jabiertxof <email address hidden> on 2014-07-07

Add LiamW changes

13435. By Jabiertxof <email address hidden> on 2014-07-07

update to trunk

13436. By Jabiertxof <email address hidden> on 2014-07-23

Fix bug on closed nodes in fillet-chamfer LPE

13437. By Jabiertxof <email address hidden> on 2014-07-23

update to trunk

13438. By Jabiertxof <email address hidden> on 2014-07-24

Fix a bug on type of 'fillet' on the closing node

13439. By Jabiertxof <email address hidden> on 2014-07-29

fix bug on open paths

13440. By root <email address hidden> on 2014-07-30

update to trunk

13441. By Jabiertxof <email address hidden> on 2014-08-10

update to trunk

13442. By Jabiertxof <email address hidden> on 2014-08-11

Added reset modifier to knotas pointed by suv

13443. By Jabiertxof <email address hidden> on 2014-08-11

add a missing line

13444. By Jabiertxof <email address hidden> on 2014-08-11

Fix LPE filet-chamfer name to sweet experimental branch

13445. By Jabiertxof <email address hidden> on 2014-08-11

update to trunk

13446. By Jabiertxof <email address hidden> on 2014-08-11

fix a bug knots resetting

13447. By Jabiertxof <email address hidden> on 2014-08-25

update to trunk

13448. By Jabiertxof <email address hidden> on 2014-08-26

Updated to use Arcs instead Bezier in fillet and inverse fillet

13449. By root <email address hidden> on 2014-08-26

adde force arc bool parameter in cubic bezier

13450. By root <email address hidden> on 2014-08-26

fixed locale in popup knot

13451. By root <email address hidden> on 2014-08-27

Added real radius and optionaly ditance to knots, also fixed subpaths bug

13452. By Jabiertxof <email address hidden> on 2014-08-27

migrate some code to a reusable function

13453. By Jabiertxof <email address hidden> on 2014-08-31

migrate more code to a reusable function

13454. By Jabiertxof <email address hidden> on 2014-08-31

update to trunk

13455. By Jabiertxof <email address hidden> on 2014-09-01

fixing bugs in fillet chamfer

13456. By Jabiertxof <email address hidden> on 2014-09-07

working on radious fillet chamfer

13457. By Jabiertxof <email address hidden> on 2014-09-07

Add HAVE_GLIBMM_THREADS_H check to fillet-chamfer by Liam

13458. By Jabiertxof <email address hidden> on 2014-09-07

fixing radious problems

13459. By Jabiertxof <email address hidden> on 2014-09-07

update to trunk

13460. By Jabiertxof <email address hidden> on 2014-09-10

updated for use also radius

13461. By Jabiertxof <email address hidden> on 2014-09-10

update to trunk

13462. By Jabiertxof <email address hidden> on 2014-09-10

Fixed code in locale, get from LiamW fix

13463. By Jabiertxof <email address hidden> on 2014-09-10

update to trunk

13464. By Jabiertxof <email address hidden> on 2014-09-11

Fix locale and bugs applied to arcs

13465. By Jabiertxof <email address hidden> on 2014-09-11

Fix locale, for the moment use classic locale

13466. By Jabiertxof <email address hidden> on 2014-09-11

Add numeric input in knot click

13467. By Jabiertxof <email address hidden> on 2014-09-28

update to trunk

13468. By Jabiertxof <email address hidden> on 2014-09-29

Fillet-Chamfer update. Two things.
Helper paths on knots: now work well in rect and curves
Method: Now the method ase selectable. Three methods:
Auto: Straight lines whith arcs and curves whith bezier
Arc: Always use arc.
Bezier: Always use bezier.

13469. By Jabiertxof <email address hidden> on 2014-09-29

A little fix in fillet-chamfer to hide knot helper path at hide the knots

13470. By Jabiertxof <email address hidden> on 2014-10-21

update to trunk

13471. By Jabiertxof <email address hidden> on 2014-10-21

Starting pointwise refactor

13472. By Jabiertxof <email address hidden> on 2014-10-22

pointwise dfinitions

[su_v (suv-lp)]

fillet-chamfer was added to experimental in r13415
http://bazaar.launchpad.net/~inkscape.dev/inkscape/experimental/revision/13415

experimental was merged into trunk in r13641
http://bazaar.launchpad.net/~inkscape.dev/inkscape/trunk/revision/13641

Changing status to 'Merged'.

=== added file 'src/2geom/pointwise.h'
--- src/2geom/pointwise.h	1970-01-01 00:00:00 +0000
+++ src/2geom/pointwise.h	2014-10-22 21:40:37 +0000
@@ -0,0 +1,90 @@
+/**
+ * \file
+ * \brief Pointwise
+ *//*
+ * Authors:
+ *
+ * Copyright 2014  authors
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, output to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ *
+ */
+
+#ifndef SEEN_GEOM_POINTWISE_H
+#define SEEN_GEOM_POINTWISE_H
+
+#include <vector>
+#include <2geom/sbasis.h>
+#include <2geom/sbasis-2d.h>
+#include <2geom/piecewise.h>
+#include <2geom/satellite.h>
+#include <2geom/affine.h>
+
+namespace Geom {
+/**
+ * %Pointwise function class.
+ */
+
+class Pointwise
+{
+    public:
+        Pointwise(){}
+        
+        Pointwise(Piecewise<D2<SBasis> > pwd2, std::vector<std::pair<int,satelite> > satellites)
+        : _pwd2(pwd2), _satellites(satellites)
+        {
+        }
+        
+        virtual ~Pointwise();
+        
+        std::pair<int,satelite> findSatellites(int A) const;
+
+        double toTime(std::pair<int,satelite> A, double B);
+        double toSize(std::pair<int,satelite> A, double B);
+        double len_to_rad(int index, double len);
+        double rad_to_len(int index, double rad);
+        std::vector<double> get_times(int index, bool last);
+        std::pair<std::size_t, std::size_t> get_positions(int index)
+        int last_index(int index);
+        double time_to_len(int index, double time);
+        double len_to_time(int index, double len);
+        Pointwise recalculate_for_new_pwd2(Piecewise<D2<SBasis> > A);
+
+    private:
+        std::vector<std::pair<int,satelite> > _satellites;
+        Piecewise<D2<SBasis> > _pwd2;
+};
+
+#endif //SEEN_GEOM_PW_SB_H
+/*
+  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 :

=== added file 'src/2geom/satellite.h'
--- src/2geom/satellite.h	1970-01-01 00:00:00 +0000
+++ src/2geom/satellite.h	2014-10-22 21:40:37 +0000
@@ -0,0 +1,146 @@
+/**
+ * \file
+ * \brief Satellite
+ *//*
+ * Authors:
+ *
+ * Copyright 2014  authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#ifndef LIB2GEOM_SEEN_SATELLITE_H
+#define LIB2GEOM_SEEN_SATELLITE_H
+
+namespace Geom {
+
+class Satellite
+{
+  public:
+    Satellite()
+    {}
+
+    virtual ~Sattelite();
+
+    Satellite(typeSatellite ts, bool isTime, bool active, bool after, bool hidden, double size, double time)
+        : _ts(ts), _time(time), _active(active), _after(after), _hidden(hidden), _size(size), _time(time)
+    {
+    }
+
+    void setTypeSatellite(typeSatellite A)
+    {
+        _ts = A;
+    }
+
+    void setActive(bool A)
+    {
+        _active = A;
+    }
+
+    void setAfter(bool A)
+    {
+        _after = A;
+    }
+
+    void setHidden(bool A)
+    {
+        _hidden = A;
+    }
+
+    void setTime(double A)
+    {
+        _isTime = true;
+        _time = A;
+    }
+
+    void setSize(double A)
+    {
+        _isTime = false;
+        _size = A;
+    }
+
+    typeSatellite ts() const
+    {
+        return _ts;
+    }
+
+    bool isTime() const
+    {
+        return _isTime;
+    }
+
+    bool active() const
+    {
+        return _active;
+    }
+
+    bool after() const
+    {
+        return _after;
+    }
+
+    bool hidden() const
+    {
+        return _hidden;
+    }
+
+    double size() const
+    {
+        return _size;
+    }
+
+    double time() const
+    {
+        return _time;
+    }
+
+    bool isDegenerate() const
+    {
+        return _size = 0 && _time = 0;
+    }
+
+  private:
+    typeSatellite _ts;
+    bool _isTime;
+    bool _active;
+    bool _after;
+    bool _hidden;
+    double _size;
+    double _time;
+};
+
+} // end namespace Geom
+
+#endif // LIB2GEOM_SEEN_SATELLITE_H
+
+/*
+  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 :

=== modified file 'src/knotholder.h'
--- src/knotholder.h	2014-03-30 12:10:32 +0000
+++ src/knotholder.h	2014-10-22 21:40:37 +0000
@@ -28,6 +28,7 @@
 }
 namespace LivePathEffect {
 class PowerStrokePointArrayParamKnotHolderEntity;
+class FilletPointArrayParamKnotHolderEntity;
 }
 }
 
@@ -60,6 +61,7 @@
 
     friend class ShapeEditor;
     friend class Inkscape::LivePathEffect::PowerStrokePointArrayParamKnotHolderEntity;
+    friend class Inkscape::LivePathEffect::FilletPointArrayParamKnotHolderEntity;
 
 protected:
 

=== modified file 'src/live_effects/CMakeLists.txt'
--- src/live_effects/CMakeLists.txt	2012-03-23 21:02:03 +0000
+++ src/live_effects/CMakeLists.txt	2014-10-22 21:40:37 +0000
@@ -13,6 +13,7 @@
 	lpe-dynastroke.cpp
 	lpe-envelope.cpp
 	lpe-extrude.cpp
+	lpe-fillet-chamfer.cpp
 	lpe-gears.cpp
 	lpe-interpolate.cpp
 	lpe-knot.cpp
@@ -44,6 +45,7 @@
 
 	parameter/array.cpp
 	parameter/bool.cpp
+	parameter/powerstrokepointarray.cpp
 	parameter/parameter.cpp
 	parameter/path.cpp
 	parameter/originalpath.cpp
@@ -72,6 +74,7 @@
 	lpe-dynastroke.h
 	lpe-envelope.h
 	lpe-extrude.h
+	lpe-fillet-chamfer.h
 	lpe-gears.h
 	lpe-interpolate.h
 	lpe-knot.h
@@ -104,6 +107,7 @@
 
 	parameter/array.h
 	parameter/bool.h
+	parameter/powerstrokepointarray.h
 	parameter/enum.h
 	parameter/parameter.h
 	parameter/path-reference.h

=== modified file 'src/live_effects/Makefile_insert'
--- src/live_effects/Makefile_insert	2012-03-23 21:02:03 +0000
+++ src/live_effects/Makefile_insert	2014-10-22 21:40:37 +0000
@@ -32,6 +32,8 @@
 	live_effects/lpe-curvestitch.h	\
 	live_effects/lpe-constructgrid.cpp	\
 	live_effects/lpe-constructgrid.h	\
+	live_effects/lpe-fillet-chamfer.cpp	\
+	live_effects/lpe-fillet-chamfer.h	\
 	live_effects/lpe-gears.cpp	\
 	live_effects/lpe-gears.h	\
 	live_effects/lpe-interpolate.cpp	\

=== modified file 'src/live_effects/effect-enum.h'
--- src/live_effects/effect-enum.h	2012-01-12 21:06:16 +0000
+++ src/live_effects/effect-enum.h	2014-10-22 21:40:37 +0000
@@ -50,6 +50,7 @@
     EXTRUDE,
     POWERSTROKE,
     CLONE_ORIGINAL,
+    FILLET_CHAMFER,
     INVALID_LPE // This must be last (I made it such that it is not needed anymore I think..., Don't trust on it being last. - johan)
 };
 

=== modified file 'src/live_effects/effect.cpp'
--- src/live_effects/effect.cpp	2014-05-05 08:40:12 +0000
+++ src/live_effects/effect.cpp	2014-10-22 21:40:37 +0000
@@ -25,6 +25,7 @@
 #include "live_effects/lpe-perspective_path.h"
 #include "live_effects/lpe-spiro.h"
 #include "live_effects/lpe-lattice.h"
+#include "live_effects/lpe-fillet-chamfer.h"
 #include "live_effects/lpe-envelope.h"
 #include "live_effects/lpe-constructgrid.h"
 #include "live_effects/lpe-perp_bisector.h"
@@ -120,6 +121,7 @@
 /* 0.49 */
     {POWERSTROKE,           N_("Power stroke"), "powerstroke"},
     {CLONE_ORIGINAL,        N_("Clone original path"), "clone_original"},
+    {FILLET_CHAMFER,        N_("Fillet/Chamfer"), "fillet-chamfer"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 
@@ -243,6 +245,9 @@
         case CLONE_ORIGINAL:
             neweffect = static_cast<Effect*> ( new LPECloneOriginal(lpeobj) );
             break;
+        case FILLET_CHAMFER:
+            neweffect = static_cast<Effect*> ( new LPEFilletChamfer(lpeobj) );
+            break;
         default:
             g_warning("LivePathEffect::Effect::New   called with invalid patheffect type (%d)", lpenr);
             neweffect = NULL;
@@ -494,11 +499,6 @@
 {
     std::vector<Geom::PathVector> hp_vec;
 
-    if (!SP_IS_SHAPE(lpeitem)) {
-//        g_print ("How to handle helperpaths for non-shapes?\n"); // non-shapes are for example SPGroups.
-        return hp_vec;
-    }
-
     // add indicators provided by the effect itself
     addCanvasIndicators(lpeitem, hp_vec);
 

=== added file 'src/live_effects/lpe-fillet-chamfer.cpp'
--- src/live_effects/lpe-fillet-chamfer.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-fillet-chamfer.cpp	2014-10-22 21:40:37 +0000
@@ -0,0 +1,649 @@
+/*
+ * Author(s):
+ *   Jabiertxo Arraiza Cenoz <[e-mail]>
+ *
+ * Copyright (C) 2014 Author(s)
+ *
+ * Special thanks to Johan Engelen for the base of the effect -powerstroke-
+ * Also to ScislaC for point me to the idea
+ * Also su_v for his construvtive feedback and time
+ * Also to Mc- (IRC nick) for his important contribution to find real time
+ * values based on
+ * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#include "live_effects/lpe-fillet-chamfer.h"
+ 
+#include <2geom/sbasis-to-bezier.h>
+#include <2geom/svg-elliptical-arc.h>
+#include <2geom/line.h>
+
+#include "desktop.h"
+#include "display/curve.h"
+#include "helper/geom-nodetype.h"
+#include "helper/geom-curves.h"
+#include "helper/geom.h"
+
+#include "live_effects/parameter/filletchamferpointarray.h"
+
+// for programmatically updating knots
+#include "selection.h"
+#include "tools-switch.h"
+#include "ui/tool/control-point-selection.h"
+#include "ui/tool/selectable-control-point.h"
+#include "ui/tool/node.h"
+#include "ui/tools/node-tool.h"
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
+using namespace Geom;
+namespace Inkscape {
+namespace LivePathEffect {
+
+static const Util::EnumData<FilletMethod> FilletMethodData[FM_END] = {
+    { FM_AUTO, N_("Auto"), "auto" },
+    { FM_ARC, N_("Force arc"), "arc" },
+    { FM_BEZIER, N_("Force bezier"), "bezier" }
+};
+static const Util::EnumDataConverter<FilletMethod>
+FMConverter(FilletMethodData, FM_END);
+
+const double tolerance = 0.001;
+const double gapHelper = 0.00001;
+
+LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    fillet_chamfer_values(_("Fillet point"), _("Fillet point"), "fillet_chamfer_values", &wr, this),
+    hide_knots(_("Hide knots"), _("Hide knots"), "hide_knots", &wr, this, false),
+    ignore_radius_0(_("Ignore 0 radius knots"), _("Ignore 0 radius knots"), "ignore_radius_0", &wr, this, false),
+    only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false),
+    flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"), "flexible", &wr, this, false),
+    use_knot_distance(_("Use knots distance instead radius"), _("Use knots distance instead radius"), "use_knot_distance", &wr, this, false),
+    unit(_("Unit"), _("Unit"), "unit", &wr, this),
+    method(_("Method"), _("Fillets methods"), "method", FMConverter, &wr, this, FM_AUTO),
+    radius(_("Radius (unit or %)"), _("Radius, in unit or %"), "radius", &wr, this, 0.),
+    helper_size(_("Helper size with direction"), _("Helper size with direction"), "helper_size", &wr, this, 0)
+{
+    registerParameter(&fillet_chamfer_values);
+    registerParameter(&unit);
+    registerParameter(&method);
+    registerParameter(&radius);
+    registerParameter(&helper_size);
+    registerParameter(&flexible);
+    registerParameter(&use_knot_distance);
+    registerParameter(&ignore_radius_0);
+    registerParameter(&only_selected);
+    registerParameter(&hide_knots);
+
+    radius.param_set_range(0., infinity());
+    radius.param_set_increments(1, 1);
+    radius.param_set_digits(4);
+    helper_size.param_set_range(0, infinity());
+    helper_size.param_set_increments(5, 5);
+    helper_size.param_set_digits(0);
+}
+
+LPEFilletChamfer::~LPEFilletChamfer() {}
+
+Gtk::Widget *LPEFilletChamfer::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);
+    vbox->set_homogeneous(false);
+    vbox->set_spacing(2);
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            Parameter *param = *it;
+            Gtk::Widget *widg = param->param_newWidget();
+            if (param->param_key == "radius") {
+                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::updateFillet));
+                widg = widgRegistered;
+                if (widg) {
+                    Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
+                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
+                    Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
+                    entryWidg->set_width_chars(6);
+                }
+            } else if (param->param_key == "flexible") {
+                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
+                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleFlexFixed));
+            } else if (param->param_key == "helper_size") {
+                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::refreshKnots));
+            } else if (param->param_key == "hide_knots") {
+                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
+                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleHide));
+            } else if (param->param_key == "only_selected") {
+                Gtk::manage(widg);
+            } else if (param->param_key == "ignore_radius_0") {
+                Gtk::manage(widg);
+            }
+
+            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::HBox *filletButtonsContainer = Gtk::manage(new Gtk::HBox(true, 0));
+    Gtk::Button *fillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
+    fillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::fillet));
+
+    filletButtonsContainer->pack_start(*fillet, true, true, 2);
+    Gtk::Button *inverse = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
+    inverse->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverse));
+    filletButtonsContainer->pack_start(*inverse, true, true, 2);
+
+    Gtk::HBox *chamferButtonsContainer = Gtk::manage(new Gtk::HBox(true, 0));
+    Gtk::Button *chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Chamfer"))));
+    chamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamfer));
+
+    chamferButtonsContainer->pack_start(*chamfer, true, true, 2);
+    Gtk::Button *doubleChamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Double chamfer"))));
+    doubleChamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::doubleChamfer));
+    chamferButtonsContainer->pack_start(*doubleChamfer, true, true, 2);
+
+    vbox->pack_start(*filletButtonsContainer, true, true, 2);
+    vbox->pack_start(*chamferButtonsContainer, true, true, 2);
+
+    return vbox;
+}
+
+void LPEFilletChamfer::toggleHide()
+{
+    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
+    std::vector<Geom::Point> result;
+    for (std::vector<Point>::const_iterator point_it = filletChamferData.begin();
+            point_it != filletChamferData.end(); ++point_it) {
+        if (hide_knots) {
+            result.push_back(Point((*point_it)[X], abs((*point_it)[Y]) * -1));
+        } else {
+            result.push_back(Point((*point_it)[X], abs((*point_it)[Y])));
+        }
+    }
+    fillet_chamfer_values.param_set_and_write_new_value(result);
+    refreshKnots();
+}
+
+void LPEFilletChamfer::toggleFlexFixed()
+{
+    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
+    std::vector<Geom::Point> result;
+    unsigned int i = 0;
+    for (std::vector<Point>::const_iterator point_it = filletChamferData.begin();
+            point_it != filletChamferData.end(); ++point_it) {
+        if (flexible) {
+            result.push_back(Point(fillet_chamfer_values.to_time(i, (*point_it)[X]),
+                                   (*point_it)[Y]));
+        } else {
+            result.push_back(Point(fillet_chamfer_values.to_len(i, (*point_it)[X]),
+                                   (*point_it)[Y]));
+        }
+        i++;
+    }
+    if (flexible) {
+        radius.param_set_range(0., 100);
+        radius.param_set_value(0);
+    } else {
+        radius.param_set_range(0., infinity());
+        radius.param_set_value(0);
+    }
+    fillet_chamfer_values.param_set_and_write_new_value(result);
+}
+
+void LPEFilletChamfer::updateFillet()
+{
+    double power = 0;
+    if (!flexible) {
+        power = Inkscape::Util::Quantity::convert(radius, unit.get_abbreviation(), "px") * -1;
+    } else {
+        power = radius;
+    }
+    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
+    doUpdateFillet(path_from_piecewise(pwd2, tolerance), power);
+}
+
+void LPEFilletChamfer::fillet()
+{
+    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
+    doChangeType(path_from_piecewise(pwd2, tolerance), 1);
+}
+
+void LPEFilletChamfer::inverse()
+{
+    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
+    doChangeType(path_from_piecewise(pwd2, tolerance), 2);
+}
+
+void LPEFilletChamfer::chamfer()
+{
+    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
+    doChangeType(path_from_piecewise(pwd2, tolerance), 3);
+}
+
+void LPEFilletChamfer::doubleChamfer()
+{
+    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
+    doChangeType(path_from_piecewise(pwd2, tolerance), 4);
+}
+
+void LPEFilletChamfer::refreshKnots()
+{
+    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
+    fillet_chamfer_values.recalculate_knots(pwd2);
+    SPDesktop *desktop = inkscape_active_desktop();
+    if (tools_isactive(desktop, TOOLS_NODES)) {
+        tools_switch(desktop, TOOLS_SELECT);
+        tools_switch(desktop, TOOLS_NODES);
+    }
+}
+
+bool LPEFilletChamfer::nodeIsSelected(Geom::Point nodePoint, std::vector<Geom::Point> point)
+{
+    if (point.size() > 0) {
+        for (std::vector<Geom::Point>::iterator i = point.begin(); i != point.end();
+                ++i) {
+            Geom::Point p = *i;
+            if (Geom::are_near(p, nodePoint, 2)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+void LPEFilletChamfer::doUpdateFillet(std::vector<Geom::Path> const& original_pathv, double power)
+{
+    std::vector<Geom::Point> point;
+    SPDesktop *desktop = inkscape_active_desktop();
+    if (INK_IS_NODE_TOOL(desktop->event_context)) {
+        Inkscape::UI::Tools::NodeTool *nodeTool = INK_NODE_TOOL(desktop->event_context);
+        Inkscape::UI::ControlPointSelection::Set &selection = nodeTool->_selected_nodes->allPoints();
+        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 = dynamic_cast<Inkscape::UI::Node *>(*i);
+                pBegin = point.begin();
+                point.insert(pBegin, desktop->doc2dt(n->position()));
+            }
+        }
+    }
+    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
+    std::vector<Geom::Point> result;
+    std::vector<Geom::Path> original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
+    int counter = 0;
+    for (PathVector::const_iterator path_it = original_pathv_processed.begin();
+            path_it != original_pathv_processed.end(); ++path_it) {
+        if (path_it->empty())
+            continue;
+
+        Geom::Path::const_iterator curve_it1 = path_it->begin();
+        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
+        Geom::Path::const_iterator curve_endit = path_it->end_default();
+        if (path_it->closed() && path_it->back_closed().isDegenerate()) {
+            const Curve &closingline = path_it->back_closed();
+            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                curve_endit = path_it->end_open();
+            }
+        }
+        double powerend = 0;
+        while (curve_it1 != curve_endit) {
+            powerend = power;
+            if (power < 0 && !use_knot_distance) {
+                powerend = fillet_chamfer_values.rad_to_len(counter,powerend);
+            }
+            if (power > 0) {
+                powerend = counter + (power / 100);
+            }
+            if (ignore_radius_0 && (filletChamferData[counter][X] == 0 ||
+                                    filletChamferData[counter][X] == counter)) {
+                powerend = filletChamferData[counter][X];
+            }
+            if (filletChamferData[counter][Y] == 0) {
+                powerend = filletChamferData[counter][X];
+            }
+            if (only_selected && !nodeIsSelected(curve_it1->initialPoint(), point)) {
+                powerend = filletChamferData[counter][X];
+            }
+            result.push_back(Point(powerend, filletChamferData[counter][Y]));
+            ++curve_it1;
+            ++curve_it2;
+            counter++;
+        }
+    }
+    fillet_chamfer_values.param_set_and_write_new_value(result);
+}
+
+void LPEFilletChamfer::doChangeType(std::vector<Geom::Path> const& original_pathv, int type)
+{
+    std::vector<Geom::Point> point;
+    SPDesktop *desktop = inkscape_active_desktop();
+    if (INK_IS_NODE_TOOL(desktop->event_context)) {
+        Inkscape::UI::Tools::NodeTool *nodeTool =
+            INK_NODE_TOOL(desktop->event_context);
+        Inkscape::UI::ControlPointSelection::Set &selection =
+            nodeTool->_selected_nodes->allPoints();
+        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 = dynamic_cast<Inkscape::UI::Node *>(*i);
+                pBegin = point.begin();
+                point.insert(pBegin, desktop->doc2dt(n->position()));
+            }
+        }
+    }
+    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
+    std::vector<Geom::Point> result;
+    std::vector<Geom::Path> original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
+    int counter = 0;
+    for (PathVector::const_iterator path_it = original_pathv_processed.begin(); path_it != original_pathv_processed.end(); ++path_it) {
+        int pathCounter = 0;
+        if (path_it->empty())
+            continue;
+
+        Geom::Path::const_iterator curve_it1 = path_it->begin();
+        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
+        Geom::Path::const_iterator curve_endit = path_it->end_default();
+        if (path_it->closed() && path_it->back_closed().isDegenerate()) {
+            const Curve &closingline = path_it->back_closed();
+            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                curve_endit = path_it->end_open();
+            }
+        }
+        while (curve_it1 != curve_endit) {
+            bool toggle = true;
+            if (filletChamferData[counter][Y] == 0 ||
+                    (ignore_radius_0 && (filletChamferData[counter][X] == 0 ||
+                                         filletChamferData[counter][X] == counter)) ||
+                    (only_selected &&
+                     !nodeIsSelected(curve_it1->initialPoint(), point))) {
+                toggle = false;
+            }
+            if (toggle) {
+                result.push_back(Point(filletChamferData[counter][X], type));
+            } else {
+                result.push_back(filletChamferData[counter]);
+            }
+            ++curve_it1;
+            if (curve_it2 != curve_endit) {
+                ++curve_it2;
+            }
+            counter++;
+            pathCounter++;
+        }
+    }
+    fillet_chamfer_values.param_set_and_write_new_value(result);
+}
+
+void LPEFilletChamfer::doOnApply(SPLPEItem const *lpeItem)
+{
+    if (SP_IS_SHAPE(lpeItem)) {
+        std::vector<Point> point;
+        PathVector const &original_pathv = pathv_to_linear_and_cubic_beziers(SP_SHAPE(lpeItem)->_curve->get_pathvector());
+        Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(original_pathv);
+        for (PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
+            if (path_it->empty())
+                continue;
+
+            Geom::Path::const_iterator curve_it1 = path_it->begin();
+            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
+            Geom::Path::const_iterator curve_endit = path_it->end_default();
+            if (path_it->closed()) {
+              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();
+              }
+            }
+            int counter = 0;
+            while (curve_it1 != curve_endit) {
+                std::pair<std::size_t, std::size_t> positions = fillet_chamfer_values.get_positions(counter, original_pathv);
+                Geom::NodeType nodetype;
+                if (positions.second == 0) {
+                    if (path_it->closed()) {
+                        Piecewise<D2<SBasis> > u;
+                        u.push_cut(0);          
+                        u.push(pwd2_in[fillet_chamfer_values.last_index(counter, original_pathv)], 1);
+                        Geom::Curve const * A = path_from_piecewise(u, 0.1)[0][0].duplicate();
+                        nodetype = get_nodetype(*A, *curve_it1);
+                    } else {
+                        nodetype = NODE_NONE;
+                    }
+                } else {
+                    nodetype = get_nodetype((*path_it)[counter - 1], *curve_it1);
+                }
+                if (nodetype == NODE_CUSP) {
+                    point.push_back(Point(0, 1));
+                } else {
+                    point.push_back(Point(0, 0));
+                }
+                ++curve_it1;
+                if (curve_it2 != curve_endit) {
+                    ++curve_it2;
+                }
+                counter++;
+            }
+        }
+        fillet_chamfer_values.param_set_and_write_new_value(point);
+    } else {
+        g_warning("LPE Fillet can only be applied to shapes (not groups).");
+    }
+}
+
+void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
+{
+    if (SP_IS_SHAPE(lpeItem)) {
+        if(hide_knots){
+            fillet_chamfer_values.set_helper_size(0);
+        } else {
+            fillet_chamfer_values.set_helper_size(helper_size);
+        }
+        fillet_chamfer_values.set_use_distance(use_knot_distance);
+        fillet_chamfer_values.set_unit(unit.get_abbreviation());
+        SPCurve *c = SP_IS_PATH(lpeItem) ? static_cast<SPPath const *>(lpeItem)
+                     ->get_original_curve()
+                     : SP_SHAPE(lpeItem)->getCurve();
+        std::vector<Point> filletChamferData = fillet_chamfer_values.data();
+        if (!filletChamferData.empty() && getKnotsNumber(c) != (int)
+                filletChamferData.size()) {
+            PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(c->get_pathvector());
+            Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(original_pathv);
+            fillet_chamfer_values.recalculate_controlpoints_for_new_pwd2(pwd2_in);
+        }
+    } else {
+        g_warning("LPE Fillet can only be applied to shapes (not groups).");
+    }
+}
+
+int LPEFilletChamfer::getKnotsNumber(SPCurve const *c)
+{
+    int nKnots = c->nodes_in_path();
+    PathVector const pv =    pathv_to_linear_and_cubic_beziers(c->get_pathvector());
+    for (std::vector<Geom::Path>::const_iterator path_it = pv.begin();
+            path_it != pv.end(); ++path_it) {
+        if (!(*path_it).closed()) {
+            nKnots--;
+        }
+    }
+    return nKnots;
+}
+
+void
+LPEFilletChamfer::adjustForNewPath(std::vector<Geom::Path> const &path_in)
+{
+    if (!path_in.empty()) {
+        fillet_chamfer_values.recalculate_controlpoints_for_new_pwd2(pathv_to_linear_and_cubic_beziers(path_in)[0].toPwSb());
+    }
+}
+
+std::vector<Geom::Path>
+LPEFilletChamfer::doEffect_path(std::vector<Geom::Path> const &path_in)
+{
+    std::vector<Geom::Path> pathvector_out;
+    Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(pathv_to_linear_and_cubic_beziers(path_in));
+    pwd2_in = remove_short_cuts(pwd2_in, .01);
+    Piecewise<D2<SBasis> > der = derivative(pwd2_in);
+    Piecewise<D2<SBasis> > n = rot90(unitVector(der));
+    fillet_chamfer_values.set_pwd2(pwd2_in, n);
+    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
+    unsigned int counter = 0;
+    const double K = (4.0 / 3.0) * (sqrt(2.0) - 1.0);
+    std::vector<Geom::Path> path_in_processed = pathv_to_linear_and_cubic_beziers(path_in);
+    for (PathVector::const_iterator path_it = path_in_processed.begin();
+            path_it != path_in_processed.end(); ++path_it) {
+        if (path_it->empty())
+            continue;
+        Geom::Path path_out;
+        Geom::Path::const_iterator curve_it1 = path_it->begin();
+        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
+        Geom::Path::const_iterator curve_endit = path_it->end_default();
+        if (path_it->closed()) {
+          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();
+          }
+        }
+        unsigned int counterCurves = 0;
+        while (curve_it1 != curve_endit) {
+            Curve *curve_it2Fixed = (*path_it->begin()).duplicate();
+            if(!path_it->closed() || curve_it2 != curve_endit){
+                curve_it2Fixed = (*curve_it2).duplicate();
+            }
+            bool last = curve_it2 == curve_endit;
+            std::vector<double> times = fillet_chamfer_values.get_times(counter, path_in, last);
+            Curve *knotCurve1 = curve_it1->portion(times[0], times[1]);
+            if (counterCurves > 0) {
+                knotCurve1->setInitial(path_out.finalPoint());
+            } else {
+                path_out.start((*curve_it1).pointAt(times[0]));
+            }
+            Curve *knotCurve2 = curve_it2Fixed->portion(times[2], 1);
+            Point startArcPoint = knotCurve1->finalPoint();
+            Point endArcPoint = curve_it2Fixed->pointAt(times[2]);
+            double k1 = distance(startArcPoint, curve_it1->finalPoint()) * K;
+            double k2 = distance(endArcPoint, curve_it1->finalPoint()) * K;
+            Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(&*knotCurve1);
+            Ray ray1(startArcPoint, curve_it1->finalPoint());
+            if (cubic1) {
+                ray1.setPoints((*cubic1)[2], startArcPoint);
+            }
+            Point handle1 =  Point::polar(ray1.angle(),k1) + startArcPoint;
+            Geom::CubicBezier const *cubic2 =
+                dynamic_cast<Geom::CubicBezier const *>(&*knotCurve2);
+            Ray ray2(curve_it1->finalPoint(), endArcPoint);
+            if (cubic2) {
+                ray2.setPoints(endArcPoint, (*cubic2)[1]);
+            }
+            Point handle2 = endArcPoint - Point::polar(ray2.angle(),k2);
+            bool ccwToggle = cross(curve_it1->finalPoint() - startArcPoint, endArcPoint - startArcPoint) < 0;
+            double angle = angle_between(ray1, ray2, ccwToggle);
+            double handleAngle = ray1.angle() - angle;
+            if (ccwToggle) {
+                handleAngle = ray1.angle() + angle;
+            }
+            Point inverseHandle1 = Point::polar(handleAngle,k1) + startArcPoint;
+            handleAngle = ray2.angle() + angle;
+            if (ccwToggle) {
+                handleAngle = ray2.angle() - angle;
+            }
+            Point inverseHandle2 = endArcPoint - Point::polar(handleAngle,k2);
+            //straigth lines arc based
+            Line const x_line(Geom::Point(0,0),Geom::Point(1,0));
+            Line const angled_line(startArcPoint,endArcPoint);
+            double angleArc = Geom::angle_between( x_line,angled_line);
+            double radius = Geom::distance(startArcPoint,middle_point(startArcPoint,endArcPoint))/sin(angle/2.0);
+            Coord rx = radius;
+            Coord ry = rx;
+            
+            if (times[1] != 1) {
+                if (times[1] != gapHelper && times[1] != times[0] + gapHelper) {
+                    path_out.append(*knotCurve1);
+                }
+                int type = 0;
+                if(path_it->closed() && last){
+                    type = abs(filletChamferData[counter - counterCurves][Y]);
+                } else if (!path_it->closed() && last){
+                    //0
+                } else {
+                    type = abs(filletChamferData[counter + 1][Y]);
+                }
+                if (type == 3 || type == 4) {
+                    if (type == 4) {
+                        Geom::Point central = middle_point(startArcPoint, endArcPoint);
+                        LineSegment chamferCenter(central, curve_it1->finalPoint());
+                        path_out.appendNew<Geom::LineSegment>(chamferCenter.pointAt(0.5));
+                    }
+                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
+                } else if (type == 2) {
+                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
+                        ccwToggle = ccwToggle?0:1;
+                        path_out.appendNew<SVGEllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
+                    }else{
+                        path_out.appendNew<Geom::CubicBezier>(inverseHandle1, inverseHandle2, endArcPoint);
+                    }
+                } else {
+                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
+                        path_out.appendNew<SVGEllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
+                    } else {
+                        path_out.appendNew<Geom::CubicBezier>(handle1, handle2, endArcPoint);
+                    }
+                }
+            } else {
+                path_out.append(*knotCurve1);
+            }
+            if (path_it->closed() && last) {
+                path_out.close();
+            }
+            ++curve_it1;
+            if (curve_it2 != curve_endit) {
+                ++curve_it2;
+            }
+            counter++;
+            counterCurves++;
+        }
+        pathvector_out.push_back(path_out);
+    }
+    return pathvector_out;
+}
+
+}; //namespace LivePathEffect
+}; /* namespace Inkscape */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offset:((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 :

=== added file 'src/live_effects/lpe-fillet-chamfer.h'
--- src/live_effects/lpe-fillet-chamfer.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-fillet-chamfer.h	2014-10-22 21:40:37 +0000
@@ -0,0 +1,101 @@
+#ifndef INKSCAPE_LPE_FILLET_CHAMFER_H
+#define INKSCAPE_LPE_FILLET_CHAMFER_H
+
+/*
+ * Author(s):
+ *     Jabiertxo Arraiza Cenoz <[e-mail]>
+ *
+ * Copyright (C) 2014 Author(s)
+ *
+ * Special thanks to Johan Engelen for the base of the effect -powerstroke-
+ * Also to ScislaC for point me to the idea
+ * Also su_v for his construvtive feedback and time
+ * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#if defined(GLIBMM_DISABLE_DEPRECATED) && defined(HAVE_GLIBMM_THREADS_H)
+# include <glibmm/threads.h>
+#endif
+
+#include "live_effects/parameter/enum.h"
+#include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/unit.h"
+
+#include "live_effects/parameter/filletchamferpointarray.h"
+#include "live_effects/effect.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+enum FilletMethod {
+    FM_AUTO,
+    FM_ARC,
+    FM_BEZIER,
+    FM_END
+};
+
+class LPEFilletChamfer : public Effect {
+public:
+    LPEFilletChamfer(LivePathEffectObject *lpeobject);
+    virtual ~LPEFilletChamfer();
+
+    virtual std::vector<Geom::Path> doEffect_path(std::vector<Geom::Path> const &path_in);
+
+    virtual void doOnApply(SPLPEItem const *lpeItem);
+    virtual void doBeforeEffect(SPLPEItem const *lpeItem);
+    virtual void adjustForNewPath(std::vector<Geom::Path> const &path_in);
+    virtual Gtk::Widget* newWidget();
+
+    int getKnotsNumber(SPCurve const *c);
+    void toggleHide();
+    void toggleFlexFixed();
+    void chamfer();
+    void fillet();
+    void doubleChamfer();
+    void inverse();
+    void updateFillet();
+    void doUpdateFillet(std::vector<Geom::Path> const& original_pathv, double power);
+    void doChangeType(std::vector<Geom::Path> const& original_pathv, int type);
+    bool nodeIsSelected(Geom::Point nodePoint, std::vector<Geom::Point> points);
+    void refreshKnots();
+
+    FilletChamferPointArrayParam fillet_chamfer_values;
+
+private:
+
+    BoolParam hide_knots;
+    BoolParam ignore_radius_0;
+    BoolParam only_selected;
+    BoolParam flexible;
+    BoolParam use_knot_distance;
+    UnitParam unit;
+    EnumParam<FilletMethod> method;
+    ScalarParam radius;
+    ScalarParam helper_size;
+
+    LPEFilletChamfer(const LPEFilletChamfer &);
+    LPEFilletChamfer &operator=(const LPEFilletChamfer &);
+
+};
+
+} //namespace LivePathEffect
+} //namespace Inkscape
+
+#endif
+
+/*
+  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 :

=== modified file 'src/live_effects/parameter/Makefile_insert'
--- src/live_effects/parameter/Makefile_insert	2012-01-12 21:06:16 +0000
+++ src/live_effects/parameter/Makefile_insert	2014-10-22 21:40:37 +0000
@@ -20,6 +20,8 @@
 	live_effects/parameter/originalpath.h	\
 	live_effects/parameter/powerstrokepointarray.cpp	\
 	live_effects/parameter/powerstrokepointarray.h	\
+	live_effects/parameter/filletchamferpointarray.cpp	\
+	live_effects/parameter/filletchamferpointarray.h	\
 	live_effects/parameter/text.cpp	\
 	live_effects/parameter/text.h	\
 	live_effects/parameter/unit.cpp	\

=== added file 'src/live_effects/parameter/filletchamferpointarray.cpp'
--- src/live_effects/parameter/filletchamferpointarray.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/filletchamferpointarray.cpp	2014-10-22 21:40:37 +0000
@@ -0,0 +1,882 @@
+/*
+ * Copyright (C) Jabiertxo Arraiza Cenoz <[e-mail]>
+ * Special thanks to Johan Engelen for the base of the effect -powerstroke-
+ * Also to ScislaC for point me to the idea
+ * Also su_v for his construvtive feedback and time
+ * and finaly to Liam P. White for his big help on coding, that save me a lot of
+ * hours
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <2geom/piecewise.h>
+#include <2geom/sbasis-to-bezier.h>
+#include <2geom/sbasis-geometric.h>
+#include <2geom/svg-elliptical-arc.h>
+#include <2geom/line.h>
+#include <2geom/path-intersection.h>
+
+#include "ui/dialog/lpe-fillet-chamfer-properties.h"
+#include "live_effects/parameter/filletchamferpointarray.h"
+#include "live_effects/effect.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "knotholder.h"
+#include "sp-lpe-item.h"
+#include "selection.h"
+
+// needed for on-canvas editting:
+#include "desktop.h"
+#include "live_effects/lpeobject.h"
+#include "helper/geom-nodetype.h"
+#include "helper/geom-curves.h"
+#include "ui/tools/node-tool.h"
+
+// TODO due to internal breakage in glibmm headers,
+// this has to be included last.
+#include <glibmm/i18n.h>
+
+
+using namespace Geom;
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+FilletChamferPointArrayParam::FilletChamferPointArrayParam(
+    const Glib::ustring &label, const Glib::ustring &tip,
+    const Glib::ustring &key, Inkscape::UI::Widget::Registry *wr,
+    Effect *effect)
+    : ArrayParam<Point>(label, tip, key, wr, effect, 0)
+{
+    knot_shape = SP_KNOT_SHAPE_DIAMOND;
+    knot_mode = SP_KNOT_MODE_XOR;
+    knot_color = 0x00ff0000;
+}
+
+FilletChamferPointArrayParam::~FilletChamferPointArrayParam() {}
+
+Gtk::Widget *FilletChamferPointArrayParam::param_newWidget()
+{
+    return NULL;
+    /*
+          Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg =
+        Gtk::manage(
+              new Inkscape::UI::Widget::RegisteredTransformedPoint(
+        param_label,
+                                                                    param_tooltip,
+                                                                    param_key,
+                                                                    *param_wr,
+                                                                    param_effect->getRepr(),
+                                                                    param_effect->getSPDoc()
+        ) );
+          // TODO: fix to get correct desktop (don't use SP_ACTIVE_DESKTOP)
+          SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+          Affine transf = desktop->doc2dt();
+          pointwdg->setTransform(transf);
+          pointwdg->setValue( *this );
+          pointwdg->clearProgrammatically();
+          pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT,
+        _("Change point parameter"));
+
+          Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
+          static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
+          static_cast<Gtk::HBox*>(hbox)->show_all_children();
+
+          return dynamic_cast<Gtk::Widget *> (hbox);
+      */
+}
+
+void
+FilletChamferPointArrayParam::param_transform_multiply(Affine const &postmul,
+        bool /*set*/)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    if (prefs->getBool("/options/transform/rectcorners", true) &&
+            _vector[1][X] <= 0) {
+        std::vector<Geom::Point> result;
+        for (std::vector<Point>::const_iterator point_it = _vector.begin();
+                point_it != _vector.end(); ++point_it) {
+            Coord A =
+                (*point_it)[X] * ((postmul.expansionX() + postmul.expansionY()) / 2);
+            result.push_back(Point(A, (*point_it)[Y]));
+        }
+        param_set_and_write_new_value(result);
+    }
+
+    //    param_set_and_write_new_value( (*this) * postmul );
+}
+
+/** call this method to recalculate the controlpoints such that they stay at the
+ * same location relative to the new path. Useful after adding/deleting nodes to
+ * the path.*/
+void FilletChamferPointArrayParam::recalculate_controlpoints_for_new_pwd2(
+    Piecewise<D2<SBasis> > const &pwd2_in)
+{
+    if (!last_pwd2.empty()) {
+        PathVector const pathv =
+            path_from_piecewise(remove_short_cuts(pwd2_in, 0.1), 0.001);
+        PathVector last_pathv =
+            path_from_piecewise(remove_short_cuts(last_pwd2, 0.1), 0.001);
+        std::vector<Point> result;
+        unsigned long counter = 0;
+        unsigned long counterPaths = 0;
+        unsigned long counterCurves = 0;
+        long offset = 0;
+        long offsetPaths = 0;
+        Geom::NodeType nodetype;
+        for (PathVector::const_iterator path_it = pathv.begin();
+                path_it != pathv.end(); ++path_it) {
+            if (path_it->empty()) {
+                counterPaths++;
+                counter++;
+                continue;
+            }
+            Geom::Path::const_iterator curve_it1 = path_it->begin();
+            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
+            Geom::Path::const_iterator curve_endit = path_it->end_default();
+            if (path_it->closed() && path_it->back_closed().isDegenerate()) {
+                const Curve &closingline = path_it->back_closed();
+                if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                    curve_endit = path_it->end_open();
+                }
+            }
+            counterCurves = 0;
+            while (curve_it1 != curve_endit) {
+                //if start a path get node type
+                if (counterCurves == 0) {
+                    if (path_it->closed()) {
+                        if (path_it->back_closed().isDegenerate()) {
+                            nodetype = get_nodetype(path_it->back_open(), *curve_it1);
+                        } else {
+                            nodetype = get_nodetype(path_it->back_closed(), *curve_it1);
+                        }
+                    } else {
+                        nodetype = NODE_NONE;
+                    }
+                } else {
+                    //check node type also whith straight lines because get_nodetype
+                    //return non cusp node in a node inserted inside a straight line
+                    //todo: if the path remove some nodes whith the result of a straight
+                    //line but with handles, the node inserted into dont fire the knot
+                    // because is not handle as cusp node by  get_nodetype function
+                    bool this_is_line = true;
+                    bool next_is_line = is_straight_curve(*curve_it1);
+                    this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
+                    nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
+                    if (this_is_line || next_is_line) {
+                        nodetype = NODE_CUSP;
+                    }
+                }
+                if (last_pathv.size() > pathv.size() ||
+                        (last_pathv.size() > counterPaths && 
+                        last_pathv[counterPaths].size() > counter - offset &&
+                         !are_near(curve_it1->initialPoint(),
+                                   last_pathv[counterPaths][counter - offset].initialPoint(),
+                                   0.1))) {
+                    if ( curve_it2 == curve_endit) {
+                        if (last_pathv[counterPaths].size() < pathv[counterPaths].size()) {
+                            offset = abs(last_pathv[counterPaths].size() -
+                                         pathv[counterPaths].size());
+                        } else if (last_pathv[counterPaths].size() >
+                                   pathv[counterPaths].size()) {
+                            offset = (abs(last_pathv[counterPaths].size() -
+                                          pathv[counterPaths].size())) * -1;
+                        } else {
+                            offset = 0;
+                        }
+                        offsetPaths += offset;
+                        offset = offsetPaths;
+                    } else if (counterCurves == 0 && last_pathv.size() <= pathv.size() &&
+                            counter - offset <= last_pathv[counterPaths].size() &&
+                            are_near(curve_it1->initialPoint(),
+                                     last_pathv[counterPaths].finalPoint(), 0.1) &&
+                                     !last_pathv[counterPaths].closed()) {
+                        long e = counter - offset + 1;
+                        std::vector<Point> tmp = _vector;
+                        for (unsigned long i =
+                                     last_pathv[counterPaths].size() + counter - offset;
+                                i > counterCurves - offset + 1; i--) {
+
+                            if (tmp[i - 1][X] > 0) {
+                                double fractpart, intpart;
+                                fractpart = modf(tmp[i - 1][X], &intpart);
+                                _vector[e] = Point(e + fractpart, tmp[i - 1][Y]);
+                            } else {
+                                _vector[e] = Point(tmp[i - 1][X], tmp[i - 1][Y]);
+                            }
+                            e++;
+                        }
+                        //delete temp vector
+                        std::vector<Point>().swap(tmp);
+                        if (last_pathv.size() > counterPaths) {
+                            last_pathv[counterPaths] = last_pathv[counterPaths].reverse();
+                        }
+                    } else {
+                        if (last_pathv.size() > counterPaths) {
+                            if (last_pathv[counterPaths].size() <
+                                    pathv[counterPaths].size()) {
+                                offset++;
+                            } else if (last_pathv[counterPaths].size() >
+                                       pathv[counterPaths].size()) {
+                                offset--;
+                                continue;
+                            }
+                        } else {
+                            offset++;
+                        }
+                    }
+                    double xPos = 0;
+                    if (_vector[1][X] > 0) {
+                        xPos = nearest_point(curve_it1->initialPoint(), pwd2_in);
+                    }
+                    if (nodetype == NODE_CUSP) {
+                        result.push_back(Point(xPos, 1));
+                    } else {
+                        result.push_back(Point(xPos, 0));
+                    }
+                } else {
+                    double xPos = _vector[counter - offset][X];
+                    if (_vector.size() <= (unsigned)(counter - offset)) {
+                        if (_vector[1][X] > 0) {
+                            xPos = nearest_point(curve_it1->initialPoint(), pwd2_in);
+                        } else {
+                            xPos = 0;
+                        }
+                    }
+                    if (nodetype == NODE_CUSP) {
+                        double vectorY = _vector[counter - offset][Y];
+                        if (_vector.size() <= (unsigned)(counter - offset) || vectorY == 0) {
+                            vectorY = 1;
+                        }
+                        result.push_back(Point(xPos, vectorY));
+                    } else {
+                        if (_vector[1][X] < 0) {
+                            xPos = 0;
+                        }
+                        result.push_back(Point(floor(xPos), 0));
+                    }
+                }
+                ++curve_it1;
+                if (curve_it2 != curve_endit) {
+                    ++curve_it2;
+                }
+                counter++;
+                counterCurves++;
+            }
+            counterPaths++;
+        }
+        _vector = result;
+        write_to_SVG();
+    }
+}
+
+void FilletChamferPointArrayParam::recalculate_knots(
+    Piecewise<D2<SBasis> > const &pwd2_in)
+{
+    bool change = false;
+    PathVector pathv = path_from_piecewise(pwd2_in, 0.001);
+    if (!pathv.empty()) {
+        std::vector<Point> result;
+        int counter = 0;
+        int counterCurves = 0;
+        Geom::NodeType nodetype;
+        for (PathVector::const_iterator path_it = pathv.begin();
+                path_it != pathv.end(); ++path_it) {
+            if (path_it->empty()) {
+                counter++;
+                continue;
+            }
+            Geom::Path::const_iterator curve_it1 = path_it->begin();
+            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
+            Geom::Path::const_iterator curve_endit = path_it->end_default();
+            if (path_it->closed() && path_it->back_closed().isDegenerate()) {
+                const Curve &closingline = path_it->back_closed();
+                if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                    curve_endit = path_it->end_open();
+                }
+            }
+            counterCurves = 0;
+            while (curve_it1 != curve_endit) {
+                //if start a path get node type
+                if (counterCurves == 0) {
+                    if (path_it->closed()) {
+                        if (path_it->back_closed().isDegenerate()) {
+                            nodetype = get_nodetype(path_it->back_open(), *curve_it1);
+                        } else {
+                            nodetype = get_nodetype(path_it->back_closed(), *curve_it1);
+                        }
+                    } else {
+                        nodetype = NODE_NONE;
+                    }
+                } else {
+                    bool this_is_line = true;
+                    bool next_is_line = is_straight_curve(*curve_it1);
+                    this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
+                    nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
+                    if (this_is_line || next_is_line) {
+                        nodetype = NODE_CUSP;
+                    }
+                }
+                if (nodetype == NODE_CUSP) {
+                    double vectorY = _vector[counter][Y];
+                    if (vectorY == 0) {
+                        vectorY = 1;
+                        change = true;
+                    }
+                    result.push_back(Point(_vector[counter][X], vectorY));
+                } else {
+                    double xPos = floor(_vector[counter][X]);
+                    if (_vector[1][X] < 0) {
+                        xPos = 0;
+                    }
+                    double vectorY = _vector[counter][Y];
+                    if (vectorY != 0) {
+                        change = true;
+                    }
+                    result.push_back(Point(xPos, 0));
+                }
+                ++curve_it1;
+                counter++;
+                if (curve_it2 != curve_endit) {
+                    ++curve_it2;
+                }
+                counterCurves++;
+            }
+        }
+        if (change) {
+            _vector = result;
+            write_to_SVG();
+        }
+    }
+}
+
+void FilletChamferPointArrayParam::set_pwd2(
+    Piecewise<D2<SBasis> > const &pwd2_in,
+    Piecewise<D2<SBasis> > const &pwd2_normal_in)
+{
+    last_pwd2 = pwd2_in;
+    last_pwd2_normal = pwd2_normal_in;
+}
+
+void FilletChamferPointArrayParam::set_helper_size(int hs)
+{
+    helper_size = hs;
+}
+
+void FilletChamferPointArrayParam::set_use_distance(bool use_knot_distance )
+{
+    use_distance = use_knot_distance;
+}
+
+void FilletChamferPointArrayParam::set_unit(const gchar *abbr)
+{
+    unit = abbr;
+}
+
+void FilletChamferPointArrayParam::updateCanvasIndicators()
+{
+    std::vector<Point> ts = data();
+    hp.clear();
+    unsigned int i = 0;
+    for (std::vector<Point>::const_iterator point_it = ts.begin();
+            point_it != ts.end(); ++point_it) {
+        double Xvalue = to_time(i, (*point_it)[X]) -i;
+        if (Xvalue == 0) {
+            i++;
+            continue;
+        }
+        Geom::Point ptA = last_pwd2[i].valueAt(Xvalue);
+        Geom::Point derivA = unit_vector(derivative(last_pwd2[i]).valueAt(Xvalue));
+        Geom::Rotate rot(Geom::Rotate::from_degrees(-90));
+        derivA = derivA * rot;
+        Geom::Point C = ptA - derivA * helper_size;
+        Geom::Point D = ptA + derivA * helper_size;
+        Geom::Ray ray1(C, D);
+        char const * svgd = "M 1,0.25 0.5,0 1,-0.25 M 1,0.5 0,0 1,-0.5";
+        Geom::PathVector pathv = sp_svg_read_pathv(svgd);
+        Geom::Affine aff = Geom::Affine();
+        aff *= Geom::Scale(helper_size);
+        aff *= Geom::Rotate(ray1.angle() - deg_to_rad(270));
+        pathv *= aff;
+        pathv += last_pwd2[i].valueAt(Xvalue);
+        hp.push_back(pathv[0]);
+        hp.push_back(pathv[1]);
+        i++;
+    }
+}
+
+void FilletChamferPointArrayParam::addCanvasIndicators(
+    SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
+{
+    hp_vec.push_back(hp);
+}
+
+double FilletChamferPointArrayParam::rad_to_len(int index, double rad)
+{
+    double len = 0;
+    std::vector<Geom::Path> subpaths = path_from_piecewise(last_pwd2, 0.1);
+    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
+    D2<SBasis> A = last_pwd2[last_index(index, subpaths)];
+    if(positions.second != 0){
+        A = last_pwd2[index-1];
+    }else{
+        if(!subpaths[positions.first].closed()){
+            return len;
+        }
+    }
+    D2<SBasis> B = last_pwd2[index];
+    Piecewise<D2<SBasis> > offset_curve0 = Piecewise<D2<SBasis> >(A)+rot90(unitVector(derivative(A)))*(rad);
+    Piecewise<D2<SBasis> > offset_curve1 = Piecewise<D2<SBasis> >(B)+rot90(unitVector(derivative(B)))*(rad);
+    Geom::Path p0 = path_from_piecewise(offset_curve0, 0.1)[0];
+    Geom::Path p1 = path_from_piecewise(offset_curve1, 0.1)[0];
+    Geom::Crossings cs = Geom::crossings(p0, p1);
+    if(cs.size() > 0){
+        Point cp =p0(cs[0].ta);
+        double p0pt = nearest_point(cp, B);
+        len = time_to_len(index,p0pt);
+    } else {
+        if(rad < 0){
+            len = rad_to_len(index, rad * -1);
+        }
+    }
+    return len;
+}
+
+double FilletChamferPointArrayParam::len_to_rad(int index, double len)
+{
+    double rad = 0;
+    double tmp_len = _vector[index][X];
+    _vector[index] = Geom::Point(len,_vector[index][Y]);
+    std::vector<Geom::Path> subpaths = path_from_piecewise(last_pwd2, 0.1);
+    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
+    Piecewise<D2<SBasis> > u;
+    u.push_cut(0);          
+    u.push(last_pwd2[last_index(index, subpaths)], 1);
+    Geom::Curve * A = path_from_piecewise(u, 0.1)[0][0].duplicate();
+    Geom::Curve * B = subpaths[positions.first][positions.second].duplicate();
+    std::vector<double> times;
+    if(positions.second != 0){
+        A = subpaths[positions.first][positions.second-1].duplicate();
+        times = get_times(index-1, subpaths, false);
+    }else{
+        if(!subpaths[positions.first].closed()){
+            return rad;
+        }
+        times = get_times(last_index(index, subpaths), subpaths, true);
+    }
+    _vector[index] = Geom::Point(tmp_len,_vector[index][Y]);
+    Geom::Point startArcPoint = A->toSBasis().valueAt(times[1]);
+    Geom::Point endArcPoint = B->toSBasis().valueAt(times[2]);
+    Curve *knotCurve1 = A->portion(times[0], times[1]);
+    Curve *knotCurve2 = B->portion(times[2], 1);
+    Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(&*knotCurve1);
+    Ray ray1(startArcPoint, A->finalPoint());
+    if (cubic1) {
+        ray1.setPoints((*cubic1)[2], startArcPoint);
+    }
+    Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(&*knotCurve2);
+    Ray ray2(B->initialPoint(), endArcPoint);
+    if (cubic2) {
+        ray2.setPoints(endArcPoint, (*cubic2)[1]);
+    }
+    bool ccwToggle = cross(A->finalPoint() - startArcPoint, endArcPoint - startArcPoint) < 0;
+    double distanceArc = Geom::distance(startArcPoint,middle_point(startArcPoint,endArcPoint));
+    double angleBetween = angle_between(ray1, ray2, ccwToggle);
+    rad = distanceArc/sin(angleBetween/2.0);
+    return rad * -1;
+}
+
+std::vector<double> FilletChamferPointArrayParam::get_times(int index, std::vector<Geom::Path> subpaths, bool last)
+{
+    const double tolerance = 0.001;
+    const double gapHelper = 0.00001;
+    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
+    Curve *curve_it1;
+    curve_it1 = subpaths[positions.first][positions.second].duplicate();
+    Coord it1_length = (*curve_it1).length(tolerance);
+    double time_it1, time_it2, time_it1_B, intpart;
+    time_it1 = modf(to_time(index, _vector[index][X]), &intpart);
+    if (_vector[index][Y] == 0) {
+        time_it1 = 0;
+    }
+    double resultLenght = 0;
+    time_it1_B = 1;
+    if (subpaths[positions.first].closed() && last) {
+        time_it2 = modf(to_time(index - positions.second , _vector[index - positions.second ][X]), &intpart);
+        resultLenght = it1_length + to_len(index - positions.second, _vector[index - positions.second ][X]);
+    } else if (!subpaths[positions.first].closed() && last){
+        time_it2 = 0;
+        resultLenght = 0;
+    } else {
+        time_it2 = modf(to_time(index + 1, _vector[index + 1][X]), &intpart);
+        resultLenght = it1_length + to_len( index + 1, _vector[index + 1][X]);
+    }
+    if (resultLenght > 0 && time_it2 != 0) {
+        time_it1_B = modf(to_time(index, -resultLenght), &intpart);
+    } else {
+        if (time_it2 == 0) {
+            time_it1_B = 1;
+        } else {
+            time_it1_B = gapHelper;
+        }
+    }
+
+    if ((subpaths[positions.first].closed() && last && _vector[index - positions.second][Y] == 0) || (subpaths[positions.first].size() > positions.second + 1 && _vector[index + 1][Y] == 0)) {
+        time_it1_B = 1;
+        time_it2 = 0;
+    }
+    if (time_it1_B < time_it1) {
+        time_it1_B = time_it1 + gapHelper;
+    }
+    std::vector<double> out;
+    out.push_back(time_it1);
+    out.push_back(time_it1_B);
+    out.push_back(time_it2);
+    return out;
+}
+
+std::pair<std::size_t, std::size_t> FilletChamferPointArrayParam::get_positions(int index, std::vector<Geom::Path> subpaths)
+{
+    int counter = -1;
+    std::size_t first = 0;
+    std::size_t second = 0;
+    for (PathVector::const_iterator path_it = subpaths.begin(); path_it != subpaths.end(); ++path_it) {
+        if (path_it->empty())
+            continue;
+        Geom::Path::const_iterator curve_it1 = path_it->begin();
+        Geom::Path::const_iterator curve_endit = path_it->end_default();
+        if (path_it->closed()) {
+          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();
+          }
+        }
+        first++;
+        second = 0;
+        while (curve_it1 != curve_endit) {
+            counter++;
+            second++;
+            if(counter == index){
+                break;
+            }
+            ++curve_it1;
+        }
+        if(counter == index){
+            break;
+        }
+    }
+    first--;
+    second--;
+    std::pair<std::size_t, std::size_t> out(first, second);
+    return out;
+}
+
+int FilletChamferPointArrayParam::last_index(int index, std::vector<Geom::Path> subpaths)
+{
+    int counter = -1;
+    bool inSubpath = false;
+    for (PathVector::const_iterator path_it = subpaths.begin(); path_it != subpaths.end(); ++path_it) {
+        if (path_it->empty())
+            continue;
+        Geom::Path::const_iterator curve_it1 = path_it->begin();
+        Geom::Path::const_iterator curve_endit = path_it->end_default();
+        if (path_it->closed()) {
+          const Geom::Curve &closingline = path_it->back_closed(); 
+          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+            curve_endit = path_it->end_open();
+          }
+        }
+        while (curve_it1 != curve_endit) {
+            counter++;
+            if(counter == index){
+                inSubpath = true;
+            }
+            ++curve_it1;
+        }
+        if(inSubpath){
+            break;
+        }
+    }
+    if(!inSubpath){
+        counter = -1;
+    }
+    return counter;
+}
+
+
+double FilletChamferPointArrayParam::len_to_time(int index, double len)
+{
+    double t = 0;
+    if (last_pwd2.size() > (unsigned) index) {
+        if (len != 0) {
+            if (last_pwd2[index][0].degreesOfFreedom() != 2) {
+                Piecewise<D2<SBasis> > u;
+                u.push_cut(0);          
+                u.push(last_pwd2[index], 1);
+                std::vector<double> t_roots = roots(arcLengthSb(u) - std::abs(len));
+                if (t_roots.size() > 0) {
+                    t = t_roots[0];
+                }
+            } else {
+                double lenghtPart = 0;
+                if (last_pwd2.size() > (unsigned) index) {
+                    lenghtPart = length(last_pwd2[index], EPSILON);
+                }
+                if (std::abs(len) < lenghtPart && lenghtPart != 0) {
+                    t = std::abs(len) / lenghtPart;
+                }
+            }
+        }
+        t = double(index) + t;
+    } else {
+        t = double(last_pwd2.size() - 1);
+    }
+
+    return t;
+}
+
+double FilletChamferPointArrayParam::time_to_len(int index, double time)
+{
+    double intpart;
+    double len = 0;
+    time = modf(time, &intpart);
+    double lenghtPart = 0;
+    if (last_pwd2.size() <= (unsigned) index || time == 0) {
+        return len;
+    }
+    if (last_pwd2[index][0].degreesOfFreedom() != 2) {
+        Piecewise<D2<SBasis> > u;
+        u.push_cut(0);
+        u.push(last_pwd2[index], 1);
+        u = portion(u, 0, time);
+        return length(u, 0.001) * -1;
+    }
+    lenghtPart = length(last_pwd2[index], EPSILON);
+    return (time * lenghtPart) * -1;
+}
+
+double FilletChamferPointArrayParam::to_time(int index, double A)
+{
+    if (A > 0) {
+        return A;
+    } else {
+        return len_to_time(index, A);
+    }
+}
+
+double FilletChamferPointArrayParam::to_len(int index, double A)
+{
+    if (A > 0) {
+        return time_to_len(index, A);
+    } else {
+        return A;
+    }
+}
+
+void FilletChamferPointArrayParam::set_oncanvas_looks(SPKnotShapeType shape,
+        SPKnotModeType mode,
+        guint32 color)
+{
+    knot_shape = shape;
+    knot_mode = mode;
+    knot_color = color;
+}
+/*
+class FilletChamferPointArrayParamKnotHolderEntity : public KnotHolderEntity {
+public:
+    FilletChamferPointArrayParamKnotHolderEntity(FilletChamferPointArrayParam
+*p, unsigned int index);
+    virtual ~FilletChamferPointArrayParamKnotHolderEntity() {}
+
+    virtual void knot_set(Point const &p, Point const &origin, guint state);
+    virtual Point knot_get() const;
+    virtual void knot_click(guint state);
+    virtual void knot_doubleclicked(guint state);
+
+    /Checks whether the index falls within the size of the parameter's vector/
+    bool valid_index(unsigned int index) const {
+        return (_pparam->_vector.size() > index);
+    };
+
+private:
+    FilletChamferPointArrayParam *_pparam;
+    unsigned int _index;
+};
+/*/
+
+FilletChamferPointArrayParamKnotHolderEntity::
+FilletChamferPointArrayParamKnotHolderEntity(
+    FilletChamferPointArrayParam *p, unsigned int index)
+    : _pparam(p), _index(index) {}
+
+void FilletChamferPointArrayParamKnotHolderEntity::knot_set(Point const &p,
+        Point const &origin,
+        guint state)
+{
+    using namespace Geom;
+
+    if (!valid_index(_index)) {
+        return;
+    }
+    /// @todo how about item transforms???
+    Piecewise<D2<SBasis> > const &pwd2 = _pparam->get_pwd2();
+    //todo: add snapping
+    //Geom::Point const s = snap_knot_position(p, state);
+    double t = nearest_point(p, pwd2[_index]);
+    if (t == 1) {
+        t = 0.9999;
+    }
+    t += _index;
+
+    if (_pparam->_vector.at(_index)[X] <= 0) {
+        _pparam->_vector.at(_index) =
+            Point(_pparam->time_to_len(_index, t), _pparam->_vector.at(_index)[Y]);
+    } else {
+        _pparam->_vector.at(_index) = Point(t, _pparam->_vector.at(_index)[Y]);
+    }
+    sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+}
+
+Point FilletChamferPointArrayParamKnotHolderEntity::knot_get() const
+{
+    using namespace Geom;
+
+    if (!valid_index(_index)) {
+        return Point(infinity(), infinity());
+    }
+
+    Piecewise<D2<SBasis> > const &pwd2 = _pparam->get_pwd2();
+
+    double time_it = _pparam->to_time(_index, _pparam->_vector.at(_index)[X]);
+    Point canvas_point = pwd2.valueAt(time_it);
+
+    _pparam->updateCanvasIndicators();
+    return canvas_point;
+
+}
+
+void FilletChamferPointArrayParamKnotHolderEntity::knot_click(guint state)
+{
+    if (state & GDK_CONTROL_MASK) {
+        if (state & GDK_MOD1_MASK) {
+            _pparam->_vector.at(_index) = Point(_index, _pparam->_vector.at(_index)[Y]);
+            _pparam->param_set_and_write_new_value(_pparam->_vector);
+            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+        }else{
+            using namespace Geom;
+            double type = _pparam->_vector.at(_index)[Y] + 1;
+            if (type > 4) {
+                type = 1;
+            }
+            _pparam->_vector.at(_index) = Point(_pparam->_vector.at(_index)[X], type);
+            _pparam->param_set_and_write_new_value(_pparam->_vector);
+            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+            const gchar *tip;
+            if (type == 3) {
+                tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> reset");
+            } else if (type == 2) {
+                tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> reset");
+            } else if (type == 1) {
+                tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> reset");
+            } else {
+                tip = _("<b>Double Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> reset");
+            }
+            this->knot->tip = g_strdup(tip);
+            this->knot->show();
+        }
+    } else if (state & GDK_SHIFT_MASK) {
+        double xModified = _pparam->_vector.at(_index).x(); 
+        if(xModified < 0 && !_pparam->use_distance){
+             xModified = _pparam->len_to_rad(_index, _pparam->_vector.at(_index).x());
+        }
+        std::vector<Geom::Path> subpaths = path_from_piecewise(_pparam->last_pwd2, 0.1);
+        std::pair<std::size_t, std::size_t> positions = _pparam->get_positions(_index, subpaths);
+        D2<SBasis> A = _pparam->last_pwd2[_pparam->last_index(_index, subpaths)];
+        if(positions.second != 0){
+            A = _pparam->last_pwd2[_index-1];
+        }
+        D2<SBasis> B = _pparam->last_pwd2[_index];
+        bool aprox = (A[0].degreesOfFreedom() != 2 || B[0].degreesOfFreedom() != 2) && !_pparam->use_distance?true:false;
+        Geom::Point offset = Geom::Point(xModified, _pparam->_vector.at(_index).y());
+        Inkscape::UI::Dialogs::FilletChamferPropertiesDialog::showDialog(
+            this->desktop, offset, this, _pparam->unit, _pparam->use_distance, aprox);
+    }
+
+}
+
+void FilletChamferPointArrayParamKnotHolderEntity::knot_set_offset(
+    Geom::Point offset)
+{
+    double xModified = offset.x(); 
+    if(xModified < 0 && !_pparam->use_distance){
+         xModified = _pparam->rad_to_len(_index, offset.x());
+    }
+    _pparam->_vector.at(_index) = Geom::Point(xModified, offset.y());
+    this->parent_holder->knot_ungrabbed_handler(this->knot, 0);
+}
+
+void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
+        SPDesktop *desktop,
+        SPItem *item)
+{
+    recalculate_knots(get_pwd2());
+    for (unsigned int i = 0; i < _vector.size(); ++i) {
+        if (_vector[i][Y] <= 0) {
+            continue;
+        }
+        const gchar *tip;
+        if (_vector[i][Y] == 3) {
+            tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+                    "<b>Shift+Click</b> open dialog, "
+                    "<b>Ctrl+Alt+Click</b> reset");
+        } else if (_vector[i][Y] == 2) {
+            tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+                    "<b>Shift+Click</b> open dialog, "
+                    "<b>Ctrl+Alt+Click</b> reset");
+        } else if (_vector[i][Y] == 1) {
+            tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+                    "<b>Shift+Click</b> open dialog, "
+                    "<b>Ctrl+Alt+Click</b> reset");
+        } else {
+            tip = _("<b>Double Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+                    "<b>Shift+Click</b> open dialog, "
+                    "<b>Ctrl+Alt+Click</b> reset");
+        }
+        FilletChamferPointArrayParamKnotHolderEntity *e =
+            new FilletChamferPointArrayParamKnotHolderEntity(this, i);
+        e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _(tip),
+                  knot_shape, knot_mode, knot_color);
+        knotholder->add(e);
+    }
+    updateCanvasIndicators();
+}
+
+} /* namespace LivePathEffect */
+
+} /* namespace Inkscape */
+
+/*
+  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 :

=== added file 'src/live_effects/parameter/filletchamferpointarray.h'
--- src/live_effects/parameter/filletchamferpointarray.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/filletchamferpointarray.h	2014-10-22 21:40:37 +0000
@@ -0,0 +1,123 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_FILLET_CHAMFER_POINT_ARRAY_H
+#define INKSCAPE_LIVEPATHEFFECT_FILLET_CHAMFER_POINT_ARRAY_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ * Copyright (C) Jabiertxo Arraiza Cenoz <[e-mail]>
+ * Special thanks to Johan Engelen for the base of the effect -powerstroke-
+ * Also to ScislaC for point me to the idea
+ * Also su_v for his construvtive feedback and time
+ * and finaly to Liam P. White for his big help on coding, that save me a lot of
+ * hours
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glib.h>
+#include <2geom/point.h>
+
+#include "live_effects/parameter/array.h"
+
+#include "knot-holder-entity.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+class FilletChamferPointArrayParamKnotHolderEntity;
+
+class FilletChamferPointArrayParam : public ArrayParam<Geom::Point> {
+public:
+    FilletChamferPointArrayParam(const Glib::ustring &label,
+                                 const Glib::ustring &tip,
+                                 const Glib::ustring &key,
+                                 Inkscape::UI::Widget::Registry *wr,
+                                 Effect *effect);
+    virtual ~FilletChamferPointArrayParam();
+
+    virtual Gtk::Widget *param_newWidget();
+
+    virtual void param_transform_multiply(Geom::Affine const &postmul,
+                                          bool /*set*/);
+
+    void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode,
+                            guint32 color);
+    virtual double to_time(int index, double A);
+    virtual double to_len(int index, double A);
+    virtual double rad_to_len(int index, double rad);
+    virtual double len_to_rad(int index, double len);
+    virtual double len_to_time(int index, double len);
+    virtual double time_to_len(int index, double time);
+    virtual std::pair<std::size_t, std::size_t> get_positions(int index, std::vector<Geom::Path> subpaths);
+    virtual int last_index(int index, std::vector<Geom::Path> subpaths);
+    std::vector<double> get_times(int index, std::vector<Geom::Path> subpaths, bool last);
+    virtual void set_helper_size(int hs);
+    virtual void set_use_distance(bool use_knot_distance);
+    virtual void set_unit(const gchar *abbr);
+    virtual void addCanvasIndicators(SPLPEItem const *lpeitem,
+                                     std::vector<Geom::PathVector> &hp_vec);
+    virtual bool providesKnotHolderEntities() const {
+        return true;
+    }
+    virtual void updateCanvasIndicators();
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop,
+                                       SPItem *item);
+
+    void set_pwd2(Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in,
+                  Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_normal_in);
+    Geom::Piecewise<Geom::D2<Geom::SBasis> > const &get_pwd2() const {
+        return last_pwd2;
+    }
+    Geom::Piecewise<Geom::D2<Geom::SBasis> > const &get_pwd2_normal() const {
+        return last_pwd2_normal;
+    }
+
+    void recalculate_controlpoints_for_new_pwd2(
+        Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in);
+    void recalculate_knots(
+        Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in);
+    friend class FilletChamferPointArrayParamKnotHolderEntity;
+
+private:
+    FilletChamferPointArrayParam(const FilletChamferPointArrayParam &);
+    FilletChamferPointArrayParam &operator=(const FilletChamferPointArrayParam &);
+
+    SPKnotShapeType knot_shape;
+    SPKnotModeType knot_mode;
+    guint32 knot_color;
+    int helper_size;
+    bool use_distance;
+    const gchar *unit;
+    Geom::PathVector hp;
+
+    Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2;
+    Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2_normal;
+};
+
+class FilletChamferPointArrayParamKnotHolderEntity : public KnotHolderEntity {
+public:
+    FilletChamferPointArrayParamKnotHolderEntity(FilletChamferPointArrayParam *p,
+            unsigned int index);
+    virtual ~FilletChamferPointArrayParamKnotHolderEntity() {}
+
+    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin,
+                          guint state);
+    virtual Geom::Point knot_get() const;
+    virtual void knot_click(guint state);
+    virtual void knot_set_offset(Geom::Point offset);
+
+    /*Checks whether the index falls within the size of the parameter's vector*/
+    bool valid_index(unsigned int index) const {
+        return (_pparam->_vector.size() > index);
+    }
+    ;
+
+private:
+    FilletChamferPointArrayParam *_pparam;
+    unsigned int _index;
+};
+
+} //namespace LivePathEffect
+
+} //namespace Inkscape
+
+#endif

=== modified file 'src/ui/CMakeLists.txt'
--- src/ui/CMakeLists.txt	2014-09-02 23:51:04 +0000
+++ src/ui/CMakeLists.txt	2014-10-22 21:40:37 +0000
@@ -78,6 +78,7 @@
 	dialog/layers.cpp
 	dialog/livepatheffect-add.cpp
 	dialog/livepatheffect-editor.cpp
+	dialog/lpe-fillet-chamfer-properties.cpp
 	dialog/memory.cpp
 	dialog/messages.cpp
 	dialog/new-from-template.cpp
@@ -194,6 +195,7 @@
 	dialog/layers.h
 	dialog/livepatheffect-add.h
 	dialog/livepatheffect-editor.h
+	dialog/lpe-fillet-chamfer-properties.cpp
 	dialog/memory.h
 	dialog/messages.h
 	dialog/new-from-template.h

=== modified file 'src/ui/dialog/Makefile_insert'
--- src/ui/dialog/Makefile_insert	2014-03-27 01:33:44 +0000
+++ src/ui/dialog/Makefile_insert	2014-10-22 21:40:37 +0000
@@ -114,4 +114,6 @@
 	ui/dialog/undo-history.h		\
 	ui/dialog/xml-tree.cpp		\
 	ui/dialog/xml-tree.h		\
+	ui/dialog/lpe-fillet-chamfer-properties.cpp		\
+	ui/dialog/lpe-fillet-chamfer-properties.h		\
 	$(inkboard_dialogs)

=== added file 'src/ui/dialog/lpe-fillet-chamfer-properties.cpp'
--- src/ui/dialog/lpe-fillet-chamfer-properties.cpp	1970-01-01 00:00:00 +0000
+++ src/ui/dialog/lpe-fillet-chamfer-properties.cpp	2014-10-22 21:40:37 +0000
@@ -0,0 +1,278 @@
+/**
+ * From the code of Liam P.White from his Power Stroke Knot dialog
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#if GLIBMM_DISABLE_DEPRECATED &&HAVE_GLIBMM_THREADS_H
+#include <glibmm/threads.h>
+#endif
+
+#include <gtkmm.h>
+#include "lpe-fillet-chamfer-properties.h"
+#include <boost/lexical_cast.hpp>
+#include <glibmm/main.h>
+#include <glibmm/i18n.h>
+#include "inkscape.h"
+#include "desktop.h"
+#include "document.h"
+#include "document-undo.h"
+#include "layer-manager.h"
+#include "message-stack.h"
+#include "desktop-handles.h"
+#include "sp-object.h"
+#include "sp-item.h"
+#include "verbs.h"
+#include "selection.h"
+#include "selection-chemistry.h"
+#include "ui/icon-names.h"
+#include "ui/widget/imagetoggler.h"
+#include "util/units.h"
+#include <cmath>
+
+//#include "event-context.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Dialogs {
+
+FilletChamferPropertiesDialog::FilletChamferPropertiesDialog()
+    : _desktop(NULL), _knotpoint(NULL), _position_visible(false)
+{
+    Gtk::Box *mainVBox = get_vbox();
+    mainVBox->set_homogeneous(false);
+    _layout_table.set_spacings(4);
+    _layout_table.resize(2, 2);
+
+    // Layer name widgets
+    _fillet_chamfer_position_numeric.set_digits(4);
+    _fillet_chamfer_position_numeric.set_increments(1,1);
+    //todo: get tha max aloable infinity freeze the widget
+    _fillet_chamfer_position_numeric.set_range(0., 999999999999999999.);
+    
+    _fillet_chamfer_position_label.set_label(_("Radius (pixels):"));
+    _fillet_chamfer_position_label.set_alignment(1.0, 0.5);
+
+    _layout_table.attach(_fillet_chamfer_position_label, 0, 1, 0, 1, Gtk::FILL,
+                         Gtk::FILL);
+    _layout_table.attach(_fillet_chamfer_position_numeric, 1, 2, 0, 1,
+                         Gtk::FILL | Gtk::EXPAND, Gtk::FILL);
+    _fillet_chamfer_type_fillet.set_label(_("Fillet"));
+    _fillet_chamfer_type_fillet.set_group(_fillet_chamfer_type_group);
+    _fillet_chamfer_type_inverse_fillet.set_label(_("Inverse fillet"));
+    _fillet_chamfer_type_inverse_fillet.set_group(_fillet_chamfer_type_group);
+    _fillet_chamfer_type_chamfer.set_label(_("Chamfer"));
+    _fillet_chamfer_type_chamfer.set_group(_fillet_chamfer_type_group);
+    _fillet_chamfer_type_double_chamfer.set_label(_("Double chamfer"));
+    _fillet_chamfer_type_double_chamfer.set_group(_fillet_chamfer_type_group);
+
+    mainVBox->pack_start(_layout_table, true, true, 4);
+    mainVBox->pack_start(_fillet_chamfer_type_fillet, true, true, 4);
+    mainVBox->pack_start(_fillet_chamfer_type_inverse_fillet, true, true, 4);
+    mainVBox->pack_start(_fillet_chamfer_type_chamfer, true, true, 4);
+    mainVBox->pack_start(_fillet_chamfer_type_double_chamfer, true, true, 4);
+
+    // Buttons
+    _close_button.set_use_stock(true);
+    _close_button.set_label(Gtk::Stock::CANCEL.id);
+    _close_button.set_can_default();
+
+    _apply_button.set_use_underline(true);
+    _apply_button.set_can_default();
+
+    _close_button.signal_clicked()
+    .connect(sigc::mem_fun(*this, &FilletChamferPropertiesDialog::_close));
+    _apply_button.signal_clicked()
+    .connect(sigc::mem_fun(*this, &FilletChamferPropertiesDialog::_apply));
+
+    signal_delete_event().connect(sigc::bind_return(
+                                      sigc::hide(sigc::mem_fun(*this, &FilletChamferPropertiesDialog::_close)),
+                                      true));
+
+    add_action_widget(_close_button, Gtk::RESPONSE_CLOSE);
+    add_action_widget(_apply_button, Gtk::RESPONSE_APPLY);
+
+    _apply_button.grab_default();
+
+    show_all_children();
+
+    set_focus(_fillet_chamfer_position_numeric);
+}
+
+FilletChamferPropertiesDialog::~FilletChamferPropertiesDialog()
+{
+
+    _setDesktop(NULL);
+}
+
+void FilletChamferPropertiesDialog::showDialog(
+    SPDesktop *desktop, Geom::Point knotpoint,
+    const Inkscape::LivePathEffect::
+    FilletChamferPointArrayParamKnotHolderEntity *pt,
+    const gchar *unit,
+    bool use_distance,
+    bool aprox_radius)
+{
+    FilletChamferPropertiesDialog *dialog = new FilletChamferPropertiesDialog();
+
+    dialog->_setDesktop(desktop);
+    dialog->_setUnit(unit);
+    dialog->_set_use_distance(use_distance);
+    dialog->_set_aprox(aprox_radius);
+    dialog->_setKnotPoint(knotpoint);
+    dialog->_setPt(pt);
+
+    dialog->set_title(_("Modify Fillet-Chamfer"));
+    dialog->_apply_button.set_label(_("_Modify"));
+
+    dialog->set_modal(true);
+    desktop->setWindowTransient(dialog->gobj());
+    dialog->property_destroy_with_parent() = true;
+
+    dialog->show();
+    dialog->present();
+}
+
+void FilletChamferPropertiesDialog::_apply()
+{
+    double d_width;
+    double d_pos =  _fillet_chamfer_position_numeric.get_value();
+    if (d_pos) {
+        if (_fillet_chamfer_type_fillet.get_active() == true) {
+            d_width = 1;
+        } else if (_fillet_chamfer_type_inverse_fillet.get_active() == true) {
+            d_width = 2;
+        } else if (_fillet_chamfer_type_chamfer.get_active() == true) {
+            d_width = 3;
+        } else {
+            d_width = 4;
+        }
+        if (_flexible) {
+            if (d_pos > 99.99999 || d_pos < 0) {
+                d_pos = 0;
+            }
+            d_pos = _index + (d_pos / 100);
+        } else {
+            d_pos = Inkscape::Util::Quantity::convert(d_pos, unit, "px");
+            d_pos = d_pos * -1;
+        }
+        _knotpoint->knot_set_offset(Geom::Point(d_pos, d_width));
+    }
+    _close();
+}
+
+void FilletChamferPropertiesDialog::_close()
+{
+    _setDesktop(NULL);
+    destroy_();
+    Glib::signal_idle().connect(
+        sigc::bind_return(
+            sigc::bind(sigc::ptr_fun(&::operator delete), this),
+            false
+        )
+    );
+}
+
+bool FilletChamferPropertiesDialog::_handleKeyEvent(GdkEventKey *event)
+{
+    return false;
+}
+
+void FilletChamferPropertiesDialog::_handleButtonEvent(GdkEventButton *event)
+{
+    if ((event->type == GDK_2BUTTON_PRESS) && (event->button == 1)) {
+        _apply();
+    }
+}
+
+void FilletChamferPropertiesDialog::_setKnotPoint(Geom::Point knotpoint)
+{
+    double position;
+    std::string distance_or_radius = std::string(_("Radius "));
+    if(aprox){
+        distance_or_radius = std::string(_("Radius aproximated "));
+    }
+    if(use_distance){
+        distance_or_radius = std::string(_("Knot distance "));
+    }
+    if (knotpoint.x() > 0) {
+        double intpart;
+        position = modf(knotpoint[Geom::X], &intpart) * 100;
+        _flexible = true;
+        _index = intpart;
+        _fillet_chamfer_position_label.set_label(_("Position (%):"));
+    } else {
+        _flexible = false;
+        std::string posConcat = distance_or_radius +
+            std::string(_("(")) + std::string(unit) + std::string(")");
+        _fillet_chamfer_position_label.set_label(_(posConcat.c_str()));
+        position = knotpoint[Geom::X] * -1;
+        position = Inkscape::Util::Quantity::convert(position, "px", unit);
+    }
+    _fillet_chamfer_position_numeric.set_value(position);
+    if (knotpoint.y() == 1) {
+        _fillet_chamfer_type_fillet.set_active(true);
+    } else if (knotpoint.y() == 2) {
+        _fillet_chamfer_type_inverse_fillet.set_active(true);
+    } else if (knotpoint.y() == 3) {
+        _fillet_chamfer_type_chamfer.set_active(true);
+    } else if (knotpoint.y() == 1) {
+        _fillet_chamfer_type_double_chamfer.set_active(true);
+    }
+}
+
+void FilletChamferPropertiesDialog::_setPt(
+    const Inkscape::LivePathEffect::
+    FilletChamferPointArrayParamKnotHolderEntity *pt)
+{
+    _knotpoint = const_cast<
+                 Inkscape::LivePathEffect::FilletChamferPointArrayParamKnotHolderEntity *>(
+                     pt);
+}
+
+void FilletChamferPropertiesDialog::_setUnit(const gchar *abbr)
+{
+    unit = abbr;
+}
+
+void FilletChamferPropertiesDialog::_set_use_distance(bool use_knot_distance)
+{
+    use_distance = use_knot_distance;
+}
+
+void FilletChamferPropertiesDialog::_set_aprox(bool aprox_radius)
+{
+    aprox = aprox_radius;
+}
+
+void FilletChamferPropertiesDialog::_setDesktop(SPDesktop *desktop)
+{
+    if (desktop) {
+        Inkscape::GC::anchor(desktop);
+    }
+    if (_desktop) {
+        Inkscape::GC::release(_desktop);
+    }
+    _desktop = desktop;
+}
+
+} // namespace
+} // namespace
+} // namespace
+
+/*
+  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
+// :

=== added file 'src/ui/dialog/lpe-fillet-chamfer-properties.h'
--- src/ui/dialog/lpe-fillet-chamfer-properties.h	1970-01-01 00:00:00 +0000
+++ src/ui/dialog/lpe-fillet-chamfer-properties.h	2014-10-22 21:40:37 +0000
@@ -0,0 +1,110 @@
+/**
+ *
+ * From the code of Liam P.White from his Power Stroke Knot dialog
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information
+ */
+
+#ifndef INKSCAPE_DIALOG_FILLET_CHAMFER_PROPERTIES_H
+#define INKSCAPE_DIALOG_FILLET_CHAMFER_PROPERTIES_H
+
+#include <2geom/point.h>
+#include <gtkmm.h>
+#include "live_effects/parameter/filletchamferpointarray.h"
+
+class SPDesktop;
+
+namespace Inkscape {
+namespace UI {
+namespace Dialogs {
+
+class FilletChamferPropertiesDialog : public Gtk::Dialog {
+public:
+    FilletChamferPropertiesDialog();
+    virtual ~FilletChamferPropertiesDialog();
+
+    Glib::ustring getName() const {
+        return "LayerPropertiesDialog";
+    }
+
+    static void showDialog(SPDesktop *desktop, Geom::Point knotpoint,
+                           const Inkscape::LivePathEffect::
+                           FilletChamferPointArrayParamKnotHolderEntity *pt,
+                           const gchar *unit,
+                           bool use_distance,
+                           bool aprox_radius);
+
+protected:
+
+    SPDesktop *_desktop;
+    Inkscape::LivePathEffect::FilletChamferPointArrayParamKnotHolderEntity *
+    _knotpoint;
+
+    Gtk::Label _fillet_chamfer_position_label;
+    Gtk::SpinButton _fillet_chamfer_position_numeric;
+    Gtk::RadioButton::Group _fillet_chamfer_type_group;
+    Gtk::RadioButton _fillet_chamfer_type_fillet;
+    Gtk::RadioButton _fillet_chamfer_type_inverse_fillet;
+    Gtk::RadioButton _fillet_chamfer_type_chamfer;
+    Gtk::RadioButton _fillet_chamfer_type_double_chamfer;
+
+    Gtk::Table _layout_table;
+    bool _position_visible;
+    double _index;
+
+    Gtk::Button _close_button;
+    Gtk::Button _apply_button;
+
+    sigc::connection _destroy_connection;
+
+    static FilletChamferPropertiesDialog &_instance() {
+        static FilletChamferPropertiesDialog instance;
+        return instance;
+    }
+
+    void _setDesktop(SPDesktop *desktop);
+    void _setPt(const Inkscape::LivePathEffect::
+                FilletChamferPointArrayParamKnotHolderEntity *pt);
+    void _setUnit(const gchar *abbr);
+    void _set_use_distance(bool use_knot_distance);
+    void _set_aprox(bool aprox_radius);
+    void _apply();
+    void _close();
+    bool _flexible;
+    const gchar *unit;
+    bool use_distance;
+    bool aprox;
+    void _setKnotPoint(Geom::Point knotpoint);
+    void _prepareLabelRenderer(Gtk::TreeModel::const_iterator const &row);
+
+    bool _handleKeyEvent(GdkEventKey *event);
+    void _handleButtonEvent(GdkEventButton *event);
+
+    friend class Inkscape::LivePathEffect::
+            FilletChamferPointArrayParamKnotHolderEntity;
+
+private:
+    FilletChamferPropertiesDialog(
+        FilletChamferPropertiesDialog const &); // no copy
+    FilletChamferPropertiesDialog &operator=(
+        FilletChamferPropertiesDialog const &); // no assign
+};
+
+} // namespace
+} // namespace
+} // namespace
+
+#endif //INKSCAPE_DIALOG_LAYER_PROPERTIES_H
+
+/*
+  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
+// :

=== modified file 'src/ui/tool/multi-path-manipulator.h'
--- src/ui/tool/multi-path-manipulator.h	2014-03-27 01:33:44 +0000
+++ src/ui/tool/multi-path-manipulator.h	2014-10-22 21:40:37 +0000
@@ -53,6 +53,7 @@
 
     void insertNodesAtExtrema(ExtremumType extremum);
     void insertNodes();
+    void alertLPE();
     void duplicateNodes();
     void joinNodes();
     void breakNodes();
@@ -104,7 +105,7 @@
     }
 
     void _commit(CommitEvent cps);
-    void _done(gchar const *reason, bool alert_LPE = false);
+    void _done(gchar const *reason, bool alert_LPE = true);
     void _doneWithCleanup(gchar const *reason, bool alert_LPE = false);
     guint32 _getOutlineColor(ShapeRole role);
 

=== modified file 'src/ui/tool/path-manipulator.cpp'
--- src/ui/tool/path-manipulator.cpp	2014-03-27 01:33:44 +0000
+++ src/ui/tool/path-manipulator.cpp	2014-10-22 21:40:37 +0000
@@ -11,6 +11,7 @@
  */
 
 #include "live_effects/lpe-powerstroke.h"
+#include "live_effects/lpe-fillet-chamfer.h"
 #include <string>
 #include <sstream>
 #include <deque>
@@ -1207,11 +1208,20 @@
     _spcurve->set_pathvector(pathv);
     if (alert_LPE) {
         /// \todo note that _path can be an Inkscape::LivePathEffect::Effect* too, kind of confusing, rework member naming?
-        if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) {
-            PathEffectList effect_list = _path->getEffectList();
-            LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast<LivePathEffect::LPEPowerStroke*>( effect_list.front()->lpeobject->get_lpe() );
-            if (lpe_pwr) {
-                lpe_pwr->adjustForNewPath(pathv);
+        if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()){
+            Inkscape::LivePathEffect::Effect* thisEffect = SP_LPE_ITEM(_path)->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE);
+            if(thisEffect){
+                LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast<LivePathEffect::LPEPowerStroke*>(thisEffect->getLPEObj()->get_lpe());
+                if (lpe_pwr) {
+                    lpe_pwr->adjustForNewPath(pathv);
+                }
+            }
+            thisEffect = SP_LPE_ITEM(_path)->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER);
+            if(thisEffect){
+                LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast<LivePathEffect::LPEFilletChamfer*>(thisEffect->getLPEObj()->get_lpe());
+                if (lpe_fll) {
+                    lpe_fll->adjustForNewPath(pathv);
+                }
             }
         }
     }

=== modified file 'src/ui/tools/node-tool.cpp'
--- src/ui/tools/node-tool.cpp	2014-08-31 21:19:39 +0000
+++ src/ui/tools/node-tool.cpp	2014-10-22 21:40:37 +0000
@@ -24,6 +24,8 @@
 #include "message-context.h"
 #include "selection.h"
 #include "shape-editor.h" // temporary!
+#include "live_effects/effect.h"
+#include "display/curve.h"
 #include "sp-clippath.h"
 #include "sp-item-group.h"
 #include "sp-mask.h"
@@ -167,6 +169,7 @@
     if (this->flash_tempitem) {
         this->desktop->remove_temporary_canvasitem(this->flash_tempitem);
     }
+
     if (this->helperpath_tmpitem) {
         this->desktop->remove_temporary_canvasitem(this->helperpath_tmpitem);
     }
@@ -250,13 +253,13 @@
 		)))
     );
 
-    this->helperpath_tmpitem = NULL;
     this->cursor_drag = false;
     this->show_transform_handles = true;
     this->single_node_transform_handles = false;
     this->flash_tempitem = NULL;
     this->flashed_item = NULL;
     this->_last_over = NULL;
+    this->helperpath_tmpitem = NULL;
 
     // read prefs before adding items to selection to prevent momentarily showing the outline
     sp_event_context_read(this, "show_handles");
@@ -473,6 +476,7 @@
     case GDK_MOTION_NOTIFY: {
 	this->update_helperpath();
         combine_motion_events(desktop->canvas, event->motion, 0);
+        this->update_helperpath();
         SPItem *over_item = sp_event_context_find_item (desktop, event_point(event->button),
                 FALSE, TRUE);