Merged.

(bzr r15369.1.19)

11 files changed, 218 insertions, 107 deletions

diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 50e2aa353..f664870ec 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -430,6 +430,9 @@ void
 Effect::processObjects(LpeAction lpe_action)
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     for (std::vector<const char *>::iterator el_it = items.begin(); 
          el_it != items.end(); ++el_it) {
         const char * id = *el_it;
diff --git a/src/live_effects/lpe-clone-original.cpp b/src/live_effects/lpe-clone-original.cpp
index 04db6171e..440af6f9c 100644
--- a/src/live_effects/lpe-clone-original.cpp
+++ b/src/live_effects/lpe-clone-original.cpp
@@ -64,6 +64,9 @@ void
 LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, const char * attributes, const char * style_attributes, bool root) 
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     if ( SP_IS_GROUP(origin) && SP_IS_GROUP(dest) && SP_GROUP(origin)->getItemCount() == SP_GROUP(dest)->getItemCount() ) {
         std::vector< SPObject * > childs = origin->childList(true);
         size_t index = 0;
@@ -344,7 +347,6 @@ void
 LPECloneOriginal::transform_multiply(Geom::Affine const& postmul, bool set)
 {
     if (linked_item.linksToItem()) {
-        bool changed = false;
         linked_item.getObject()->requestModified(SP_OBJECT_MODIFIED_FLAG);
     }
 }
diff --git a/src/live_effects/lpe-copy_rotate.cpp b/src/live_effects/lpe-copy_rotate.cpp
index 42e055062..9ba680cd4 100644
--- a/src/live_effects/lpe-copy_rotate.cpp
+++ b/src/live_effects/lpe-copy_rotate.cpp
@@ -92,11 +92,13 @@ LPECopyRotate::doAfterEffect (SPLPEItem const* lpeitem)
 {
     if (split_items) {
         SPDocument * document = SP_ACTIVE_DOCUMENT;
+        if (!document) {
+            return;
+        }
         items.clear();
         container = dynamic_cast<SPObject *>(sp_lpe_item->parent);
-        SPDocument * doc = SP_ACTIVE_DOCUMENT;
         Inkscape::XML::Node *root = sp_lpe_item->document->getReprRoot();
-        Inkscape::XML::Node *root_origin = doc->getReprRoot();
+        Inkscape::XML::Node *root_origin = document->getReprRoot();
         if (root_origin != root) {
             return;
         }
@@ -168,15 +170,15 @@ LPECopyRotate::doAfterEffect (SPLPEItem const* lpeitem)
         processObjects(LPE_ERASE);
         items.clear();
     }
-    
-    std::cout << previous_num_copies << "previous_num_copies\n";
-    std::cout << num_copies << "num_copies\n";
 }
 
 void
 LPECopyRotate::cloneD(SPObject *origin, SPObject *dest, bool root, bool reset) 
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     if ( SP_IS_GROUP(origin) && SP_IS_GROUP(dest) && SP_GROUP(origin)->getItemCount() == SP_GROUP(dest)->getItemCount() ) {
         std::vector< SPObject * > childs = origin->childList(true);
@@ -190,7 +192,7 @@ LPECopyRotate::cloneD(SPObject *origin, SPObject *dest, bool root, bool reset)
     }
     SPShape * shape =  SP_SHAPE(origin);
     SPPath * path =  SP_PATH(dest);
-    if (!path && !SP_IS_GROUP(dest)) {
+    if (shape && !path) {
         Inkscape::XML::Node *dest_node = sp_selected_item_to_curved_repr(SP_ITEM(dest), 0);
         dest->updateRepr(xml_doc, dest_node, SP_OBJECT_WRITE_ALL);
         path =  SP_PATH(dest);
@@ -219,6 +221,9 @@ void
 LPECopyRotate::toItem(Geom::Affine transform, size_t i, bool reset)
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     const char * elemref_id = g_strdup(Glib::ustring("rotated-").append(std::to_string(i)).append("-").append(sp_lpe_item->getRepr()->attribute("id")).c_str());
     items.push_back(elemref_id);
@@ -377,11 +382,11 @@ LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
         num_copies.param_set_increments(1.0, 10.0);
     }
 
-    if (dist_angle_handle < 1.0) {
-        dist_angle_handle = 1.0;
-    }
     A = Point(boundingbox_X.min(), boundingbox_Y.middle());
     B = Point(boundingbox_X.middle(), boundingbox_Y.middle());
+    if (Geom::are_near(A, B, 0.01)) {
+        B += Geom::Point(1.0, 0.0);
+    }
     dir = unit_vector(B - A);
     // I first suspected the minus sign to be a bug in 2geom but it is
     // likely due to SVG's choice of coordinate system orientation (max)
@@ -394,6 +399,9 @@ LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
             dist_angle_handle = L2(starting_point - origin);
         }
     }
