Fix for bug #1715433 Clone original LPE can no longer be used to fill a powerstroke path

13 files changed, 164 insertions, 277 deletions

diff --git a/src/live_effects/lpe-clone-original.cpp b/src/live_effects/lpe-clone-original.cpp
index e72735370..b035cc1d0 100644
--- a/src/live_effects/lpe-clone-original.cpp
+++ b/src/live_effects/lpe-clone-original.cpp
@@ -5,6 +5,10 @@
  */
 
 #include "live_effects/lpe-clone-original.h"
+#include "live_effects/lpe-spiro.h"
+#include "live_effects/lpe-bspline.h"
+#include "live_effects/lpeobject.h"
+#include "live_effects/lpeobject-reference.h"
 #include "display/curve.h"
 #include "svg/path-string.h"
 #include "svg/svg.h"
@@ -18,59 +22,45 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
+static const Util::EnumData<Clonelpemethod> ClonelpemethodData[] = {
+    { CLM_NONE, N_("No shape"), "none" },
+    { CLM_ORIGINALD, N_("Without LPE's"), "originald" }, 
+    { CLM_BSPLINESPIRO, N_("With Spiro or BSpline"), "bsplinespiro" },
+    { CLM_D, N_("With LPE's"), "d" }
+};
+static const Util::EnumDataConverter<Clonelpemethod> CLMConverter(ClonelpemethodData, CLM_END);
+
 LPECloneOriginal::LPECloneOriginal(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     linkeditem(_("Linked Item:"), _("Item from which to take the original data"), "linkeditem", &wr, this),
-    scale(_("Scale %"), _("Scale item %"), "scale", &wr, this, 100.0),
-    preserve_position(_("Preserve position"), _("Preserve position"), "preserve_position", &wr, this, false),
-    inverse(_("Inverse clone"), _("Use LPE item as origin"), "inverse", &wr, this, false),
-    d(_("Clone shape -d-"), _("Clone shape -d-"), "d", &wr, this, true),
-    transform(_("Clone transforms"), _("Clone transforms"), "transform", &wr, this, true),
-    fill(_("Clone fill"), _("Clone fill"), "fill", &wr, this, false),
-    stroke(_("Clone stroke"), _("Clone stroke"), "stroke", &wr, this, false),
-    paintorder(_("Clone paint order"), _("Clone paint order"), "paintorder", &wr, this, false),
-    opacity(_("Clone opacity"), _("Clone opacity"), "opacity", &wr, this, false),
-    filter(_("Clone filter"), _("Clone filter"), "filter", &wr, this, false),
+    method(_("Shape linked"), _("Shape linked"), "method", CLMConverter, &wr, this, CLM_D),
     attributes("Attributes linked", "Attributes linked, comma separated atributes", "attributes", &wr, this,""),
-    style_attributes("Style attributes linked", "Style attributes linked, comma separated atributes", "style_attributes", &wr, this,""),
-    expanded(false),
-    origin(Geom::Point(0,0))
+    style_attributes("Style attributes linked", "Style attributes linked, comma separated attributes like fill, filter, opacity", "style_attributes", &wr, this,""),
+    allow_transforms(_("Alow transforms"), _("Alow transforms"), "allow_transforms", &wr, this, true)
 {
     //0.92 compatibility
     const gchar * linkedpath = this->getRepr()->attribute("linkedpath");
     if (linkedpath && strcmp(linkedpath, "") != 0){
         this->getRepr()->setAttribute("linkeditem", linkedpath);
         this->getRepr()->setAttribute("linkedpath", NULL);
-        this->getRepr()->setAttribute("transform", "false");
+        this->getRepr()->setAttribute("method", "bsplinespiro");
+        this->getRepr()->setAttribute("allow_transforms", "false");
     };
 
     registerParameter(&linkeditem);
-    registerParameter(&scale);
+    registerParameter(&method);
     registerParameter(&attributes);
     registerParameter(&style_attributes);
-    registerParameter(&preserve_position);
-    registerParameter(&inverse);
-    registerParameter(&d);
-    registerParameter(&transform);
-    registerParameter(&fill);
-    registerParameter(&stroke);
-    registerParameter(&paintorder);
-    registerParameter(&opacity);
-    registerParameter(&filter);
-    scale.param_set_range(0.01, 999999.0);
-    scale.param_set_increments(1, 1);
-    scale.param_set_digits(2);
+    registerParameter(&allow_transforms);
     attributes.param_hide_canvas_text();
     style_attributes.param_hide_canvas_text();
-    preserve_position_changed = preserve_position;
-    preserve_affine = Geom::identity();
 }
 
 void
-LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, const char * attributes, const char * style_attributes, bool root) 
+LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, const char * attributes, const char * style_attributes) 
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
-    if (!document) {
+    if (!document || !origin || !dest) {
         return;
     }
     if ( SP_IS_GROUP(origin) && SP_IS_GROUP(dest) && SP_GROUP(origin)->getItemCount() == SP_GROUP(dest)->getItemCount() ) {
@@ -79,7 +69,7 @@ LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, co
         for (std::vector<SPObject * >::iterator obj_it = childs.begin(); 
              obj_it != childs.end(); ++obj_it) {
             SPObject *dest_child = dest->nthChild(index); 
-            cloneAttrbutes((*obj_it), dest_child, live, attributes, style_attributes, false); 
+            cloneAttrbutes((*obj_it), dest_child, attributes, style_attributes); 
             index++;
         }
     }
@@ -97,7 +87,7 @@ LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, co
             for ( std::vector<SPObject*>::const_iterator iter=mask_list.begin();iter!=mask_list.end();++iter) {
                 SPObject * mask_data = *iter;
                 SPObject * mask_dest_data = mask_list_dest[i];
-                cloneAttrbutes(mask_data, mask_dest_data, live, attributes, style_attributes, false);
+                cloneAttrbutes(mask_data, mask_dest_data, attributes, style_attributes);
                 i++;
             }
         }
