Merge lp:~inkscape.dev/inkscape/lattice2 into lp:~inkscape.dev/inkscape/trunk

[Jabiertxof]

It improve lattice to a new live effet lattice 2, add the knots visibles on groups and make the helper paths show again

[lp:~inkscape.dev/inkscape/lattice2]

12742. By Jabiertxof <email address hidden> on 2014-01-12

update to trunk

12743. By Jabiertxof <email address hidden> on 2014-03-03

fixing update to trunk

12744. By Jabiertxof <email address hidden> on 2014-03-03

update to trunk

12745. By Jabiertxof <email address hidden> on 2014-03-03

update to trunk

12746. By Jabiertxof <email address hidden> on 2014-03-23

update to trunk

12747. By Jabiertxof <email address hidden> on 2014-03-23

update to trunk

[Martin Owens (doctormo)]

I've done a code review, but I need to have instructions about the testing proceedure. What it should do etc for a functional test.

Most of the code is good.

I'm unhappy about the lack of code reuse in lpe-lattice2.cpp/h there are so many grid points that all that code should be converted to using a vector or some kind and shortened. Normally this would be a nit-pick, but I believe the flatness in those files is bad enough to warrant a Needs Fixing.

review: Needs Fixing (code)

[Martin Owens (doctormo)]