+    if (dist_angle_handle < 1.0) {
+        dist_angle_handle = 1.0;
+    }
     start_pos = origin + dir * Rotate(-rad_from_deg(starting_angle)) * dist_angle_handle;
     rot_pos = origin + dir * Rotate(-rad_from_deg(rotation_angle+starting_angle)) * dist_angle_handle;
     near = Geom::are_near(start_pos, (Geom::Point)starting_point, 0.01);
diff --git a/src/live_effects/lpe-fill-between-many.cpp b/src/live_effects/lpe-fill-between-many.cpp
index 2690ce160..2e1fe0dc1 100644
--- a/src/live_effects/lpe-fill-between-many.cpp
+++ b/src/live_effects/lpe-fill-between-many.cpp
@@ -4,13 +4,13 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <gtkmm/box.h>
 
 #include "live_effects/lpe-fill-between-many.h"
 
 #include "display/curve.h"
 #include "sp-shape.h"
 #include "sp-text.h"
+#include "svg/svg.h"
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
@@ -20,11 +20,17 @@ namespace LivePathEffect {
 LPEFillBetweenMany::LPEFillBetweenMany(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     linked_paths(_("Linked path:"), _("Paths from which to take the original path data"), "linkedpaths", &wr, this),
-    fuse(_("Fuse coincident points"), _("Fuse coincident points"), "fuse", &wr, this)
+    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),
+    close(_("Close"), _("Close path"), "close", &wr, this, true)
 {
     registerParameter( dynamic_cast<Parameter *>(&linked_paths) );
     registerParameter( dynamic_cast<Parameter *>(&fuse) );
-    //perceived_path = true;
+    registerParameter( dynamic_cast<Parameter *>(&allow_transforms) );
+    registerParameter( dynamic_cast<Parameter *>(&join) );
+    registerParameter( dynamic_cast<Parameter *>(&close) );
+    transformmultiply = false;
 }
 
 LPEFillBetweenMany::~LPEFillBetweenMany()
@@ -46,7 +52,7 @@ void LPEFillBetweenMany::doEffect (SPCurve * curve)
                 linked_path = (*iter)->_pathvector.front();
             }
             
-            if (!res_pathv.empty()) {
+            if (!res_pathv.empty() && join) {
                 linked_path = linked_path * SP_ITEM(obj)->getRelativeTransform(firstObj);
                 if (!are_near(res_pathv.front().finalPoint(), linked_path.initialPoint(), 0.01) || !fuse) {
                     res_pathv.front().appendNew<Geom::LineSegment>(linked_path.initialPoint());
@@ -56,19 +62,40 @@ void LPEFillBetweenMany::doEffect (SPCurve * curve)
                 res_pathv.front().append(linked_path);
             } else {
                 firstObj = SP_ITEM(obj);
+                if (close && !join) {
+                    linked_path.close();
+                }
                 res_pathv.push_back(linked_path);
             }
         }
     }
-    if (!res_pathv.empty()) {
+    if (!res_pathv.empty() && close) {
         res_pathv.front().close();
     }
     if (res_pathv.empty()) {
         res_pathv = curve->get_pathvector();
     }
+    if(!allow_transforms && !transformmultiply) {
+        Geom::Affine affine = Geom::identity();
+        sp_svg_transform_read(SP_ITEM(sp_lpe_item)->getAttribute("transform"), &affine);
+        res_pathv *= affine.inverse();
+    }
+    if(transformmultiply) {
+        transformmultiply = false;
+    }
     curve->set_pathvector(res_pathv);
 }
 
+void
+LPEFillBetweenMany::transform_multiply(Geom::Affine const& postmul, bool set)
+{
+    if(!allow_transforms && sp_lpe_item) {
+        SP_ITEM(sp_lpe_item)->transform *= postmul.inverse();
+        transformmultiply = true;
+        sp_lpe_item_update_patheffect(sp_lpe_item, false, false);
+    }
+}
+
 } // namespace LivePathEffect
 } /* namespace Inkscape */
 