@@ -112,86 +102,60 @@ LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, co
             for ( std::vector<SPObject*>::const_iterator iter=clippath_list.begin();iter!=clippath_list.end();++iter) {
                 SPObject * clippath_data = *iter;
                 SPObject * clippath_dest_data = clippath_list_dest[i];
-                cloneAttrbutes(clippath_data, clippath_dest_data, live, attributes, style_attributes, false);
+                cloneAttrbutes(clippath_data, clippath_dest_data, attributes, style_attributes);
                 i++;
             }
         }
     }
     gchar ** attarray = g_strsplit(attributes, ",", 0);
     gchar ** iter = attarray;
-    Geom::Affine affine_dest = Geom::identity();
-    Geom::Affine affine_origin = Geom::identity();
-    Geom::Affine affine_previous = Geom::identity();
-    sp_svg_transform_read(SP_ITEM(dest)->getAttribute("transform"), &affine_dest);
-    sp_svg_transform_read(SP_ITEM(origin)->getAttribute("transform"), &affine_origin);
     while (*iter != NULL) {
         const char* attribute = (*iter);
-        if ( std::strcmp(attribute, "transform") == 0 ) {
-            if (preserve_position) {
-                Geom::Affine dest_affine = Geom::identity();
-                if (root) {
-                    dest_affine *= affine_origin;
-                    if (preserve_affine == Geom::identity()) {
-                        dest_affine *= Geom::Translate(affine_dest.translation());
+        if (strlen(attribute)) {
+            if ( shape_dest && shape_origin && (std::strcmp(attribute, "d") == 0)) {
+                SPCurve *c = NULL;
+                if (method == CLM_BSPLINESPIRO) {
+                    c = shape_origin->getCurveBeforeLPE();
+                    SPLPEItem * lpe_item = SP_LPE_ITEM(origin);
+                    if (lpe_item) {
+                        PathEffectList lpelist = lpe_item->getEffectList();
+                        PathEffectList::iterator i;
+                        for (i = lpelist.begin(); i != lpelist.end(); ++i) {
+                            LivePathEffectObject *lpeobj = (*i)->lpeobject;
+                            if (lpeobj) {
+                                Inkscape::LivePathEffect::Effect *lpe = lpeobj->get_lpe();
+                                if (dynamic_cast<Inkscape::LivePathEffect::LPEBSpline *>(lpe)) {
+                                    LivePathEffect::sp_bspline_do_effect(c, 0);
+                                } else if (dynamic_cast<Inkscape::LivePathEffect::LPESpiro *>(lpe)) {
+                                    LivePathEffect::sp_spiro_do_effect(c);
+                                }
+                            }
+                        }
                     }
-                    dest_affine *= Geom::Translate(affine_origin.translation()).inverse();
-                    dest_affine *= Geom::Translate(preserve_affine.translation());
-                    affine_previous = preserve_affine;
-                    preserve_affine = Geom::identity();
-                    gchar * str = sp_svg_transform_write(dest_affine);
-                    SP_ITEM(dest)->getRepr()->setAttribute("transform", str);
-                    g_free(str);
-                }
-            } else {
-                gchar * str = sp_svg_transform_write(affine_origin);
-                SP_ITEM(dest)->getRepr()->setAttribute("transform", str);
-                g_free(str);
-            }
-        } else if ( shape_dest && shape_origin && live && (std::strcmp(attribute, "d") == 0)) {
-            SPCurve *c = NULL;
-            if (inverse) {
-                c = shape_origin->getCurveBeforeLPE();
-            } else {
-                c = shape_origin->getCurve();
-            }
-            if (c) {
-                Geom::PathVector c_pv = c->get_pathvector();
-                Geom::OptRect orig_bbox = SP_ITEM(origin)->geometricBounds();
-                Geom::OptRect dest_bbox = SP_ITEM(dest)->geometricBounds();
-                if (dest_bbox && orig_bbox && root) {
-                    Geom::Point orig_point = (*orig_bbox).corner(0);
-                    Geom::Point dest_point = (*dest_bbox).corner(0);
-                    if (scale != 100.0) {
-                        double scale_affine = scale/100.0;
-                        Geom::Scale scale = Geom::Scale(scale_affine);
-                        c_pv *= Geom::Translate(orig_point).inverse();
-                        c_pv *= scale;
-                        c_pv *= Geom::Translate(orig_point);
-                    }
-                    if (preserve_position) {
-                        c_pv *= Geom::Translate(dest_point - orig_point);
-                    }
-                }
-                if (inverse) {
-                    c_pv *= i2anc_affine(origin, sp_lpe_item);
+                } else if(method == CLM_ORIGINALD) {
+                    c = shape_origin->getCurveBeforeLPE();
                 } else {
-                    c_pv *= i2anc_affine(dest, sp_lpe_item);
+                    c = shape_origin->getCurve();
                 }
-                c->set_pathvector(c_pv);
-                if (!path_origin) {
-                    shape_dest->setCurveInsync(c, TRUE);
-                    gchar *str = sp_svg_write_path(c_pv);
-                    dest->getRepr()->setAttribute(attribute, str);
-                    g_free(str);
+                if (c) {
+                    Geom::PathVector c_pv = c->get_pathvector();
+                    c_pv *= i2anc_affine(dest, sp_lpe_item);
+                    c->set_pathvector(c_pv);
+                    if (!path_origin) {
+                        shape_dest->setCurveInsync(c, TRUE);
+                        gchar *str = sp_svg_write_path(c_pv);
+                        dest->getRepr()->setAttribute(attribute, str);
+                        g_free(str);
+                    } else {
+                        shape_dest->setCurve(c, TRUE);
+                    }
+                    c->unref();
                 } else {
-                    shape_dest->setCurve(c, TRUE);
+                    dest->getRepr()->setAttribute(attribute, NULL);
                 }
-                c->unref();
             } else {
-                dest->getRepr()->setAttribute(attribute, NULL);
+                dest->getRepr()->setAttribute(attribute, origin->getRepr()->attribute(attribute));
             }
-        } else {
-            dest->getRepr()->setAttribute(attribute, origin->getRepr()->attribute(attribute));
         }
         iter++;
     }
@@ -204,11 +168,13 @@ LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, co
     gchar ** styleiter = styleattarray;
     while (*styleiter != NULL) {
         const char* attribute = (*styleiter);
-        const char* origin_attribute = sp_repr_css_property(css_origin, attribute, "");
-        if (!strlen(origin_attribute)) { //==0
-            sp_repr_css_set_property (css_dest, attribute, NULL);
-        } else {
-            sp_repr_css_set_property (css_dest, attribute, origin_attribute);
+        if (strlen(attribute)) {
+            const char* origin_attribute = sp_repr_css_property(css_origin, attribute, "");
+            if (!strlen(origin_attribute)) { //==0
+                sp_repr_css_set_property (css_dest, attribute, NULL);
+            } else {
+                sp_repr_css_set_property (css_dest, attribute, origin_attribute);
+            }
         }
         styleiter++;
     }
@@ -221,123 +187,29 @@ LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, co
 void
 LPECloneOriginal::doBeforeEffect (SPLPEItem const* lpeitem){
     if (linkeditem.linksToItem()) {
-        linkeditem.setInsensitive(inverse);
-        if ( preserve_position_changed != preserve_position ) {
-            if (!preserve_position) {
-                sp_svg_transform_read(SP_ITEM(sp_lpe_item)->getAttribute("transform"), &preserve_affine);
-            }
-            preserve_position_changed = preserve_position;
-        }
         Glib::ustring attr = "";
-        if (d) {
+        if (method != CLM_NONE) {
             attr.append("d,");
         }
-        if (transform) {
-            attr.append("transform,");
-        }
         attr.append(Glib::ustring(attributes.param_getSVGValue()).append(","));
         if (attr.size()  && !Glib::ustring(attributes.param_getSVGValue()).size()) {
             attr.erase (attr.size()-1, 1);
         }
         Glib::ustring style_attr = "";
-        if (fill) {
-            style_attr.append("fill,").append("fill-rule,");
-        }
-        if (stroke) {
-            style_attr.append("stroke,").append("stroke-width,").append("stroke-linecap,").append("stroke-linejoin,");
-            style_attr.append("stroke-opacity,").append("stroke-miterlimit,").append("stroke-dasharray,");
-            style_attr.append("stroke-opacity,").append("stroke-dashoffset,").append("marker-start,");
-            style_attr.append("marker-mid,").append("marker-end,");
-        }
-        if (paintorder) {
-            style_attr.append("paint-order,");
-        }
-        if (filter) {
-            style_attr.append("filter,");
-        }
-        if (opacity) {
-            style_attr.append("opacity,");
-        }
         if (style_attr.size() && !Glib::ustring(style_attributes.param_getSVGValue()).size()) {
             style_attr.erase (style_attr.size()-1, 1);
         }
         style_attr.append(Glib::ustring(style_attributes.param_getSVGValue()).append(","));
 
-        SPItem * from =  inverse ? SP_ITEM(sp_lpe_item) : SP_ITEM(linkeditem.getObject()); 
-        SPItem * to   = !inverse ? SP_ITEM(sp_lpe_item) : SP_ITEM(linkeditem.getObject()); 
-        cloneAttrbutes(from, to, true, g_strdup(attr.c_str()), g_strdup(style_attr.c_str()), true);
-        Geom::OptRect bbox = from->geometricBounds();
-        if (bbox && preserve_position && origin != Geom::Point(0,0)) {
-            origin = (*bbox).corner(0) - origin;
-            to->transform *= Geom::Translate(origin);
-        }
-        bbox = from->geometricBounds();
-        if (bbox && preserve_position) {
-            origin = (*bbox).corner(0);
+        SPItem * origin =  SP_ITEM(linkeditem.getObject()); 
+        SPItem * dest   =  SP_ITEM(sp_lpe_item); 
+        cloneAttrbutes(origin, dest, g_strdup(attr.c_str()), g_strdup(style_attr.c_str()));
+        if (!allow_transforms) {
+            SP_ITEM(dest)->getRepr()->setAttribute("transform", SP_ITEM(origin)->getAttribute("transform"));
         }
     }
 }
 
-
-Gtk::Widget *
-LPECloneOriginal::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);
-    Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
-    vbox_expander->set_border_width(0);
-    vbox_expander->set_spacing(2);
-    std::vector<Parameter *>::iterator it = param_vector.begin();
-    while (it != param_vector.end()) {
-        if ((*it)->widget_is_visible) {
-            Parameter * param = *it;
-            if (param->param_key == "linkedpath") {
-                ++it;
-                continue;
-            }
-            Gtk::Widget * widg = param->param_newWidget();
-            Glib::ustring * tip = param->param_getTooltip();
-            if (widg) {
-                if (param->param_key != "attributes" &&
-                    param->param_key != "style_attributes") {
-                    vbox->pack_start(*widg, true, true, 2);
-                } else {
-                    vbox_expander->pack_start(*widg, true, true, 2);
-                }
-                if (tip) {
-                    widg->set_tooltip_text(*tip);
-                } else {
-                    widg->set_tooltip_text("");
-                    widg->set_has_tooltip(false);
-                }
-            }
-        }
-
-        ++it;
-    }
-    expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show attributes override"))));
-    expander->add(*vbox_expander);
-    expander->set_expanded(expanded);
-    expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPECloneOriginal::onExpanderChanged) );
-    vbox->pack_start(*expander, true, true, 2);
-    return dynamic_cast<Gtk::Widget *>(vbox);
-}
-
-void
-LPECloneOriginal::onExpanderChanged()
-{
-    expanded = expander->get_expanded();
-    if(expanded) {
-        expander->set_label (Glib::ustring(_("Hide attributes override")));
-    } else {
-        expander->set_label (Glib::ustring(_("Show attributes override")));
-    }
-}
-
 LPECloneOriginal::~LPECloneOriginal()
 {
 
@@ -346,15 +218,15 @@ LPECloneOriginal::~LPECloneOriginal()
 void
 LPECloneOriginal::transform_multiply(Geom::Affine const& postmul, bool set)
 {
-    if (linkeditem.linksToItem()) {
-        linkeditem.getObject()->requestModified(SP_OBJECT_MODIFIED_FLAG);
+    if (!allow_transforms && linkeditem.linksToItem()) {
+        sp_lpe_item->transform *= postmul.inverse();
     }
 }
 
 void 
 LPECloneOriginal::doEffect (SPCurve * curve)
 {
-    if (linkeditem.linksToItem() && !inverse) {
+    if (linkeditem.linksToItem()) {
         SPShape * shape = getCurrentShape();
         if(shape){
             curve->set_pathvector(shape->getCurve()->get_pathvector());
diff --git a/src/live_effects/lpe-clone-original.h b/src/live_effects/lpe-clone-original.h
index 9bab8553f..b78b144bc 100644
--- a/src/live_effects/lpe-clone-original.h
+++ b/src/live_effects/lpe-clone-original.h
@@ -10,16 +10,22 @@
  */
 #include <gtkmm/expander.h>
 #include "live_effects/effect.h"
+#include "live_effects/parameter/enum.h"
 #include "live_effects/parameter/originalitem.h"
-#include "live_effects/parameter/originalpath.h"
-#include "live_effects/parameter/parameter.h"
-#include "live_effects/parameter/point.h"
 #include "live_effects/parameter/text.h"
 #include "live_effects/lpegroupbbox.h"
 
 namespace Inkscape {
 namespace LivePathEffect {
 
+enum Clonelpemethod {
+    CLM_NONE,
+    CLM_ORIGINALD,
+    CLM_BSPLINESPIRO,
+    CLM_D,
+    CLM_END
+};
+
 class LPECloneOriginal : public Effect, GroupBBoxEffect {
 public:
     LPECloneOriginal(LivePathEffectObject *lpeobject);
@@ -27,29 +33,14 @@ public:
     virtual void doEffect (SPCurve * curve);
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
     virtual void transform_multiply(Geom::Affine const& postmul, bool set);
-    virtual Gtk::Widget * newWidget();
-    void onExpanderChanged();
-    void cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, const char * attributes, const char * style_attributes, bool root);
+    void cloneAttrbutes(SPObject *origin, SPObject *dest, const char * attributes, const char * style_attributes);
 
 private:
-    OriginalItemParam  linkeditem;
-    ScalarParam scale;
-    BoolParam preserve_position;
-    BoolParam inverse;
-    BoolParam d;
-    BoolParam transform;
-    BoolParam fill;
-    BoolParam stroke;
-    BoolParam paintorder;
-    BoolParam opacity;
-    BoolParam filter;
+    OriginalItemParam linkeditem;
+    EnumParam<Clonelpemethod> method;
     TextParam attributes;
     TextParam style_attributes;
-    Geom::Point origin;
-    bool preserve_position_changed;
-    bool expanded;
-    Gtk::Expander * expander;
-    Geom::Affine preserve_affine;
+    BoolParam allow_transforms;
     LPECloneOriginal(const LPECloneOriginal&);
     LPECloneOriginal& operator=(const LPECloneOriginal&);
 };
diff --git a/src/live_effects/lpe-fill-between-many.cpp b/src/live_effects/lpe-fill-between-many.cpp
index e380ca2dd..7e2131f76 100644
--- a/src/live_effects/lpe-fill-between-many.cpp
+++ b/src/live_effects/lpe-fill-between-many.cpp
@@ -22,16 +22,16 @@ namespace Inkscape {
 namespace LivePathEffect {
 
 static const Util::EnumData<Filllpemethod> FilllpemethodData[] = {
-    { FLM_NONE, N_("Without LPE"), "none" }, 
-    { FLM_PARTIAL, N_("Spiro/BSpline"), "partial" },
-    { FLM_ALL, N_("All LPE"), "all" }
+    { FLM_ORIGINALD, N_("Without LPE's"), "originald" }, 
+    { FLM_BSPLINESPIRO, N_("With Spiro or BSpline"), "bsplinespiro" },
+    { FLM_D, N_("With LPE's"), "d" }
 };
 static const Util::EnumDataConverter<Filllpemethod> FLMConverter(FilllpemethodData, FLM_END);
 
 LPEFillBetweenMany::LPEFillBetweenMany(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     linked_paths(_("Linked path:"), _("Paths from which to take the original path data"), "linkedpaths", &wr, this),
-    method(_("LPE's on linked:"), _("LPE's on linked"), "method", FLMConverter, &wr, this, FLM_PARTIAL),
+    method(_("LPE's on linked:"), _("LPE's on linked"), "method", FLMConverter, &wr, this, FLM_BSPLINESPIRO),
     fuse(_("Fuse coincident points"), _("Fuse coincident points"), "fuse", &wr, this, false),
     allow_transforms(_("Allow transforms"), _("Allow transforms"), "allow_transforms", &wr, this, false),
     join(_("Join subpaths"), _("Join subpaths"), "join", &wr, this, true),
@@ -104,10 +104,10 @@ void LPEFillBetweenMany::doOnApply (SPLPEItem const* lpeitem)
 void LPEFillBetweenMany::doEffect (SPCurve * curve)
 {
     if (previous_method != method) {
-        if (method == FLM_PARTIAL) {
+        if (method == FLM_BSPLINESPIRO) {
             linked_paths.allowOnlyBsplineSpiro(true);
             linked_paths.setFromOriginalD(false);
-        } else if(method == FLM_NONE) {
+        } else if(method == FLM_ORIGINALD) {
             linked_paths.allowOnlyBsplineSpiro(false);
             linked_paths.setFromOriginalD(true);
         } else {
diff --git a/src/live_effects/lpe-fill-between-many.h b/src/live_effects/lpe-fill-between-many.h
index da3a532bf..7ff998309 100644
--- a/src/live_effects/lpe-fill-between-many.h
+++ b/src/live_effects/lpe-fill-between-many.h
@@ -18,9 +18,9 @@ namespace Inkscape {
 namespace LivePathEffect {
 
 enum Filllpemethod {
-    FLM_NONE,
-    FLM_PARTIAL,
-    FLM_ALL,
+    FLM_ORIGINALD,
+    FLM_BSPLINESPIRO,
+    FLM_D,
     FLM_END
 };
 
diff --git a/src/live_effects/parameter/originalitemarray.cpp b/src/live_effects/parameter/originalitemarray.cpp
index fddbfe4ce..24b002e18 100644
--- a/src/live_effects/parameter/originalitemarray.cpp
+++ b/src/live_effects/parameter/originalitemarray.cpp
@@ -44,13 +44,13 @@ public:
     {
         add(_colObject);
         add(_colLabel);
-        add(_colActived);
+        add(_colActive);
     }
     virtual ~ModelColumns() {}
 
     Gtk::TreeModelColumn<ItemAndActive*> _colObject;
     Gtk::TreeModelColumn<Glib::ustring> _colLabel;
-    Gtk::TreeModelColumn<bool> _colActived;
+    Gtk::TreeModelColumn<bool> _colActive;
 };
 
 OriginalItemArrayParam::OriginalItemArrayParam( const Glib::ustring& label,
@@ -62,7 +62,7 @@ OriginalItemArrayParam::OriginalItemArrayParam( const Glib::ustring& label,
         _vector(),
         _tree(),
         _text_renderer(),
-        _toggle_renderer(),
+        _toggle_active(),
         _scroller()
 {    
     _model = new ModelColumns();
@@ -72,12 +72,12 @@ OriginalItemArrayParam::OriginalItemArrayParam( const Glib::ustring& label,
     _tree.set_reorderable(true);
     _tree.enable_model_drag_dest (Gdk::ACTION_MOVE);
     
-    Gtk::CellRendererToggle * _toggle_renderer = manage(new Gtk::CellRendererToggle());
-    int toggleColNum = _tree.append_column(_("Active"), *_toggle_renderer) - 1;
-    Gtk::TreeViewColumn* col = _tree.get_column(toggleColNum);
-    _toggle_renderer->set_activatable(true);
-    _toggle_renderer->signal_toggled().connect(sigc::mem_fun(*this, &OriginalItemArrayParam::on_active_toggled));
-    col->add_attribute(_toggle_renderer->property_active(), _model->_colActived);
+    Gtk::CellRendererToggle * _toggle_active = manage(new Gtk::CellRendererToggle());
+    int activeColNum = _tree.append_column(_("Active"), *_toggle_active) - 1;
+    Gtk::TreeViewColumn* col_active = _tree.get_column(activeColNum);
+    _toggle_active->set_activatable(true);
+    _toggle_active->signal_toggled().connect(sigc::mem_fun(*this, &OriginalItemArrayParam::on_active_toggled));
+    col_active->add_attribute(_toggle_active->property_active(), _model->_colActive);
     
     _text_renderer = manage(new Gtk::CellRendererText());
     int nameColNum = _tree.append_column(_("Name"), *_text_renderer) - 1;
@@ -113,8 +113,8 @@ void OriginalItemArrayParam::on_active_toggled(const Glib::ustring& item)
     Gtk::TreeModel::iterator iter = _store->get_iter(item);
     Gtk::TreeModel::Row row = *iter;
     ItemAndActive *w = row[_model->_colObject];
-    row[_model->_colActived] = !row[_model->_colActived];
-    w->actived = row[_model->_colActived];
+    row[_model->_colActive] = !row[_model->_colActive];
+    w->actived = row[_model->_colActive];
     
     gchar * full = param_getSVGValue();
     param_write_to_repr(full);
@@ -416,7 +416,7 @@ bool OriginalItemArrayParam::param_readSVGValue(const gchar* strvalue)
 
                 row[_model->_colObject] = w;
                 row[_model->_colLabel] = obj ? ( obj->label() ? obj->label() : obj->getId() ) : w->href;
-                row[_model->_colActived] = w->actived;
+                row[_model->_colActive] = w->actived;
                 g_strfreev (substrarray);
             }
         }
@@ -442,6 +442,14 @@ gchar * OriginalItemArrayParam::param_getSVGValue() const
     return str;
 }
 
+void OriginalItemArrayParam::update()
+{
+    for (std::vector<ItemAndActive*>::iterator iter = _vector.begin(); iter != _vector.end(); ++iter) {
+        SPObject *linked_obj = (*iter)->ref.getObject();
+        linked_modified(linked_obj, SP_OBJECT_MODIFIED_FLAG, *iter);
+    }
+}
+
 } /* namespace LivePathEffect */
 
 } /* namespace Inkscape */
diff --git a/src/live_effects/parameter/originalitemarray.h b/src/live_effects/parameter/originalitemarray.h
index 3b300bd25..f600aba34 100644
--- a/src/live_effects/parameter/originalitemarray.h
+++ b/src/live_effects/parameter/originalitemarray.h
@@ -87,7 +87,7 @@ protected:
     Glib::RefPtr<Gtk::TreeStore> _store;
     Gtk::TreeView _tree;
     Gtk::CellRendererText *_text_renderer;
-    Gtk::CellRendererToggle *_toggle_renderer;
+    Gtk::CellRendererToggle *_toggle_active;
     Gtk::TreeView::Column *_name_column;
     Gtk::ScrolledWindow _scroller;
     
@@ -95,9 +95,10 @@ protected:
     void on_remove_button_click();
     void on_up_button_click();
     void on_down_button_click();
-    void on_active_toggled(const Glib::ustring& actived);
+    void on_active_toggled(const Glib::ustring& item);
     
 private:
+    void update();
     OriginalItemArrayParam(const OriginalItemArrayParam&);
     OriginalItemArrayParam& operator=(const OriginalItemArrayParam&);
 };
diff --git a/src/live_effects/parameter/originalpatharray.cpp b/src/live_effects/parameter/originalpatharray.cpp
index 8ac07b98f..d67f08e5b 100644
--- a/src/live_effects/parameter/originalpatharray.cpp
+++ b/src/live_effects/parameter/originalpatharray.cpp
@@ -73,7 +73,7 @@ OriginalPathArrayParam::OriginalPathArrayParam( const Glib::ustring& label,
         _vector(),
         _tree(),
         _text_renderer(),
-        _toggle_renderer(),
+        _toggle_reverse(),
         _toggle_visible(),
         _scroller()
 {    
@@ -85,20 +85,20 @@ OriginalPathArrayParam::OriginalPathArrayParam( const Glib::ustring& label,
     _tree.enable_model_drag_dest (Gdk::ACTION_MOVE);
     
     
-    Gtk::CellRendererToggle * _toggle_renderer = manage(new Gtk::CellRendererToggle());
-    int toggleColNum = _tree.append_column(_("Reverse"), *_toggle_renderer) - 1;
-    Gtk::TreeViewColumn* col = _tree.get_column(toggleColNum);
-    _toggle_renderer->set_activatable(true);
-    _toggle_renderer->signal_toggled().connect(sigc::mem_fun(*this, &OriginalPathArrayParam::on_reverse_toggled));
-    col->add_attribute(_toggle_renderer->property_active(), _model->_colReverse);
+    Gtk::CellRendererToggle * _toggle_reverse = manage(new Gtk::CellRendererToggle());
+    int reverseColNum = _tree.append_column(_("Reverse"), *_toggle_reverse) - 1;
+    Gtk::TreeViewColumn* col_reverse = _tree.get_column(reverseColNum);
+    _toggle_reverse->set_activatable(true);
+    _toggle_reverse->signal_toggled().connect(sigc::mem_fun(*this, &OriginalPathArrayParam::on_reverse_toggled));
+    col_reverse->add_attribute(_toggle_reverse->property_active(), _model->_colReverse);
     
 
     Gtk::CellRendererToggle * _toggle_visible = manage(new Gtk::CellRendererToggle());
-    int toggleColNum2 = _tree.append_column(_("Visible"), *_toggle_visible) - 1;
-    Gtk::TreeViewColumn* col2 = _tree.get_column(toggleColNum2);
+    int visibleColNum = _tree.append_column(_("Visible"), *_toggle_visible) - 1;
+    Gtk::TreeViewColumn* col_visible = _tree.get_column(visibleColNum);
     _toggle_visible->set_activatable(true);
     _toggle_visible->signal_toggled().connect(sigc::mem_fun(*this, &OriginalPathArrayParam::on_visible_toggled));
-    col2->add_attribute(_toggle_visible->property_active(), _model->_colVisible);
+    col_visible->add_attribute(_toggle_visible->property_active(), _model->_colVisible);
     
     _text_renderer = manage(new Gtk::CellRendererText());
     int nameColNum = _tree.append_column(_("Name"), *_text_renderer) - 1;
diff --git a/src/live_effects/parameter/originalpatharray.h b/src/live_effects/parameter/originalpatharray.h
index cffa2911f..0ba6984c2 100644
--- a/src/live_effects/parameter/originalpatharray.h
+++ b/src/live_effects/parameter/originalpatharray.h
@@ -93,7 +93,7 @@ protected:
     Glib::RefPtr<Gtk::TreeStore> _store;
     Gtk::TreeView _tree;
     Gtk::CellRendererText *_text_renderer;
-    Gtk::CellRendererToggle *_toggle_renderer;
+    Gtk::CellRendererToggle *_toggle_reverse;
     Gtk::CellRendererToggle *_toggle_visible;
     Gtk::TreeView::Column *_name_column;
     Gtk::ScrolledWindow _scroller;
diff --git a/src/selection-chemistry.cpp b/src/selection-chemistry.cpp
index 9e0298f6a..807c8f7e1 100644
--- a/src/selection-chemistry.cpp
+++ b/src/selection-chemistry.cpp
@@ -2911,10 +2911,12 @@ void ObjectSet::cloneOriginalPathLPE(bool allow_transforms)
     Inkscape::SVGOStringStream os;
     SPObject * firstItem = NULL;
     auto items_= items();
+    bool multiple = false;
     for (auto i=items_.begin();i!=items_.end();++i){
         if (SP_IS_SHAPE(*i) || SP_IS_TEXT(*i)) {
             if (firstItem) {
                 os << "|";
+                multiple = true;
             } else {
                 firstItem = SP_ITEM(*i);
             }
@@ -2924,19 +2926,21 @@ void ObjectSet::cloneOriginalPathLPE(bool allow_transforms)
     if (firstItem) {
         Inkscape::XML::Document *xml_doc = document()->getReprDoc();
         SPObject *parent = firstItem->parent;
-
         // create the LPE
         Inkscape::XML::Node *lpe_repr = xml_doc->createElement("inkscape:path-effect");
-        {
+        if (multiple) {
             lpe_repr->setAttribute("effect", "fill_between_many");
             lpe_repr->setAttribute("linkedpaths", os.str());
             lpe_repr->setAttribute("applied", "true");
-            gchar const *method_str = allow_transforms ? "all" : "partial";
-            lpe_repr->setAttribute("method", method_str);
-            gchar const *allow_transforms_str = allow_transforms ? "true" : "false";
-            lpe_repr->setAttribute("allow_transforms", allow_transforms_str);
-            document()->getDefs()->getRepr()->addChild(lpe_repr, NULL); // adds to <defs> and assigns the 'id' attribute
+        } else {
+            lpe_repr->setAttribute("effect", "clone_original");
+            lpe_repr->setAttribute("linkeditem", ((Glib::ustring)"#" + (Glib::ustring)firstItem->getId()).c_str());
         }
+        gchar const *method_str = allow_transforms ?  "d" : "bsplinespiro";
+        lpe_repr->setAttribute("method", method_str);
+        gchar const *allow_transforms_str = allow_transforms ? "true" : "false";
+        lpe_repr->setAttribute("allow_transforms", allow_transforms_str);
+        document()->getDefs()->getRepr()->addChild(lpe_repr, NULL); // adds to <defs> and assigns the 'id' attribute
         std::string lpe_id_href = std::string("#") + lpe_repr->attribute("id");
         Inkscape::GC::release(lpe_repr);
 
@@ -2946,18 +2950,21 @@ void ObjectSet::cloneOriginalPathLPE(bool allow_transforms)
             clone->setAttribute("d", "M 0 0", false);
             // add the new clone to the top of the original's parent
             parent->appendChildRepr(clone);
+            // select the new object:
+            set(clone);
+            Inkscape::GC::release(clone);
             SPObject *clone_obj = document()->getObjectById(clone->attribute("id"));
             SPLPEItem *clone_lpeitem = dynamic_cast<SPLPEItem *>(clone_obj);
             if (clone_lpeitem) {
                 clone_lpeitem->addPathEffect(lpe_id_href, false);
             }
         }
+        if (multiple) {
+            DocumentUndo::done(document(), SP_VERB_EDIT_CLONE_ORIGINAL_PATH_LPE, _("Fill between many"));
+        } else {
+            DocumentUndo::done(document(), SP_VERB_EDIT_CLONE_ORIGINAL_PATH_LPE, _("Clone original"));
+        }
 
-        DocumentUndo::done(document(), SP_VERB_EDIT_CLONE_ORIGINAL_PATH_LPE, _("Fill between many"));
-        // select the new object:
-        set(clone);
-
-        Inkscape::GC::release(clone);
     } else {
         if(desktop())
             desktop()->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select path(s) to fill."));
diff --git a/src/sp-ellipse.cpp b/src/sp-ellipse.cpp
index 30c1096ca..c2dca1fc3 100644
--- a/src/sp-ellipse.cpp
+++ b/src/sp-ellipse.cpp
@@ -503,6 +503,8 @@ Geom::Affine SPGenericEllipse::set_transform(Geom::Affine const &xform)
 {
     // Allow live effects
     if (hasPathEffect() && pathEffectsEnabled()) {
+        this->adjust_livepatheffect(xform);
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
         return xform;
     }
 
diff --git a/src/sp-spiral.cpp b/src/sp-spiral.cpp
index d75db3daa..f59fc0720 100644
--- a/src/sp-spiral.cpp
+++ b/src/sp-spiral.cpp
@@ -436,6 +436,8 @@ Geom::Affine SPSpiral::set_transform(Geom::Affine const &xform)
 
     // Allow live effects
     if (hasPathEffect() && pathEffectsEnabled()) {
+        this->adjust_livepatheffect(xform);
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
         return xform;
     }
 
diff --git a/src/sp-star.cpp b/src/sp-star.cpp
index d7ee352c7..5913dde20 100644
--- a/src/sp-star.cpp
+++ b/src/sp-star.cpp
@@ -518,6 +518,8 @@ Geom::Affine SPStar::set_transform(Geom::Affine const &xform)
 
     // Allow live effects
     if (hasPathEffect() && pathEffectsEnabled()) {
+        this->adjust_livepatheffect(xform);
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
         return xform;
     }
 
diff --git a/src/ui/dialog/livepatheffect-editor.cpp b/src/ui/dialog/livepatheffect-editor.cpp
index 02f76dbbb..28a42929b 100644
--- a/src/ui/dialog/livepatheffect-editor.cpp
+++ b/src/ui/dialog/livepatheffect-editor.cpp
@@ -206,9 +206,11 @@ LivePathEffectEditor::showParams(LivePathEffect::Effect& effect)
          if (defaultswidget) {
             Gtk::Expander * expander = NULL;
             std::vector<Gtk::Widget *> childs = dynamic_cast<Gtk::Box *> (effectwidget)->get_children();
-            std::vector<Gtk::Widget *> childs_default = dynamic_cast<Gtk::Box *> (childs[childs.size()-1])->get_children();
-            if ((expander = dynamic_cast<Gtk::Expander *>(childs_default[childs_default.size()-1]))){
-                expanderopen = expander->get_expanded();
+            if (childs.size()) {
+                std::vector<Gtk::Widget *> childs_default = dynamic_cast<Gtk::Box *> (childs[childs.size()-1])->get_children();
+                if ((expander = dynamic_cast<Gtk::Expander *>(childs_default[childs_default.size()-1]))){
+                    expanderopen = expander->get_expanded();
+                }
             }
         }
         effectcontrol_vbox.remove(*effectwidget);