On Fri, 2014-03-28 at 08:20 +0100, Jabiertxo Arraiza Cenoz wrote:
> There is a strange bug whith some groups that make necessary press
> reset
> grid at first step to show correct :(
>
> I'm going to change it to vector. Ping you when done.

Thanks for the quick reply Jabier.

The name presented to users is "Lattice Deformation 2", is this the best
description of what it does? how is this Lattice different from Lattice
Deformation 1?

Best Regards, Martin Owens

[lp:~inkscape.dev/inkscape/lattice2]

12748. By Jabiertxof <email address hidden> on 2014-03-28

update to trunk

12749. By Jabiertxof <email address hidden> on 2014-03-28

update to trunk

12750. By root <email address hidden> on 2014-03-29

Refactor to simplify the code.

12751. By root <email address hidden> on 2014-03-29

update to trunk

[Jabiertxof (jabiertxof)]

> On Fri, 2014-03-28 at 08:20 +0100, Jabiertxo Arraiza Cenoz wrote:
> > There is a strange bug whith some groups that make necessary press
> > reset
> > grid at first step to show correct :(
> >
> > I'm going to change it to vector. Ping you when done.
>
> Thanks for the quick reply Jabier.
>
> The name presented to users is "Lattice Deformation 2", is this the best
> description of what it does? how is this Lattice different from Lattice
> Deformation 1?
>
> Best Regards, Martin Owens

Hi Martin, Think i respond to you but dont see here.
Latticce2 is the same of latticce with important changes and bugfixes. But the effect distorsion elements whith old lattice effect. I discuss whith suv about the name and finaly we select this, for the moment.

By the other way I refactor a lot the code but if need more, I need help moving the "PointReseteableParam" to an array,vector... because coulden`t inicializate the diferent
PointReseteableParam on constructor. But I spend a lot of time whith this and dont find another way than create a new pointparameter that handle points arrays.

TODO: add presets and collapse/expand to the pointparameter list

review: Needs Resubmitting

[Jabiertxof (jabiertxof)]

> On Fri, 2014-03-28 at 08:20 +0100, Jabiertxo Arraiza Cenoz wrote:
> > There is a strange bug whith some groups that make necessary press
> > reset
> > grid at first step to show correct :(

This bug is not related to lattice2: https://bugs.launchpad.net/inkscape/+bug/1299461

[Martin Owens (doctormo)]

OK, name is ok if it's been discussed before. Code will have to stand as is.

review: Approve (code)

[lp:~inkscape.dev/inkscape/lattice2]

12752. By Jabiertxof <email address hidden> on 2014-03-29

update to knot changes

12753. By Jabiertxof <email address hidden> on 2014-03-29

Fixing redraw by Knot update

12754. By Jabiertxof <email address hidden> on 2014-04-06

update to trunk

12755. By Jabiertxof <email address hidden> on 2014-04-06

fix a bad applied patch to source

12756. By Jabiertxof <email address hidden> on 2014-04-09

removed extra var

12757. By Jabiertxof <email address hidden> on 2014-04-09

update to trunk

12758. By Jabiertxof <email address hidden> on 2014-04-11

Fix bug show by su_v in console execution

12759. By Jabiertxof <email address hidden> on 2014-04-11

update to trunk

12760. By Jabiertxof <email address hidden> on 2014-04-11

Removed unnecesary static var

12761. By Jabiertxof <email address hidden> on 2014-04-12

updates to helper paths

12762. By Jabiertxof <email address hidden> on 2014-05-13

update to trunk

[su_v (suv-lp)]

lattice2 was merged into experimental in r13355
http://bazaar.launchpad.net/~inkscape.dev/inkscape/experimental/revision/13355

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

Changing status to 'Merged'.

=== modified file 'po/POTFILES.skip'
--- po/POTFILES.skip	2010-01-14 08:13:09 +0000
+++ po/POTFILES.skip	2014-05-13 06:54:02 +0000
@@ -25,6 +25,7 @@
 src/live_effects/lpe-tangent_to_curve.cpp
 src/live_effects/lpe-test-doEffect-stack.cpp
 src/live_effects/lpe-text_label.cpp
+src/live_effects/lpe-lattice2.cpp
 src/lpe-tool-context.cpp
 src/ui/dialog/session-player.cpp
 src/ui/dialog/whiteboard-connect.cpp

=== 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-05-13 06:54:02 +0000
@@ -40,6 +40,8 @@
 	live_effects/lpe-test-doEffect-stack.h	\
 	live_effects/lpe-lattice.cpp	\
 	live_effects/lpe-lattice.h	\
+	live_effects/lpe-lattice2.cpp	\
+	live_effects/lpe-lattice2.h	\
 	live_effects/lpe-envelope.cpp	\
 	live_effects/lpe-envelope.h	\
 	live_effects/lpe-spiro.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-05-13 06:54:02 +0000
@@ -28,6 +28,7 @@
     PERSPECTIVE_PATH,
     SPIRO,
     LATTICE,
+    LATTICE2,
     ENVELOPE,
     CONSTRUCT_GRID,
     PERP_BISECTOR,

=== 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-05-13 06:54:02 +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-lattice2.h"
 #include "live_effects/lpe-envelope.h"
 #include "live_effects/lpe-constructgrid.h"
 #include "live_effects/lpe-perp_bisector.h"
@@ -89,12 +90,12 @@
     {CIRCLE_3PTS,           N_("Circle by 3 points"),      "circle_3pts"},
     {DYNASTROKE,            N_("Dynamic stroke"),          "dynastroke"},
     {EXTRUDE,               N_("Extrude"),                 "extrude"},
-    {LATTICE,               N_("Lattice Deformation"),     "lattice"},
     {LINE_SEGMENT,          N_("Line Segment"),            "line_segment"},
     {MIRROR_SYMMETRY,       N_("Mirror symmetry"),         "mirror_symmetry"},
     {OFFSET,                N_("Offset"),                  "offset"},
     {PARALLEL,              N_("Parallel"),                "parallel"},
     {PATH_LENGTH,           N_("Path length"),             "path_length"},
+    {LATTICE,               N_("Lattice Deformation"),     "lattice"},
     {PERP_BISECTOR,         N_("Perpendicular bisector"),  "perp_bisector"},
     {PERSPECTIVE_PATH,      N_("Perspective path"),        "perspective_path"},
     {COPY_ROTATE,           N_("Rotate copies"),           "copy_rotate"},
@@ -120,6 +121,7 @@
 /* 0.49 */
     {POWERSTROKE,           N_("Power stroke"), "powerstroke"},
     {CLONE_ORIGINAL,        N_("Clone original path"), "clone_original"},
+    {LATTICE2,               N_("Lattice Deformation 2"),     "lattice2"},
 };
 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 LATTICE2:
+            neweffect = static_cast<Effect*> ( new LPELattice2(lpeobj) );
+            break;
         default:
             g_warning("LivePathEffect::Effect::New   called with invalid patheffect type (%d)", lpenr);
             neweffect = NULL;
@@ -496,7 +501,16 @@
 
     if (!SP_IS_SHAPE(lpeitem)) {
 //        g_print ("How to handle helperpaths for non-shapes?\n"); // non-shapes are for example SPGroups.
-        return hp_vec;
+//        return hp_vec;
+    }
+
+
+    // TODO: we can probably optimize this by using a lot more references
+    //       rather than copying PathVectors all over the place
+    if (SP_IS_SHAPE(lpeitem) && show_orig_path) {
+        // add original path to helperpaths
+        SPCurve* curve = SP_SHAPE(lpeitem)->getCurve ();
+        hp_vec.push_back(curve->get_pathvector());
     }
 
     // add indicators provided by the effect itself

=== modified file 'src/live_effects/lpe-lattice.h'
--- src/live_effects/lpe-lattice.h	2014-03-27 01:33:44 +0000
+++ src/live_effects/lpe-lattice.h	2014-05-13 06:54:02 +0000
@@ -58,7 +58,6 @@
     PointParam grid_point13;
     PointParam grid_point14;
     PointParam grid_point15;
-    
     LPELattice(const LPELattice&);
     LPELattice& operator=(const LPELattice&);
 };

=== added file 'src/live_effects/lpe-lattice2.cpp'
--- src/live_effects/lpe-lattice2.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-lattice2.cpp	2014-05-13 06:54:02 +0000
@@ -0,0 +1,496 @@
+/** \file
+ * LPE <lattice2> implementation
+ 
+ */
+/*
+ * Authors:
+ *   Johan Engelen <[e-mail]>
+ *   Steren Giannini
+ *   Noé Falzon
+ *   Victor Navez
+ *   ~suv
+ *   Jabiertxo Arraiza
+*
+* Copyright (C) 2007-2008 Authors 
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/lpe-lattice2.h"
+
+#include "sp-shape.h"
+#include "sp-item.h"
+#include "sp-path.h"
+#include "display/curve.h"
+#include "svg/svg.h"
+
+#include <2geom/sbasis.h>
+#include <2geom/sbasis-2d.h>
+#include <2geom/sbasis-geometric.h>
+#include <2geom/bezier-to-sbasis.h>
+#include <2geom/sbasis-to-bezier.h>
+#include <2geom/d2.h>
+#include <2geom/piecewise.h>
+#include <2geom/transforms.h>
+#include <tools-switch.h>
+
+#include "desktop.h" // TODO: should be factored out (see below)
+
+using namespace Geom;
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+LPELattice2::LPELattice2(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    // initialise your parameters here:
+    grid_point0(_("Control handle 0:"), _("Control handle 0 - Ctrl+Alt+Click to reset"), "gridpoint0", &wr, this),
+    grid_point1(_("Control handle 1:"), _("Control handle 1 - Ctrl+Alt+Click to reset"), "gridpoint1", &wr, this),
+    grid_point2(_("Control handle 2:"), _("Control handle 2 - Ctrl+Alt+Click to reset"), "gridpoint2", &wr, this),
+    grid_point3(_("Control handle 3:"), _("Control handle 3 - Ctrl+Alt+Click to reset"), "gridpoint3", &wr, this),
+    grid_point4(_("Control handle 4:"), _("Control handle 4 - Ctrl+Alt+Click to reset"), "gridpoint4", &wr, this),
+    grid_point5(_("Control handle 5:"), _("Control handle 5 - Ctrl+Alt+Click to reset"), "gridpoint5", &wr, this),
+    grid_point6(_("Control handle 6:"), _("Control handle 6 - Ctrl+Alt+Click to reset"), "gridpoint6", &wr, this),
+    grid_point7(_("Control handle 7:"), _("Control handle 7 - Ctrl+Alt+Click to reset"), "gridpoint7", &wr, this),
+    grid_point8x9(_("Control handle 8x9:"), _("Control handle 8x9 - Ctrl+Alt+Click to reset"), "gridpoint8x9", &wr, this),
+    grid_point10x11(_("Control handle 10x11:"), _("Control handle 10x11 - Ctrl+Alt+Click to reset"), "gridpoint10x11", &wr, this),
+    grid_point12(_("Control handle 12:"), _("Control handle 12 - Ctrl+Alt+Click to reset"), "gridpoint12", &wr, this),
+    grid_point13(_("Control handle 13:"), _("Control handle 13 - Ctrl+Alt+Click to reset"), "gridpoint13", &wr, this),
+    grid_point14(_("Control handle 14:"), _("Control handle 14 - Ctrl+Alt+Click to reset"), "gridpoint14", &wr, this),
+    grid_point15(_("Control handle 15:"), _("Control handle 15 - Ctrl+Alt+Click to reset"), "gridpoint15", &wr, this),
+    grid_point16(_("Control handle 16:"), _("Control handle 16 - Ctrl+Alt+Click to reset"), "gridpoint16", &wr, this),
+    grid_point17(_("Control handle 17:"), _("Control handle 17 - Ctrl+Alt+Click to reset"), "gridpoint17", &wr, this),
+    grid_point18(_("Control handle 18:"), _("Control handle 18 - Ctrl+Alt+Click to reset"), "gridpoint18", &wr, this),
+    grid_point19(_("Control handle 19:"), _("Control handle 19 - Ctrl+Alt+Click to reset"), "gridpoint19", &wr, this),
+    grid_point20x21(_("Control handle 20x21:"), _("Control handle 20x21 - Ctrl+Alt+Click to reset"), "gridpoint20x21", &wr, this),
+    grid_point22x23(_("Control handle 22x23:"), _("Control handle 22x23 - Ctrl+Alt+Click to reset"), "gridpoint22x23", &wr, this),
+    grid_point24x26(_("Control handle 24x26:"), _("Control handle 24x26 - Ctrl+Alt+Click to reset"), "gridpoint24x26", &wr, this),
+    grid_point25x27(_("Control handle 25x27:"), _("Control handle 25x27 - Ctrl+Alt+Click to reset"), "gridpoint25x27", &wr, this),
+    grid_point28x30(_("Control handle 28x30:"), _("Control handle 28x30 - Ctrl+Alt+Click to reset"), "gridpoint28x30", &wr, this),
+    grid_point29x31(_("Control handle 29x31:"), _("Control handle 29x31 - Ctrl+Alt+Click to reset"), "gridpoint29x31", &wr, this),
+    grid_point32x33x34x35(_("Control handle 32x33x34x35:"), _("Control handle 32x33x34x35 - Ctrl+Alt+Click to reset"), "gridpoint32x33x34x35", &wr, this)
+
+    
+{
+    // register all your parameters here, so Inkscape knows which parameters this effect has:
+    registerParameter( dynamic_cast<Parameter *>(&grid_point0) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point1) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point2) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point3) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point4) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point5) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point6) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point7) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point8x9) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point10x11) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point12) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point13) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point14) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point15) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point16) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point17) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point18) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point19) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point20x21) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point22x23) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point24x26) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point25x27) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point28x30) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point29x31) );
+    registerParameter( dynamic_cast<Parameter *>(&grid_point32x33x34x35) );
+}
+
+LPELattice2::~LPELattice2()
+{
+}
+
+Geom::Piecewise<Geom::D2<Geom::SBasis> >
+LPELattice2::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
+{
+    D2<SBasis2d> sb2;
+    
+    //Initialisation of the sb2
+    for(unsigned dim = 0; dim < 2; dim++) {
+        sb2[dim].us = 3;
+        sb2[dim].vs = 3;
+        const int depth = sb2[dim].us*sb2[dim].vs;
+        sb2[dim].resize(depth, Linear2d(0));
+    }
+
+    //Grouping the point params in a convenient vector
+    std::vector<Geom::Point *> handles(36);
+    
+    handles[0] = &grid_point0;
+    handles[1] = &grid_point1;
+    handles[2] = &grid_point2;
+    handles[3] = &grid_point3;
+    handles[4] = &grid_point4;
+    handles[5] = &grid_point5;
+    handles[6] = &grid_point6;
+    handles[7] = &grid_point7;
+    handles[8] = &grid_point8x9;
+    handles[9] = &grid_point8x9;
+    handles[10] = &grid_point10x11;
+    handles[11] = &grid_point10x11;
+    handles[12] = &grid_point12;
+    handles[13] = &grid_point13;
+    handles[14] = &grid_point14;
+    handles[15] = &grid_point15;
+    handles[16] = &grid_point16;
+    handles[17] = &grid_point17;
+    handles[18] = &grid_point18;
+    handles[19] = &grid_point19;
+    handles[20] = &grid_point20x21;
+    handles[21] = &grid_point20x21;
+    handles[22] = &grid_point22x23;
+    handles[23] = &grid_point22x23;
+    handles[24] = &grid_point24x26;
+    handles[25] = &grid_point25x27;
+    handles[26] = &grid_point24x26;
+    handles[27] = &grid_point25x27;
+    handles[28] = &grid_point28x30;
+    handles[29] = &grid_point29x31;
+    handles[30] = &grid_point28x30;
+    handles[31] = &grid_point29x31;
+    handles[32] = &grid_point32x33x34x35;
+    handles[33] = &grid_point32x33x34x35;
+    handles[34] = &grid_point32x33x34x35;
+    handles[35] = &grid_point32x33x34x35;
+
+    Geom::Point origin = Geom::Point(boundingbox_X.min(),boundingbox_Y.min());
+      
+    double width = boundingbox_X.extent();
+    double height = boundingbox_Y.extent();
+
+    //numbering is based on 4 rectangles.16
+    for(unsigned dim = 0; dim < 2; dim++) {
+        Geom::Point dir(0,0);
+        dir[dim] = 1;
+        for(unsigned vi = 0; vi < sb2[dim].vs; vi++) {
+            for(unsigned ui = 0; ui < sb2[dim].us; ui++) {
+                for(unsigned iv = 0; iv < 2; iv++) {
+                    for(unsigned iu = 0; iu < 2; iu++) {
+                        unsigned corner = iu + 2*iv;
+                        unsigned i = ui + vi*sb2[dim].us;
+                        
+                        //This is the offset from the Upperleft point
+                        Geom::Point base(   (ui + iu*(4-2*ui))*width/4.,
+                                            (vi + iv*(4-2*vi))*height/4.);
+                        
+                        //Special action for corners
+                        if(vi == 0 && ui == 0) {
+                            base = Geom::Point(0,0);
+                        }
+                        
+                        // i = Upperleft corner of the considerated rectangle
+                        // corner = actual corner of the rectangle
+                        // origin = Upperleft point
+                        double dl = dot((*handles[corner+4*i] - (base + origin)), dir)/dot(dir,dir);
+                        sb2[dim][i][corner] = dl/( dim ? height : width )*pow(4.0,ui+vi);
+                    }
+                }
+            }
+        }
+    }
+   
+    Piecewise<D2<SBasis> >  output;
+    output.push_cut(0.);
+    for(unsigned i = 0; i < pwd2_in.size(); i++) {
+        D2<SBasis> B = pwd2_in[i];
+        B[Geom::X] -= origin[Geom::X];
+        B[Geom::X]*= 1/width;
+        B[Geom::Y] -= origin[Geom::Y];
+        B[Geom::Y]*= 1/height;
+        //Here comes the magic
+        D2<SBasis> tB = compose_each(sb2,B);
+        tB[Geom::X] = tB[Geom::X] * width + origin[Geom::X];
+        tB[Geom::Y] = tB[Geom::Y] * height + origin[Geom::Y];
+
+        output.push(tB,i+1);
+    }
+    return output;
+}
+
+Gtk::Widget *
+LPELattice2::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);
+    Gtk::Button* resetButton = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset grid"))));
+    resetButton->set_alignment(0.0, 0.5);
+    resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPELattice2::resetGrid));
+    Gtk::Widget* resetButtonWidget = dynamic_cast<Gtk::Widget *>(resetButton);
+    resetButtonWidget->set_tooltip_text("Reset grid");
+    vbox->pack_start(*resetButtonWidget, true, true,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 = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+            if(param->param_key == "grid"){
+                widg = NULL;
+            }
+            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;
+    }
+    return dynamic_cast<Gtk::Widget *>(vbox);
+}
+
+void
+LPELattice2::doBeforeEffect (SPLPEItem const* lpeitem)
+{
+    original_bbox(lpeitem);
+    setDefaults();
+}
+
+void
+LPELattice2::setDefaults()
+{
+    Geom::Point gp0((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min());
+
+    Geom::Point gp1((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min());
+
+    Geom::Point gp2((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
+
+    Geom::Point gp3((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
+
+    Geom::Point gp4((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min());
+
+    Geom::Point gp5((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min());
+
+    Geom::Point gp6((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
+
+    Geom::Point gp7((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
+
+    Geom::Point gp8x9((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min());
+
+    Geom::Point gp10x11((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
+
+    Geom::Point gp12((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+
+    Geom::Point gp13((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+
+    Geom::Point gp14((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+
+    Geom::Point gp15((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+
+    Geom::Point gp16((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+
+    Geom::Point gp17((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+
+    Geom::Point gp18((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+
+    Geom::Point gp19((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+
+    Geom::Point gp20x21((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+
+    Geom::Point gp22x23((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+
+    Geom::Point gp24x26((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+
+    Geom::Point gp25x27((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+
+    Geom::Point gp28x30((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+
+    Geom::Point gp29x31((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+
+    Geom::Point gp32x33x34x35((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
+                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+
+    grid_point0.param_update_default(gp0);
+    grid_point1.param_update_default(gp1);
+    grid_point2.param_update_default(gp2);
+    grid_point3.param_update_default(gp3);
+    grid_point4.param_update_default(gp4);
+    grid_point5.param_update_default(gp5);
+    grid_point6.param_update_default(gp6);
+    grid_point7.param_update_default(gp7);
+    grid_point8x9.param_update_default(gp8x9);
+    grid_point10x11.param_update_default(gp10x11);
+    grid_point12.param_update_default(gp12);
+    grid_point13.param_update_default(gp13);
+    grid_point14.param_update_default(gp14);
+    grid_point15.param_update_default(gp15);
+    grid_point16.param_update_default(gp16);
+    grid_point17.param_update_default(gp17);
+    grid_point18.param_update_default(gp18);
+    grid_point19.param_update_default(gp19);
+    grid_point20x21.param_update_default(gp20x21);
+    grid_point22x23.param_update_default(gp22x23);
+    grid_point24x26.param_update_default(gp24x26);
+    grid_point25x27.param_update_default(gp25x27);
+    grid_point28x30.param_update_default(gp28x30);
+    grid_point29x31.param_update_default(gp29x31);
+    grid_point32x33x34x35.param_update_default(gp32x33x34x35);
+}
+
+void
+LPELattice2::resetGrid()
+{
+    grid_point0.param_set_and_write_default();
+    grid_point1.param_set_and_write_default();
+    grid_point2.param_set_and_write_default();
+    grid_point3.param_set_and_write_default();
+    grid_point4.param_set_and_write_default();
+    grid_point5.param_set_and_write_default();
+    grid_point6.param_set_and_write_default();
+    grid_point7.param_set_and_write_default();
+    grid_point8x9.param_set_and_write_default();
+    grid_point10x11.param_set_and_write_default();
+    grid_point12.param_set_and_write_default();
+    grid_point13.param_set_and_write_default();
+    grid_point14.param_set_and_write_default();
+    grid_point15.param_set_and_write_default();
+    grid_point16.param_set_and_write_default();
+    grid_point17.param_set_and_write_default();
+    grid_point18.param_set_and_write_default();
+    grid_point19.param_set_and_write_default();
+    grid_point20x21.param_set_and_write_default();
+    grid_point22x23.param_set_and_write_default();
+    grid_point24x26.param_set_and_write_default();
+    grid_point25x27.param_set_and_write_default();
+    grid_point28x30.param_set_and_write_default();
+    grid_point29x31.param_set_and_write_default();
+    grid_point32x33x34x35.param_set_and_write_default();
+    //todo:this hack is only to reposition the knots on reser grid button
+    //Better update path effect in LPEITEM
+    SPDesktop * desktop = inkscape_active_desktop();
+    tools_switch(desktop, TOOLS_SELECT);
+    tools_switch(desktop, TOOLS_NODES);
+}
+
+void
+LPELattice2::resetDefaults(SPItem const* item)
+{
+    Effect::resetDefaults(item);
+    original_bbox(SP_LPE_ITEM(item));
+    setDefaults();
+    resetGrid();
+}
+
+void
+LPELattice2::calculateCurve(Geom::Point a,Geom::Point b, SPCurve* c, bool horizontal, bool move)
+{
+    using Geom::X;
+    using Geom::Y;
+    if(move) c->moveto(a);
+    Geom::Point cubic1 = a + (1./3)* (b - a);
+    Geom::Point cubic2 = b + (1./3)* (a - b);
+    if(horizontal) c->curveto(Geom::Point(cubic1[X],a[Y]),Geom::Point(cubic2[X],b[Y]),b);
+    else c->curveto(Geom::Point(a[X],cubic1[Y]),Geom::Point(b[X],cubic2[Y]),b);
+}
+
+void
+LPELattice2::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
+{
+    hp_vec.clear();
+
+    SPCurve *c = new SPCurve();
+    calculateCurve(grid_point0,grid_point4, c,true, true);
+    calculateCurve(grid_point4,grid_point8x9, c,true, false);
+    calculateCurve(grid_point8x9,grid_point5, c,true, false);
+    calculateCurve(grid_point5,grid_point1, c,true, false);
+
+    calculateCurve(grid_point12,grid_point16, c,true, true);
+    calculateCurve(grid_point16,grid_point20x21, c,true, false);
+    calculateCurve(grid_point20x21,grid_point17, c,true, false);
+    calculateCurve(grid_point17,grid_point13, c,true, false);
+
+    calculateCurve(grid_point24x26,grid_point28x30, c,true, true);
+    calculateCurve(grid_point28x30,grid_point32x33x34x35, c,true, false);
+    calculateCurve(grid_point32x33x34x35,grid_point29x31, c,true, false);
+    calculateCurve(grid_point29x31,grid_point25x27, c,true, false);
+
+    calculateCurve(grid_point14,grid_point18, c,true, true);
+    calculateCurve(grid_point18,grid_point22x23, c,true, false);
+    calculateCurve(grid_point22x23,grid_point19, c,true, false);
+    calculateCurve(grid_point19,grid_point15, c,true, false);
+
+    calculateCurve(grid_point2,grid_point6, c,true, true);
+    calculateCurve(grid_point6,grid_point10x11, c,true, false);
+    calculateCurve(grid_point10x11,grid_point7, c,true, false);
+    calculateCurve(grid_point7,grid_point3, c,true, false);
+
+    calculateCurve(grid_point0,grid_point12, c,false, true);
+    calculateCurve(grid_point12,grid_point24x26, c,false, false);
+    calculateCurve(grid_point24x26,grid_point14, c,false, false);
+    calculateCurve(grid_point14,grid_point2, c,false, false);
+
+    calculateCurve(grid_point4,grid_point16, c,false, true);
+    calculateCurve(grid_point16,grid_point28x30, c,false, false);
+    calculateCurve(grid_point28x30,grid_point18, c,false, false);
+    calculateCurve(grid_point18,grid_point6, c,false, false);
+
+    calculateCurve(grid_point8x9,grid_point20x21, c,false, true);
+    calculateCurve(grid_point20x21,grid_point32x33x34x35, c,false, false);
+    calculateCurve(grid_point32x33x34x35,grid_point22x23, c,false, false);
+    calculateCurve(grid_point22x23,grid_point10x11, c,false, false);
+
+    calculateCurve(grid_point5,grid_point17, c, false, true);
+    calculateCurve(grid_point17,grid_point29x31, c,false, false);
+    calculateCurve(grid_point29x31,grid_point19, c,false, false);
+    calculateCurve(grid_point19,grid_point7, c,false, false);
+
+    calculateCurve(grid_point1,grid_point13, c, false, true);
+    calculateCurve(grid_point13,grid_point25x27, c,false, false);
+    calculateCurve(grid_point25x27,grid_point15, c,false, false);
+    calculateCurve(grid_point15,grid_point3, c, false, false);
+    hp_vec.push_back(c->get_pathvector());
+}
+
+
+/* ######################## */
+
+} //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/lpe-lattice2.h'
--- src/live_effects/lpe-lattice2.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-lattice2.h	2014-05-13 06:54:02 +0000
@@ -0,0 +1,92 @@
+#ifndef INKSCAPE_LPE_LATTICE2_H
+#define INKSCAPE_LPE_LATTICE2_H
+
+/** \file
+ * LPE <lattice2> implementation, see lpe-lattice2.cpp.
+ */
+
+/*
+ * Authors:
+ *   Johan Engelen
+ *   Steren Giannini
+ *   Noé Falzon
+ *   Victor Navez
+ *   ~suv
+ *   Jabiertxo Arraiza
+*
+* Copyright (C) Johan Engelen 2007 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/parameter/enum.h"
+#include "live_effects/effect.h"
+#include "live_effects/parameter/pointreseteable.h"
+#include "live_effects/lpegroupbbox.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+class LPELattice2 : public Effect, GroupBBoxEffect {
+public:
+
+    LPELattice2(LivePathEffectObject *lpeobject);
+    virtual ~LPELattice2();
+
+    virtual Geom::Piecewise<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
+    
+    virtual void resetDefaults(SPItem const* item);
+
+    virtual void doBeforeEffect(SPLPEItem const* lpeitem);
+
+    virtual Gtk::Widget * newWidget();
+
+    virtual void calculateCurve(Geom::Point a,Geom::Point b, SPCurve *c, bool horizontal, bool move);
+
+    virtual void setDefaults();
+
+    virtual void resetGrid();
+
+    //virtual void original_bbox(SPLPEItem const* lpeitem, bool absolute = false);
+
+    //virtual void addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector<Geom::PathVector> &/*hp_vec*/);
+
+    //virtual std::vector<Geom::PathVector> getHelperPaths(SPLPEItem const* lpeitem);
+protected:
+    void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
+private:
+
+    PointReseteableParam grid_point0;
+    PointReseteableParam grid_point1;
+    PointReseteableParam grid_point2;
+    PointReseteableParam grid_point3;
+    PointReseteableParam grid_point4;
+    PointReseteableParam grid_point5;
+    PointReseteableParam grid_point6;
+    PointReseteableParam grid_point7;
+    PointReseteableParam grid_point8x9;
+    PointReseteableParam grid_point10x11;
+    PointReseteableParam grid_point12;
+    PointReseteableParam grid_point13;
+    PointReseteableParam grid_point14;
+    PointReseteableParam grid_point15;
+    PointReseteableParam grid_point16;
+    PointReseteableParam grid_point17;
+    PointReseteableParam grid_point18;
+    PointReseteableParam grid_point19;
+    PointReseteableParam grid_point20x21;
+    PointReseteableParam grid_point22x23;
+    PointReseteableParam grid_point24x26;
+    PointReseteableParam grid_point25x27;
+    PointReseteableParam grid_point28x30;
+    PointReseteableParam grid_point29x31;
+    PointReseteableParam grid_point32x33x34x35; 
+
+    LPELattice2(const LPELattice2&);
+    LPELattice2& operator=(const LPELattice2&);
+};
+
+} //namespace LivePathEffect
+} //namespace Inkscape
+
+#endif

=== 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-05-13 06:54:02 +0000
@@ -11,6 +11,8 @@
 	live_effects/parameter/random.h	\
 	live_effects/parameter/point.cpp	\
 	live_effects/parameter/point.h	\
+	live_effects/parameter/pointreseteable.cpp	\
+	live_effects/parameter/pointreseteable.h	\
 	live_effects/parameter/enum.h	\
 	live_effects/parameter/path-reference.cpp	\
 	live_effects/parameter/path-reference.h	\

=== added file 'src/live_effects/parameter/pointreseteable.cpp'
--- src/live_effects/parameter/pointreseteable.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/pointreseteable.cpp	2014-05-13 06:54:02 +0000
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) Johan Engelen 2007 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "ui/widget/registered-widget.h"
+#include "live_effects/parameter/pointreseteable.h"
+#include "live_effects/effect.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "ui/widget/point.h"
+#include "widgets/icon.h"
+#include "inkscape.h"
+#include "verbs.h"
+#include "knotholder.h"
+#include <glibmm/i18n.h>
+#include "tools-switch.h"
+#include "ui/tools/node-tool.h"
+
+// needed for on-canvas editting:
+#include "desktop.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+PointReseteableParam::PointReseteableParam( const Glib::ustring& label, const Glib::ustring& tip,
+                        const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
+                        Effect* effect, const gchar *htip, Geom::Point default_value)
+    : Geom::Point(default_value), Parameter(label, tip, key, wr, effect), defvalue(default_value)
+{
+    knot_shape = SP_KNOT_SHAPE_DIAMOND;
+    knot_mode  = SP_KNOT_MODE_XOR;
+    knot_color = 0xffffff00;
+    handle_tip = g_strdup(htip);
+}
+
+PointReseteableParam::~PointReseteableParam()
+{
+    if (handle_tip)
+        g_free(handle_tip);
+}
+
+void
+PointReseteableParam::param_set_default()
+{
+    param_setValue(defvalue);
+}
+
+void
+PointReseteableParam::param_set_and_write_default()
+{
+    param_set_and_write_new_value(defvalue);
+}
+
+void
+PointReseteableParam::param_update_default(Geom::Point newpoint)
+{
+    this->defvalue = newpoint;
+}
+
+bool
+PointReseteableParam::param_readSVGValue(const gchar * strvalue)
+{
+    gchar ** strarray = g_strsplit(strvalue, ",", 2);
+    double newx, newy;
+    unsigned int success = sp_svg_number_read_d(strarray[0], &newx);
+    success += sp_svg_number_read_d(strarray[1], &newy);
+    g_strfreev (strarray);
+    if (success == 2) {
+        param_setValue( Geom::Point(newx, newy) );
+        return true;
+    }
+    return false;
+}
+
+gchar *
+PointReseteableParam::param_getSVGValue() const
+{
+    Inkscape::SVGOStringStream os;
+    os << *dynamic_cast<Geom::Point const *>( this );
+    gchar * str = g_strdup(os.str().c_str());
+    return str;
+}
+
+Gtk::Widget *
+PointReseteableParam::param_newWidget()
+{
+    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;
+    Geom::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
+PointReseteableParam::param_setValue(Geom::Point newpoint)
+{
+    *dynamic_cast<Geom::Point *>( this ) = newpoint;
+    if(SP_ACTIVE_DESKTOP){
+        SPDesktop* desktop = SP_ACTIVE_DESKTOP;
+        if (tools_isactive( desktop, TOOLS_NODES)) {
+            Inkscape::UI::Tools::NodeTool *nt = static_cast<Inkscape::UI::Tools::NodeTool*>( desktop->event_context);
+            nt->update_helperpath();
+        }
+    }
+}
+
+void
+PointReseteableParam::param_set_and_write_new_value (Geom::Point newpoint)
+{
+    Inkscape::SVGOStringStream os;
+    os << newpoint;
+    gchar * str = g_strdup(os.str().c_str());
+    param_write_to_repr(str);
+    g_free(str);
+}
+
+void
+PointReseteableParam::param_transform_multiply(Geom::Affine const& postmul, bool /*set*/)
+{
+    param_set_and_write_new_value( (*this) * postmul );
+}
+
+
+void
+PointReseteableParam::set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color)
+{
+    knot_shape = shape;
+    knot_mode  = mode;
+    knot_color = color;
+}
+
+class PointReseteableParamKnotHolderEntity : public KnotHolderEntity {
+public:
+    PointReseteableParamKnotHolderEntity(PointReseteableParam *p) { this->pparam = p; }
+    virtual ~PointReseteableParamKnotHolderEntity() {}
+
+    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);
+
+private:
+    PointReseteableParam *pparam;
+};
+
+void
+PointReseteableParamKnotHolderEntity::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
+{
+    Geom::Point const s = snap_knot_position(p, state);
+    pparam->param_setValue(s);
+    sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+}
+
+Geom::Point
+PointReseteableParamKnotHolderEntity::knot_get() const
+{
+    return *pparam;
+}
+
+void
+PointReseteableParamKnotHolderEntity::knot_click(guint state)
+{
+    if (state & GDK_CONTROL_MASK) {
+            if (state & GDK_MOD1_MASK) {
+                this->pparam->param_set_default();
+                sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+            }
+    }
+}
+
+void
+PointReseteableParam::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+{
+    PointReseteableParamKnotHolderEntity *e = new PointReseteableParamKnotHolderEntity(this);
+    // TODO: can we ditch handleTip() etc. because we have access to handle_tip etc. itself???
+    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), knot_shape, knot_mode, knot_color);
+    knotholder->add(e);
+}
+
+} /* 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/pointreseteable.h'
--- src/live_effects/parameter/pointreseteable.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/pointreseteable.h	2014-05-13 06:54:02 +0000
@@ -0,0 +1,74 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_POINT_RESETEABLE_H
+#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_POINT_RESETEABLE_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ *
+* Copyright (C) Johan Engelen 2007 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glib.h>
+#include <2geom/point.h>
+
+#include "live_effects/parameter/parameter.h"
+
+#include "knot-holder-entity.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+class PointReseteableParamKnotHolderEntity;
+
+class PointReseteableParam : public Geom::Point, public Parameter {
+public:
+    PointReseteableParam( const Glib::ustring& label,
+                const Glib::ustring& tip,
+                const Glib::ustring& key,
+                Inkscape::UI::Widget::Registry* wr,
+                Effect* effect,
+                const gchar *handle_tip = NULL,
+		Geom::Point default_value = Geom::Point(0,0) ); // tip for automatically associated on-canvas handle
+    virtual ~PointReseteableParam();
+
+    virtual Gtk::Widget * param_newWidget();
+
+    bool param_readSVGValue(const gchar * strvalue);
+    gchar * param_getSVGValue() const;
+    inline const gchar *handleTip() const { return handle_tip ? handle_tip : param_tooltip.c_str(); }
+
+    void param_setValue(Geom::Point newpoint);
+    void param_set_default();
+    void param_set_and_write_default();
+    void param_update_default(Geom::Point newpoint);
+
+    void param_set_and_write_new_value(Geom::Point newpoint);
+
+    virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/);
+
+    void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
+
+    virtual bool providesKnotHolderEntities() const { return true; }
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+
+    friend class PointReseteableParamKnotHolderEntity;
+private:
+    PointReseteableParam(const PointReseteableParam&);
+    PointReseteableParam& operator=(const PointReseteableParam&);
+
+    Geom::Point defvalue;
+
+    SPKnotShapeType knot_shape;
+    SPKnotModeType knot_mode;
+    guint32 knot_color;
+    gchar *handle_tip;
+};
+
+
+} //namespace LivePathEffect
+
+} //namespace Inkscape
+
+#endif

=== modified file 'src/ui/tools/node-tool.cpp'
--- src/ui/tools/node-tool.cpp	2014-03-27 01:33:44 +0000
+++ src/ui/tools/node-tool.cpp	2014-05-13 06:54:02 +0000
@@ -23,6 +23,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,10 @@
         this->desktop->remove_temporary_canvasitem(this->flash_tempitem);
     }
 
+    if (this->helperpath_tmpitem) {
+        this->desktop->remove_temporary_canvasitem(this->helperpath_tmpitem);
+    }
+
     this->_selection_changed_connection.disconnect();
     //this->_selection_modified_connection.disconnect();
     this->_mouseover_changed_connection.disconnect();
@@ -252,6 +258,7 @@
     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");
@@ -278,6 +285,41 @@
     }
 
     this->desktop->emitToolSubselectionChanged(NULL); // sets the coord entry fields to inactive
+    this->update_helperpath();
+}
+
+void  NodeTool::update_helperpath(){
+    Inkscape::Selection *selection = sp_desktop_selection (this->desktop);
+    if (this->helperpath_tmpitem) {
+        this->desktop->remove_temporary_canvasitem(this->helperpath_tmpitem);
+        this->helperpath_tmpitem = NULL;
+    }
+    if (SP_IS_LPE_ITEM(selection->singleItem())) {
+        Inkscape::LivePathEffect::Effect *lpe = SP_LPE_ITEM(selection->singleItem())->getCurrentLPE();
+        if (lpe && lpe->isVisible()/* && lpe->showOrigPath()*/) {
+            if (lpe) {
+                SPCurve *c = new SPCurve();
+                SPCurve *cc = new SPCurve();
+                std::vector<Geom::PathVector> cs = lpe->getCanvasIndicators(SP_LPE_ITEM(selection->singleItem()));
+                for (std::vector<Geom::PathVector>::iterator p = cs.begin(); p != cs.end(); ++p) {
+                    cc->set_pathvector(*p);
+                    c->append(cc, false);
+                    cc->reset();
+                }
+                if (!c->is_empty()) {
+                    c->transform(selection->singleItem()->i2dt_affine());
+                    SPCanvasItem *helperpath = sp_canvas_bpath_new(sp_desktop_tempgroup(this->desktop), c);
+                    sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(helperpath),
+                       0x0000ff9A, 1.0,
+                        SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+                    sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(helperpath), 0, SP_WIND_RULE_NONZERO);
+                    this->helperpath_tmpitem = this->desktop->add_temporary_canvasitem(helperpath,0);
+                }
+                c->unref();
+                cc->unref();
+           }
+        }
+    }
 }
 
 void NodeTool::set(const Inkscape::Preferences::Entry& value) {
@@ -392,7 +434,7 @@
     for (std::set<ShapeRecord>::iterator i = shapes.begin(); i != shapes.end(); ++i) {
         ShapeRecord const &r = *i;
 
-        if ((SP_IS_SHAPE(r.item) || SP_IS_TEXT(r.item)) &&
+        if ((SP_IS_SHAPE(r.item) || SP_IS_TEXT(r.item) || SP_IS_GROUP(r.item) || SP_IS_OBJECTGROUP(r.item)) &&
             this->_shape_editors.find(r.item) == this->_shape_editors.end())
         {
             ShapeEditor *si = new ShapeEditor(this->desktop);
@@ -416,7 +458,7 @@
     
     Inkscape::Selection *selection = desktop->selection;
     static Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    
+
     if (this->_multipath->event(this, event)) {
     	return true;
     }
@@ -433,6 +475,7 @@
     {
     case GDK_MOTION_NOTIFY: {
         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);
 
@@ -441,7 +484,6 @@
             //ink_node_tool_update_tip(nt, event);
             this->update_tip(event);
         }
-
         // create pathflash outline
         if (prefs->getBool("/tools/nodes/pathflash_enabled")) {
             if (over_item == this->flashed_item) {

=== modified file 'src/ui/tools/node-tool.h'
--- src/ui/tools/node-tool.h	2014-03-27 01:33:44 +0000
+++ src/ui/tools/node-tool.h	2014-05-13 06:54:02 +0000
@@ -51,6 +51,7 @@
 	static const std::string prefsPath;
 
 	virtual void setup();
+	virtual void update_helperpath();
 	virtual void set(const Inkscape::Preferences::Entry& val);
 	virtual bool root_handler(GdkEvent* event);
 
@@ -63,6 +64,7 @@
 
     SPItem *flashed_item;
     Inkscape::Display::TemporaryItem *flash_tempitem;
+    Inkscape::Display::TemporaryItem *helperpath_tmpitem;
     Inkscape::UI::Selector* _selector;
     Inkscape::UI::PathSharedData* _path_data;
     SPCanvasGroup *_transform_handle_group;