diff --git a/src/live_effects/lpe-fill-between-many.h b/src/live_effects/lpe-fill-between-many.h
index 552c8037d..fe824e936 100644
--- a/src/live_effects/lpe-fill-between-many.h
+++ b/src/live_effects/lpe-fill-between-many.h
@@ -19,13 +19,16 @@ class LPEFillBetweenMany : public Effect {
 public:
     LPEFillBetweenMany(LivePathEffectObject *lpeobject);
     virtual ~LPEFillBetweenMany();
-    
+    virtual void transform_multiply(Geom::Affine const& postmul, bool set);
     virtual void doEffect (SPCurve * curve);
 
 private:
     OriginalPathArrayParam linked_paths;
     BoolParam fuse;
-
+    BoolParam allow_transforms;
+    BoolParam join;
+    BoolParam close;
+    bool transformmultiply;
 private:
     LPEFillBetweenMany(const LPEFillBetweenMany&);
     LPEFillBetweenMany& operator=(const LPEFillBetweenMany&);
diff --git a/src/live_effects/lpe-fill-between-strokes.cpp b/src/live_effects/lpe-fill-between-strokes.cpp
index 8dc55357f..43fef4288 100644
--- a/src/live_effects/lpe-fill-between-strokes.cpp
+++ b/src/live_effects/lpe-fill-between-strokes.cpp
@@ -8,6 +8,7 @@
 #include "display/curve.h"
 #include "sp-shape.h"
 #include "sp-text.h"
+#include "svg/svg.h"
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
@@ -19,15 +20,19 @@ LPEFillBetweenStrokes::LPEFillBetweenStrokes(LivePathEffectObject *lpeobject) :
     linked_path(_("Linked path:"), _("Path from which to take the original path data"), "linkedpath", &wr, this),
     second_path(_("Second path:"), _("Second path from which to take the original path data"), "secondpath", &wr, this),
     reverse_second(_("Reverse Second"), _("Reverses the second path order"), "reversesecond", &wr, this),
-    close(_("Close path"), _("Close path"), "close", &wr, this),
-    fuse(_("Fuse coincident points"), _("Fuse coincident points"), "fuse", &wr, this)
+    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),
+    close(_("Close"), _("Close path"), "close", &wr, this, true)
 {
     registerParameter( dynamic_cast<Parameter *>(&linked_path) );
     registerParameter( dynamic_cast<Parameter *>(&second_path) );
     registerParameter( dynamic_cast<Parameter *>(&reverse_second) );
-    registerParameter( dynamic_cast<Parameter *>(&close) );
     registerParameter( dynamic_cast<Parameter *>(&fuse) );
-    //perceived_path = true;
+    registerParameter( dynamic_cast<Parameter *>(&allow_transforms) );
+    registerParameter( dynamic_cast<Parameter *>(&join) );
+    registerParameter( dynamic_cast<Parameter *>(&close) );
+    transformmultiply = false;
 }
 
 LPEFillBetweenStrokes::~LPEFillBetweenStrokes()
@@ -38,6 +43,13 @@ LPEFillBetweenStrokes::~LPEFillBetweenStrokes()
 void LPEFillBetweenStrokes::doEffect (SPCurve * curve)
 {
     if (curve) {
+        Geom::Affine affine = Geom::identity();
+        if(!allow_transforms && !transformmultiply) {
+            sp_svg_transform_read(SP_ITEM(sp_lpe_item)->getAttribute("transform"), &affine);
+        }
+        if(transformmultiply) {
+            transformmultiply = false;
+        }
         if ( linked_path.linksToPath() && second_path.linksToPath() && linked_path.getObject() && second_path.getObject() ) {
             Geom::PathVector linked_pathv = linked_path.get_pathvector();
             Geom::PathVector second_pathv = second_path.get_pathvector();
@@ -58,19 +70,30 @@ void LPEFillBetweenStrokes::doEffect (SPCurve * curve)
                 if (reverse_second.get_value()) {
                     result_second_pathv.front() = result_second_pathv.front().reversed();
                 }
-                if (!are_near(result_linked_pathv.front().finalPoint(), result_second_pathv.front().initialPoint(),0.01) || !fuse) {
-                    result_linked_pathv.front().appendNew<Geom::LineSegment>(result_second_pathv.front().initialPoint());
+                if (join) {
+                    if (!are_near(result_linked_pathv.front().finalPoint(), result_second_pathv.front().initialPoint(),0.01) || !fuse) {
+                        result_linked_pathv.front().appendNew<Geom::LineSegment>(result_second_pathv.front().initialPoint());
+                    } else {
+                        result_second_pathv.front().setInitial(result_linked_pathv.front().finalPoint());
+                    }
+                    result_linked_pathv.front().append(result_second_pathv.front());
+                    if (close) {
+                        result_linked_pathv.front().close();
+                    }
                 } else {
-                    result_second_pathv.front().setInitial(result_linked_pathv.front().finalPoint());
-                }
-                result_linked_pathv.front().append(result_second_pathv.front());
-                if (close) {
-                    result_linked_pathv.front().close();
+                    if (close) {
+                        result_linked_pathv.front().close();
+                        result_second_pathv.front().close();
+                    }
+                    result_linked_pathv.push_back(result_second_pathv.front());
                 }
+                result_linked_pathv *= affine.inverse();
                 curve->set_pathvector(result_linked_pathv);
             } else if ( !result_linked_pathv.empty() ) {
+                result_linked_pathv *= affine.inverse();
                 curve->set_pathvector(result_linked_pathv);
             } else if ( !result_second_pathv.empty() ) {
+                result_second_pathv *= affine.inverse();
                 curve->set_pathvector(result_second_pathv);
             }
         }
@@ -83,6 +106,10 @@ void LPEFillBetweenStrokes::doEffect (SPCurve * curve)
                 result_pathv.push_back((*iter));
             }
             if ( !result_pathv.empty() ) {
+                result_pathv *= affine.inverse();
+                if (close) {
+                    result_pathv.front().close();
+                }
                 curve->set_pathvector(result_pathv);
             }
         }
@@ -95,12 +122,26 @@ void LPEFillBetweenStrokes::doEffect (SPCurve * curve)
                 result_pathv.push_back((*iter));
             }
             if ( !result_pathv.empty() ) {
+                result_pathv *= affine.inverse();
+                if (close) {
+                    result_pathv.front().close();
+                }
                 curve->set_pathvector(result_pathv);
             }
         }
     }
 }
 
+void
+LPEFillBetweenStrokes::transform_multiply(Geom::Affine const& postmul, bool set)
+{
+    if(!allow_transforms && sp_lpe_item) {
+        SP_ITEM(sp_lpe_item)->transform *= postmul.inverse();
+        transformmultiply = true;
+        sp_lpe_item_update_patheffect(sp_lpe_item, false, false);
+    }
+}
+
 } // namespace LivePathEffect
 } /* namespace Inkscape */
 
diff --git a/src/live_effects/lpe-fill-between-strokes.h b/src/live_effects/lpe-fill-between-strokes.h
index 14eb9167c..5bbd6e7da 100644
--- a/src/live_effects/lpe-fill-between-strokes.h
+++ b/src/live_effects/lpe-fill-between-strokes.h
@@ -19,15 +19,18 @@ class LPEFillBetweenStrokes : public Effect {
 public:
     LPEFillBetweenStrokes(LivePathEffectObject *lpeobject);
     virtual ~LPEFillBetweenStrokes();
-    
+    virtual void transform_multiply(Geom::Affine const& postmul, bool set);
     virtual void doEffect (SPCurve * curve);
 
 private:
     OriginalPathParam  linked_path;
     OriginalPathParam  second_path;
     BoolParam reverse_second;
-    BoolParam close;
     BoolParam fuse;
+    BoolParam allow_transforms;
+    BoolParam join;
+    BoolParam close;
+    bool transformmultiply;
 
 private:
     LPEFillBetweenStrokes(const LPEFillBetweenStrokes&);
diff --git a/src/live_effects/lpe-measure-line.cpp b/src/live_effects/lpe-measure-line.cpp
index ef87be81c..625db150b 100644
--- a/src/live_effects/lpe-measure-line.cpp
+++ b/src/live_effects/lpe-measure-line.cpp
@@ -171,6 +171,9 @@ void
 LPEMeasureLine::createArrowMarker(const char * mode)
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     SPObject *elemref = NULL;
     Inkscape::XML::Node *arrow = NULL;
@@ -232,6 +235,9 @@ void
 LPEMeasureLine::createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove, bool valid)
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     Inkscape::XML::Node *rtext = NULL;
     double doc_w = document->getRoot()->width.value;
@@ -376,6 +382,9 @@ void
 LPEMeasureLine::createLine(Geom::Point start,Geom::Point end, const char * id, bool main, bool overflow, bool remove, bool arrows)
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     SPObject *elemref = NULL;
     Inkscape::XML::Node *line = NULL;
@@ -500,6 +509,9 @@ LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
     SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
     sp_lpe_item->parent = dynamic_cast<SPObject *>(splpeitem->parent);
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     Inkscape::XML::Node *root = splpeitem->document->getReprRoot();
     Inkscape::XML::Node *root_origin = document->getReprRoot();
     if (root_origin != root) {
diff --git a/src/live_effects/lpe-mirror_symmetry.cpp b/src/live_effects/lpe-mirror_symmetry.cpp
index 7f0a93c52..c31ce7c01 100644
--- a/src/live_effects/lpe-mirror_symmetry.cpp
+++ b/src/live_effects/lpe-mirror_symmetry.cpp
@@ -87,11 +87,14 @@ LPEMirrorSymmetry::~LPEMirrorSymmetry()
 void
 LPEMirrorSymmetry::doAfterEffect (SPLPEItem const* lpeitem)
 {
+    SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     if (split_items && !discard_orig_path) {
         container = dynamic_cast<SPObject *>(sp_lpe_item->parent);
-        SPDocument * doc = SP_ACTIVE_DOCUMENT;
         Inkscape::XML::Node *root = sp_lpe_item->document->getReprRoot();
-        Inkscape::XML::Node *root_origin = doc->getReprRoot();
+        Inkscape::XML::Node *root_origin = document->getReprRoot();
         if (root_origin != root) {
             return;
         }
@@ -161,20 +164,24 @@ LPEMirrorSymmetry::doBeforeEffect (SPLPEItem const* lpeitem)
         }
     } else if ( mode == MT_V){
         SPDocument * document = SP_ACTIVE_DOCUMENT;
-        Geom::Affine transform = i2anc_affine(SP_OBJECT(lpeitem), NULL).inverse();
-        Geom::Point sp = Geom::Point(document->getWidth().value("px")/2.0, 0) * transform;
-        start_point.param_setValue(sp, true);
-        Geom::Point ep = Geom::Point(document->getWidth().value("px")/2.0, document->getHeight().value("px")) * transform;
-        end_point.param_setValue(ep, true);
-        center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point), true);
+        if (document) {
+            Geom::Affine transform = i2anc_affine(SP_OBJECT(lpeitem), NULL).inverse();
+            Geom::Point sp = Geom::Point(document->getWidth().value("px")/2.0, 0) * transform;
+            start_point.param_setValue(sp, true);
+            Geom::Point ep = Geom::Point(document->getWidth().value("px")/2.0, document->getHeight().value("px")) * transform;
+            end_point.param_setValue(ep, true);
+            center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point), true);
+        }
     } else { //horizontal page
         SPDocument * document = SP_ACTIVE_DOCUMENT;
-        Geom::Affine transform = i2anc_affine(SP_OBJECT(lpeitem), NULL).inverse();
-        Geom::Point sp = Geom::Point(0, document->getHeight().value("px")/2.0) * transform;
-        start_point.param_setValue(sp, true);
-        Geom::Point ep = Geom::Point(document->getWidth().value("px"), document->getHeight().value("px")/2.0) * transform;
-        end_point.param_setValue(ep, true);
-        center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point), true);
+        if (document) {
+            Geom::Affine transform = i2anc_affine(SP_OBJECT(lpeitem), NULL).inverse();
+            Geom::Point sp = Geom::Point(0, document->getHeight().value("px")/2.0) * transform;
+            start_point.param_setValue(sp, true);
+            Geom::Point ep = Geom::Point(document->getWidth().value("px"), document->getHeight().value("px")/2.0) * transform;
+            end_point.param_setValue(ep, true);
+            center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point), true);
+        }
     }
     previous_center = center_point;
 }
@@ -183,6 +190,9 @@ void
 LPEMirrorSymmetry::cloneD(SPObject *origin, SPObject *dest, bool live, bool root) 
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
+    if (!document) {
+        return;
+    }
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     if ( SP_IS_GROUP(origin) && SP_IS_GROUP(dest) && SP_GROUP(origin)->getItemCount() == SP_GROUP(dest)->getItemCount() ) {
         std::vector< SPObject * > childs = origin->childList(true);
@@ -196,7 +206,7 @@ LPEMirrorSymmetry::cloneD(SPObject *origin, SPObject *dest, bool live, bool root
     }
     SPShape * shape =  SP_SHAPE(origin);
     SPPath * path =  SP_PATH(dest);
-    if (!path && !SP_IS_GROUP(dest)) {
+    if (shape && !path) {
         Inkscape::XML::Node *dest_node = sp_selected_item_to_curved_repr(SP_ITEM(dest), 0);
         dest->updateRepr(xml_doc, dest_node, SP_OBJECT_WRITE_ALL);
         path =  SP_PATH(dest);
@@ -226,67 +236,69 @@ void
 LPEMirrorSymmetry::toMirror(Geom::Affine transform)
 {
     SPDocument * document = SP_ACTIVE_DOCUMENT;
-    Inkscape::XML::Document *xml_doc = document->getReprDoc();
-    const char * id_origin_char = id_origin.param_getSVGValue();
-    const char * elemref_id = g_strdup(Glib::ustring("mirror-").append(id_origin_char).c_str());
-    items.clear();
-    items.push_back(elemref_id);
-    SPObject *elemref= NULL;
-    Inkscape::XML::Node *phantom = NULL;
-    if (elemref = document->getObjectById(elemref_id)) {
-        phantom = elemref->getRepr();
-    } else {
-        phantom = sp_lpe_item->getRepr()->duplicate(xml_doc);
-        std::vector<const char *> attrs;
-        attrs.push_back("inkscape:path-effect");
-        attrs.push_back("inkscape:original-d");
-        attrs.push_back("sodipodi:type");
-        attrs.push_back("sodipodi:rx");
-        attrs.push_back("sodipodi:ry");
-        attrs.push_back("sodipodi:cx");
-        attrs.push_back("sodipodi:cy");
-        attrs.push_back("sodipodi:end");
-        attrs.push_back("sodipodi:start");
-        attrs.push_back("inkscape:flatsided");
-        attrs.push_back("inkscape:randomized");
-        attrs.push_back("inkscape:rounded");
-        attrs.push_back("sodipodi:arg1");
-        attrs.push_back("sodipodi:arg2");
-        attrs.push_back("sodipodi:r1");
-        attrs.push_back("sodipodi:r2");
-        attrs.push_back("sodipodi:sides");
-        attrs.push_back("inkscape:randomized");
-        attrs.push_back("sodipodi:argument");
-        attrs.push_back("sodipodi:expansion");
-        attrs.push_back("sodipodi:radius");
-        attrs.push_back("sodipodi:revolution");
-        attrs.push_back("sodipodi:t0");
-        attrs.push_back("inkscape:randomized");
-        attrs.push_back("inkscape:randomized");
-        attrs.push_back("inkscape:randomized");
-        attrs.push_back("x");
-        attrs.push_back("y");
-        attrs.push_back("rx");
-        attrs.push_back("ry");
-        attrs.push_back("width");
-        attrs.push_back("height");
-        for(const char * attr : attrs) { 
-            phantom->setAttribute(attr, NULL);
+    if (document) {
+        Inkscape::XML::Document *xml_doc = document->getReprDoc();
+        const char * id_origin_char = id_origin.param_getSVGValue();
+        const char * elemref_id = g_strdup(Glib::ustring("mirror-").append(id_origin_char).c_str());
+        items.clear();
+        items.push_back(elemref_id);
+        SPObject *elemref= NULL;
+        Inkscape::XML::Node *phantom = NULL;
+        if (elemref = document->getObjectById(elemref_id)) {
+            phantom = elemref->getRepr();
+        } else {
+            phantom = sp_lpe_item->getRepr()->duplicate(xml_doc);
+            std::vector<const char *> attrs;
+            attrs.push_back("inkscape:path-effect");
+            attrs.push_back("inkscape:original-d");
+            attrs.push_back("sodipodi:type");
+            attrs.push_back("sodipodi:rx");
+            attrs.push_back("sodipodi:ry");
+            attrs.push_back("sodipodi:cx");
+            attrs.push_back("sodipodi:cy");
+            attrs.push_back("sodipodi:end");
+            attrs.push_back("sodipodi:start");
+            attrs.push_back("inkscape:flatsided");
+            attrs.push_back("inkscape:randomized");
+            attrs.push_back("inkscape:rounded");
+            attrs.push_back("sodipodi:arg1");
+            attrs.push_back("sodipodi:arg2");
+            attrs.push_back("sodipodi:r1");
+            attrs.push_back("sodipodi:r2");
+            attrs.push_back("sodipodi:sides");
+            attrs.push_back("inkscape:randomized");
+            attrs.push_back("sodipodi:argument");
+            attrs.push_back("sodipodi:expansion");
+            attrs.push_back("sodipodi:radius");
+            attrs.push_back("sodipodi:revolution");
+            attrs.push_back("sodipodi:t0");
+            attrs.push_back("inkscape:randomized");
+            attrs.push_back("inkscape:randomized");
+            attrs.push_back("inkscape:randomized");
+            attrs.push_back("x");
+            attrs.push_back("y");
+            attrs.push_back("rx");
+            attrs.push_back("ry");
+            attrs.push_back("width");
+            attrs.push_back("height");
+            for(const char * attr : attrs) { 
+                phantom->setAttribute(attr, NULL);
+            }
+        }
+        phantom->setAttribute("id", elemref_id);
+        if (!elemref) {
+            elemref = container->appendChildRepr(phantom);
+            Inkscape::GC::release(phantom);
+        }
+        cloneD(SP_OBJECT(sp_lpe_item), elemref, true, true);
+        elemref->getRepr()->setAttribute("transform" , sp_svg_transform_write(transform));
+        if (elemref->parent != container) {
+            Inkscape::XML::Node *copy = phantom->duplicate(xml_doc);
+            copy->setAttribute("id", elemref_id);
+            container->appendChildRepr(copy);
+            Inkscape::GC::release(copy);
+            elemref->deleteObject();
         }
-    }
-    phantom->setAttribute("id", elemref_id);
-    if (!elemref) {
-        elemref = container->appendChildRepr(phantom);
-        Inkscape::GC::release(phantom);
-    }
-    cloneD(SP_OBJECT(sp_lpe_item), elemref, true, true);
-    elemref->getRepr()->setAttribute("transform" , sp_svg_transform_write(transform));
-    if (elemref->parent != container) {
-        Inkscape::XML::Node *copy = phantom->duplicate(xml_doc);
-        copy->setAttribute("id", elemref_id);
-        container->appendChildRepr(copy);
-        Inkscape::GC::release(copy);
-        elemref->deleteObject();
     }
 }
 
diff --git a/src/live_effects/parameter/originalpath.cpp b/src/live_effects/parameter/originalpath.cpp
index f7eb48b7a..1e78f7fe1 100644
--- a/src/live_effects/parameter/originalpath.cpp
+++ b/src/live_effects/parameter/originalpath.cpp
@@ -89,7 +89,7 @@ OriginalPathParam::linked_modified_callback(SPObject *linked_obj, guint /*flags*
 {
     SPCurve *curve = NULL;
     if (SP_IS_SHAPE(linked_obj)) {
-        curve = SP_SHAPE(linked_obj)->getCurveBeforeLPE();
+        curve = SP_SHAPE(linked_obj)->getCurve();
     }
     if (SP_IS_TEXT(linked_obj)) {
         curve = SP_TEXT(linked_obj)->getNormalizedBpath();
diff --git a/src/live_effects/parameter/originalpatharray.cpp b/src/live_effects/parameter/originalpatharray.cpp
index 083abc94c..693821ed2 100644
--- a/src/live_effects/parameter/originalpatharray.cpp
+++ b/src/live_effects/parameter/originalpatharray.cpp
@@ -386,7 +386,7 @@ void OriginalPathArrayParam::setPathVector(SPObject *linked_obj, guint /*flags*/
     }
     SPCurve *curve = NULL;
     if (SP_IS_SHAPE(linked_obj)) {
-        curve = SP_SHAPE(linked_obj)->getCurveBeforeLPE();
+        curve = SP_SHAPE(linked_obj)->getCurve();
     }
     if (SP_IS_TEXT(linked_obj)) {
         curve = SP_TEXT(linked_obj)->getNormalizedBpath();