Merge lp:~liampwhite/inkscape/inkscape into lp:inkscape/experimental

[Liam P. White]

Proposing to merge to watch progression of diff.

[lp:~liampwhite/inkscape/inkscape]

13179. By Liam P. White <inkscapebrony at-sign gmail dot com> on 2014-07-09

Update to experimental r13428

13180. By Liam P. White <inkscapebrony at-sign gmail dot com> on 2014-07-17

Update to experimental r13429

13181. By Liam P. White <inkscapebrony at-sign gmail dot com> on 2014-07-23

Duplicate LPE entries

13182. By Liam P. White <inkscapebrony at-sign gmail dot com> on 2014-07-23

Update to experimental r13436

13183. By Liam P. White <inkscapebrony at-sign gmail dot com> on 2014-07-23

This file does not need executable permissions

13184. By Liam P. White <inkscapebrony at-sign gmail dot com> on 2014-07-23

Refactoring of linejoin code

13185. By Liam P. White on 2014-07-30

Update to experimental r13452

13186. By Liam P. White on 2014-07-30

Fix make check

13187. By Liam P. White on 2014-07-31

I'm an idiot

13188. By Liam P. White on 2014-08-06

Update to experimental r13460

13189. By Liam P. White on 2014-08-08

Update to experimental r13464

13190. By Liam P. White on 2014-08-08

Messed up German translation (??)

13191. By Liam P. White on 2014-08-08

Ponyscape feature: finish pen drawing on context switch

13192. By Liam P. White on 2014-08-08

Update to experimental r13465

13193. By Liam P. White on 2014-08-12

Update to experimental r13479

13194. By Liam P. White on 2014-08-14

Clone Original -> Fill Between Many

13195. By Liam P. White on 2014-08-17

Update to experimental r13483

13196. By Liam P. White on 2014-08-31

Update to experimental r13531

13197. By Liam P. White on 2014-09-02

Fix gtk3 build

13198. By Liam P. White on 2014-09-07

Update to experimental r13543

[Martin Owens (doctormo)]

I've passed along a few clean up points over irc and I can't spot anything really bad. So I'm going ahead with a merge.

review: Approve

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2014-08-30 15:50:55 +0000
+++ po/POTFILES.in	2014-09-07 17:02:32 +0000
@@ -153,7 +153,18 @@
 src/live_effects/lpe-skeleton.cpp
 src/live_effects/lpe-sketch.cpp
 src/live_effects/lpe-vonkoch.cpp
+src/live_effects/lpe-envelope-perspective.cpp
+src/live_effects/lpe-attach-path.cpp
+src/live_effects/lpe-bounding-box.cpp
+src/live_effects/lpe-ellipse_5pts.cpp
+src/live_effects/lpe-fill-between-many.cpp
+src/live_effects/lpe-fill-between-strokes.cpp
+src/live_effects/lpe-jointype.cpp
+src/live_effects/lpe-taperstroke.cpp
+src/live_effects/lpe-fillet-chamfer.cpp
 src/live_effects/parameter/filletchamferpointarray.cpp
+src/live_effects/parameter/originalpatharray.cpp
+src/live_effects/parameter/transformedpoint.cpp
 src/live_effects/parameter/pointreseteable.cpp
 src/live_effects/parameter/togglebutton.cpp
 src/live_effects/parameter/bool.cpp
@@ -260,6 +271,10 @@
 src/ui/dialog/tracedialog.cpp
 src/ui/dialog/transformation.cpp
 src/ui/dialog/xml-tree.cpp
+src/ui/dialog/lpe-fillet-chamfer-properties.cpp
+src/ui/dialog/lpe-powerstroke-properties.cpp
+src/ui/dialog/objects.cpp
+src/ui/dialog/tags.cpp
 src/ui/tool/curve-drag-point.cpp
 src/ui/tool/multi-path-manipulator.cpp
 src/ui/tool/node.cpp
 
=== modified file 'src/Makefile_insert'
--- src/Makefile_insert	2014-08-31 18:17:26 +0000
+++ src/Makefile_insert	2014-09-07 17:02:32 +0000
@@ -199,6 +199,9 @@
 	sp-style-elem.cpp sp-style-elem.h	\
 	sp-switch.cpp sp-switch.h		\
 	sp-symbol.cpp sp-symbol.h		\
+	sp-tag.cpp sp-tag.h			\
+	sp-tag-use.cpp sp-tag-use.h		\
+	sp-tag-use-reference.cpp sp-tag-use-reference.h			\
 	sp-text.cpp sp-text.h			\
 	sp-textpath.h				\
 	sp-title.cpp sp-title.h			\
 
=== modified file 'src/attributes.cpp'
--- src/attributes.cpp	2014-08-18 20:19:55 +0000
+++ src/attributes.cpp	2014-09-07 17:02:32 +0000
@@ -40,6 +40,7 @@
     {SP_ATTR_TRANSFORM_CENTER_X, "inkscape:transform-center-x"},
     {SP_ATTR_TRANSFORM_CENTER_Y, "inkscape:transform-center-y"},
     {SP_ATTR_INKSCAPE_PATH_EFFECT, "inkscape:path-effect"},
+    {SP_ATTR_INKSCAPE_HIGHLIGHT_COLOR, "inkscape:highlight-color"},
     /* SPAnchor */
     {SP_ATTR_XLINK_HREF, "xlink:href"},
     {SP_ATTR_XLINK_TYPE, "xlink:type"},
@@ -50,6 +51,7 @@
     {SP_ATTR_XLINK_ACTUATE, "xlink:actuate"},
     {SP_ATTR_TARGET, "target"},
     {SP_ATTR_INKSCAPE_GROUPMODE, "inkscape:groupmode"},
+    {SP_ATTR_INKSCAPE_EXPANDED, "inkscape:expanded"},
     /* SPRoot */
     {SP_ATTR_VERSION, "version"},
     {SP_ATTR_WIDTH, "width"},
 
=== modified file 'src/attributes.h'
--- src/attributes.h	2014-08-04 16:19:41 +0000
+++ src/attributes.h	2014-09-07 17:02:32 +0000
@@ -40,6 +40,7 @@
     SP_ATTR_TRANSFORM_CENTER_X,
     SP_ATTR_TRANSFORM_CENTER_Y,
     SP_ATTR_INKSCAPE_PATH_EFFECT,
+    SP_ATTR_INKSCAPE_HIGHLIGHT_COLOR,
     /* SPAnchor */
     SP_ATTR_XLINK_HREF,
     SP_ATTR_XLINK_TYPE,
@@ -51,6 +52,7 @@
     SP_ATTR_TARGET,
     /* SPGroup */
     SP_ATTR_INKSCAPE_GROUPMODE,
+    SP_ATTR_INKSCAPE_EXPANDED,
     /* SPRoot */
     SP_ATTR_VERSION,
     SP_ATTR_WIDTH,
 
=== modified file 'src/display/cairo-utils.cpp'
--- src/display/cairo-utils.cpp	2014-09-06 15:25:51 +0000
+++ src/display/cairo-utils.cpp	2014-09-07 17:02:32 +0000
@@ -33,8 +33,6 @@
 #include "helper/geom-curves.h"
 #include "display/cairo-templates.h"
 
-static void ink_cairo_pixbuf_cleanup(guchar *, void *);
-
 /**
  * Key for cairo_surface_t to keep track of current color interpolation value
  * Only the address of the structure is used, it is never initialized. See:
@@ -1172,7 +1170,7 @@
  * to gdk_pixbuf_new_from_data when creating a GdkPixbuf backed by
  * a Cairo surface.
  */
-static void ink_cairo_pixbuf_cleanup(guchar * /*pixels*/, void *data)
+void ink_cairo_pixbuf_cleanup(guchar * /*pixels*/, void *data)
 {
     cairo_surface_t *surface = static_cast<cairo_surface_t*>(data);
     cairo_surface_destroy(surface);
 
=== modified file 'src/display/cairo-utils.h'
--- src/display/cairo-utils.h	2014-08-30 17:23:17 +0000
+++ src/display/cairo-utils.h	2014-09-07 17:02:32 +0000
@@ -20,6 +20,9 @@
 struct SPColor;
 typedef struct _GdkPixbuf GdkPixbuf;
 
+void ink_cairo_pixbuf_cleanup(unsigned char *, void *);
+void convert_pixbuf_argb32_to_normal(GdkPixbuf *pb);
+
 namespace Inkscape {
 
 /**
 
=== modified file 'src/display/drawing-item.cpp'
--- src/display/drawing-item.cpp	2014-08-18 21:18:05 +0000
+++ src/display/drawing-item.cpp	2014-09-07 17:02:32 +0000
@@ -825,9 +825,10 @@
 {
     // Sometimes there's no BBOX in state, reason unknown (bug 992817)
     // I made this not an assert to remove the warning
+    // This warning clutters the console output, so commented out
     if (!(_state & STATE_BBOX) || !(_state & STATE_PICK)) {
-        g_warning("Invalid state when picking: STATE_BBOX = %d, STATE_PICK = %d",
-                  _state & STATE_BBOX, _state & STATE_PICK);
+        /*g_warning("Invalid state when picking: STATE_BBOX = %d, STATE_PICK = %d",
+                  _state & STATE_BBOX, _state & STATE_PICK);*/
         return NULL;
     }
     // ignore invisible and insensitive items unless sticky
 
=== modified file 'src/display/sp-canvas.cpp'
--- src/display/sp-canvas.cpp	2014-08-26 11:14:18 +0000
+++ src/display/sp-canvas.cpp	2014-09-07 17:02:32 +0000
@@ -1146,7 +1146,7 @@
 sp_canvas_init(SPCanvas *canvas)
 {
     gtk_widget_set_has_window (GTK_WIDGET (canvas), TRUE);
-    //gtk_widget_set_double_buffered (GTK_WIDGET (canvas), TRUE);
+    gtk_widget_set_double_buffered (GTK_WIDGET (canvas), FALSE);
     gtk_widget_set_can_focus (GTK_WIDGET (canvas), TRUE);
 
     canvas->pick_event.type = GDK_LEAVE_NOTIFY;
 
=== modified file 'src/interface.cpp'
--- src/interface.cpp	2014-09-02 21:14:55 +0000
+++ src/interface.cpp	2014-09-07 17:02:32 +0000
@@ -1756,6 +1756,13 @@
     }
     mi->show();
     append(*mi);
+
+    /*SSet Clip Group */
+    mi = Gtk::manage(new Gtk::MenuItem(_("Create Clip G_roup"),1));
+    mi->signal_activate().connect(sigc::mem_fun(*this, &ContextMenu::CreateGroupClip));
+    mi->set_sensitive(TRUE);
+    mi->show();
+    append(*mi);
     
     /* Set Clip */
     mi = Gtk::manage(new Gtk::MenuItem(_("Set Cl_ip"), 1));
@@ -1867,6 +1874,10 @@
     sp_selection_unset_mask(_desktop, false);
 }
 
+void ContextMenu::CreateGroupClip(void)
+{
+    sp_selection_set_clipgroup(_desktop);
+}
 
 void ContextMenu::SetClip(void)
 {
 
=== modified file 'src/interface.h'
--- src/interface.h	2014-08-31 18:17:26 +0000
+++ src/interface.h	2014-09-07 17:02:32 +0000
@@ -183,6 +183,7 @@
         void SelectSameStrokeStyle(void);
         void SelectSameObjectType(void);
         void ItemCreateLink(void);
+        void CreateGroupClip(void);
         void SetMask(void);
         void ReleaseMask(void);
         void SetClip(void);
 
=== modified file 'src/knotholder.cpp'
--- src/knotholder.cpp	2014-08-04 16:10:37 +0000
+++ src/knotholder.cpp	2014-09-07 17:02:32 +0000
@@ -154,8 +154,15 @@
     }
 
     // for drag, this is done by ungrabbed_handler, but for click we must do it here
-    DocumentUndo::done(saved_item->document, object_verb,
-                       _("Change handle"));
+    
+    if (saved_item) { //increasingly aggressive sanity checks
+       if (saved_item->document) {
+            if (object_verb <= SP_VERB_LAST && object_verb >= SP_VERB_INVALID) {
+                DocumentUndo::done(saved_item->document, object_verb,
+                                   _("Change handle"));
+            }
+       }
+    } // else { abort(); }
 }
 
 void
@@ -203,14 +210,16 @@
         /* do cleanup tasks (e.g., for LPE items write the parameter values
          * that were changed by dragging the handle to SVG)
          */
-        if (SP_IS_LPE_ITEM(object)) {
+        if (dynamic_cast<SPLPEItem*> (object)) {
             // This writes all parameters to SVG. Is this sufficiently efficient or should we only
             // write the ones that were changed?
-
-            Inkscape::LivePathEffect::Effect *lpe = SP_LPE_ITEM(object)->getCurrentLPE();
-            if (lpe) {
-                LivePathEffectObject *lpeobj = lpe->getLPEObj();
-                lpeobj->updateRepr();
+            SPLPEItem * lpeitem = SP_LPE_ITEM(object);
+            if (lpeitem) {
+                Inkscape::LivePathEffect::Effect *lpe = lpeitem->getCurrentLPE();
+                if (lpe) {
+                    LivePathEffectObject *lpeobj = lpe->getLPEObj();
+                    lpeobj->updateRepr();
+                }
             }
         }
 
@@ -232,9 +241,14 @@
             else
                 object_verb = SP_VERB_SELECTION_DYNAMIC_OFFSET;
         }
-
-        DocumentUndo::done(object->document, object_verb,
-                           _("Move handle"));
+        if (object) { //increasingly aggressive sanity checks
+            if (object->document) {
+                if (object_verb <= SP_VERB_LAST && object_verb >= SP_VERB_INVALID) {
+                    DocumentUndo::done(object->document, object_verb,
+                                       _("Move handle"));
+                }
+            }
+        } //else { abort(); }
     }
 }
 
 
=== modified file 'src/live_effects/CMakeLists.txt'
--- src/live_effects/CMakeLists.txt	2014-08-12 22:30:34 +0000
+++ src/live_effects/CMakeLists.txt	2014-09-07 17:02:32 +0000
@@ -2,8 +2,10 @@
 set(live_effects_SRC
 	effect.cpp
 	lpe-angle_bisector.cpp
+	lpe-attach-path.cpp
 	lpe-bendpath.cpp
 	lpe-boolops.cpp
+	lpe-bounding-box.cpp
 	lpe-circle_3pts.cpp
 	lpe-circle_with_radius.cpp
 	lpe-clone-original.cpp
@@ -11,9 +13,12 @@
 	lpe-copy_rotate.cpp
 	lpe-curvestitch.cpp
 	lpe-dynastroke.cpp
+	lpe-ellipse-5pts.cpp
 	lpe-envelope.cpp
 	lpe-envelope-perspective.cpp
 	lpe-extrude.cpp
+	lpe-fill-between-many.cpp
+	lpe-fill-between-strokes.cpp
 	lpe-fillet-chamfer.cpp
 	lpe-gears.cpp
 	lpe-interpolate.cpp
@@ -55,11 +60,13 @@
 	parameter/parameter.cpp
 	parameter/path.cpp
 	parameter/originalpath.cpp
+	parameter/originalpatharray.cpp
 	parameter/path-reference.cpp
 	parameter/point.cpp
 	parameter/powerstrokepointarray.cpp
 	parameter/random.cpp
 	parameter/text.cpp
+	paramter/transformedpoint.cpp
 	parameter/togglebutton.cpp
 	parameter/unit.cpp
 	parameter/vector.cpp
@@ -70,8 +77,10 @@
 	effect-enum.h
 	effect.h
 	lpe-angle_bisector.h
+	lpe-attach-path.h
 	lpe-bendpath.h
 	lpe-boolops.h
+	lpe-bounding-box.h
 	lpe-circle_3pts.h
 	lpe-circle_with_radius.h
 	lpe-clone-original.h
@@ -79,8 +88,11 @@
 	lpe-copy_rotate.h
 	lpe-curvestitch.h
 	lpe-dynastroke.h
+	lpe-ellipse-5pts.h
 	lpe-envelope.h
 	lpe-extrude.h
+	lpe-fill-between-many.h
+	lpe-fill-between-strokes.h
 	lpe-fillet-chamfer.h
 	lpe-gears.h
 	lpe-interpolate.h
@@ -125,6 +137,7 @@
 	parameter/path-reference.h
 	parameter/path.h
 	parameter/originalpath.h
+	parameter/originalpatharray.h
 	parameter/point.h
 	parameter/powerstrokepointarray.h
 	parameter/random.h
 
=== modified file 'src/live_effects/Makefile_insert'
--- src/live_effects/Makefile_insert	2014-08-23 16:39:36 +0000
+++ src/live_effects/Makefile_insert	2014-09-07 17:02:32 +0000
@@ -97,5 +97,21 @@
 	live_effects/lpe-path_length.h	\
 	live_effects/lpe-line_segment.cpp	\
 	live_effects/lpe-line_segment.h	\
+	live_effects/lpe-bounding-box.cpp	\
+	live_effects/lpe-bounding-box.h	\
+	live_effects/lpe-attach-path.cpp	\
+	live_effects/lpe-attach-path.h	\
+	live_effects/lpe-fill-between-strokes.cpp	\
+	live_effects/lpe-fill-between-strokes.h	\
+	live_effects/lpe-fill-between-many.cpp	\
+	live_effects/lpe-fill-between-many.h	\
+	live_effects/lpe-ellipse_5pts.cpp	\
+	live_effects/lpe-ellipse_5pts.h	\
+	live_effects/pathoutlineprovider.cpp	\
+	live_effects/pathoutlineprovider.h	\
+	live_effects/lpe-jointype.cpp	\
+	live_effects/lpe-jointype.h	\
+	live_effects/lpe-taperstroke.cpp	\
+	live_effects/lpe-taperstroke.h 	\
 	live_effects/lpe-envelope-perspective.cpp	\
 	live_effects/lpe-envelope-perspective.h
 
=== modified file 'src/live_effects/effect-enum.h'
--- src/live_effects/effect-enum.h	2014-08-23 16:39:36 +0000
+++ src/live_effects/effect-enum.h	2014-09-07 17:02:32 +0000
@@ -56,6 +56,13 @@
     EXTRUDE,
     POWERSTROKE,
     CLONE_ORIGINAL,
+    ATTACH_PATH,
+    FILL_BETWEEN_STROKES,
+    FILL_BETWEEN_MANY,
+    ELLIPSE_5PTS,
+    BOUNDING_BOX,
+    JOIN_TYPE,
+    TAPER_STROKE,
     ENVELOPE_PERSPECTIVE,
     FILLET_CHAMFER,
     INVALID_LPE // This must be last (I made it such that it is not needed anymore I think..., Don't trust on it being last. - johan)
 
=== modified file 'src/live_effects/effect.cpp'
--- src/live_effects/effect.cpp	2014-08-23 16:39:36 +0000
+++ src/live_effects/effect.cpp	2014-09-07 17:02:32 +0000
@@ -5,6 +5,8 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+//#define LPE_ENABLE_TEST_EFFECTS //uncomment for toy effects
+
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
@@ -19,7 +21,6 @@
 #include "live_effects/lpe-rough-hatches.h"
 #include "live_effects/lpe-dynastroke.h"
 #include "live_effects/lpe-test-doEffect-stack.h"
-#include "live_effects/lpe-bspline.h"
 #include "live_effects/lpe-gears.h"
 #include "live_effects/lpe-curvestitch.h"
 #include "live_effects/lpe-circle_with_radius.h"
@@ -51,6 +52,14 @@
 #include "live_effects/lpe-extrude.h"
 #include "live_effects/lpe-powerstroke.h"
 #include "live_effects/lpe-clone-original.h"
+#include "live_effects/lpe-bspline.h"
+#include "live_effects/lpe-attach-path.h"
+#include "live_effects/lpe-fill-between-strokes.h"
+#include "live_effects/lpe-fill-between-many.h"
+#include "live_effects/lpe-ellipse_5pts.h"
+#include "live_effects/lpe-bounding-box.h"
+#include "live_effects/lpe-jointype.h"
+#include "live_effects/lpe-taperstroke.h"
 #include "live_effects/lpe-envelope-perspective.h"
 #include "live_effects/lpe-fillet-chamfer.h"
 
@@ -132,10 +141,18 @@
     {SHOW_HANDLES,          N_("Show handles"),            "show_handles"},
     {ROUGHEN,               N_("Roughen"),                 "roughen"},
     {BSPLINE,               N_("BSpline"),                 "bspline"},
-    {SIMPLIFY,              N_("Simplify"),                "simplify"},
-    {LATTICE2,              N_("Lattice Deformation 2"),   "lattice2"},
-    // TRANSLATORS: "Envelope Perspective" should be equivalent to "perspective transformation"
-    {ENVELOPE_PERSPECTIVE,  N_("Envelope Perspective"),    "envelope-perspective"},
+    {JOIN_TYPE,             N_("Join type"),               "join_type"},
+    {TAPER_STROKE,          N_("Taper stroke"),            "taper_stroke"},
+/* Ponyscape */
+    {ATTACH_PATH,           N_("Attach path"),             "attach_path"},
+    {FILL_BETWEEN_STROKES,  N_("Fill between strokes"),    "fill_between_strokes"},
+    {FILL_BETWEEN_MANY,     N_("Fill between many"),       "fill_between_many"},
+    {ELLIPSE_5PTS,          N_("Ellipse by 5 points"),     "ellipse_5pts"},
+    {BOUNDING_BOX,          N_("Bounding Box"),            "bounding_box"},
+/* 0.91 */
+    {SIMPLIFY,               N_("Simplify"),     "simplify"},
+    {LATTICE2,               N_("Lattice Deformation 2"),     "lattice2"},
+    {ENVELOPE_PERSPECTIVE,  N_("Envelope-Perspective"),        "envelope-perspective"},
     {FILLET_CHAMFER,        N_("Fillet/Chamfer"),          "fillet-chamfer"},
     {INTERPOLATE_POINTS,    N_("Interpolate points"),      "interpolate_points"},
 };
@@ -267,6 +284,27 @@
         case CLONE_ORIGINAL:
             neweffect = static_cast<Effect*> ( new LPECloneOriginal(lpeobj) );
             break;
+        case ATTACH_PATH:
+            neweffect = static_cast<Effect*> ( new LPEAttachPath(lpeobj) );
+            break;
+        case FILL_BETWEEN_STROKES:
+            neweffect = static_cast<Effect*> ( new LPEFillBetweenStrokes(lpeobj) );
+            break;
+        case FILL_BETWEEN_MANY:
+            neweffect = static_cast<Effect*> ( new LPEFillBetweenMany(lpeobj) );
+            break;
+        case ELLIPSE_5PTS:
+            neweffect = static_cast<Effect*> ( new LPEEllipse5Pts(lpeobj) );
+            break;
+        case BOUNDING_BOX:
+            neweffect = static_cast<Effect*> ( new LPEBoundingBox(lpeobj) );
+            break;
+        case JOIN_TYPE:
+            neweffect = static_cast<Effect*> ( new LPEJoinType(lpeobj) );
+            break;
+        case TAPER_STROKE:
+            neweffect = static_cast<Effect*> ( new LPETaperStroke(lpeobj) );
+            break;
         case SIMPLIFY:
             neweffect = static_cast<Effect*> ( new LPESimplify(lpeobj) );
             break;
@@ -286,7 +324,7 @@
             neweffect = static_cast<Effect*> ( new LPEShowHandles(lpeobj) );
             break;
         default:
-            g_warning("LivePathEffect::Effect::New   called with invalid patheffect type (%d)", lpenr);
+            g_warning("LivePathEffect::Effect::New called with invalid patheffect type (%d)", lpenr);
             neweffect = NULL;
             break;
     }
@@ -369,6 +407,33 @@
     //Do nothing for simple effects
 }
 
+void Effect::doAfterEffect (SPLPEItem const* lpeitem)
+{
+}
+
+void Effect::doOnRemove (SPLPEItem const* lpeitem)
+{
+}
+
+//secret impl methods (shhhh!)
+void Effect::doOnApply_impl(SPLPEItem const* lpeitem)
+{
+    sp_lpe_item = const_cast<SPLPEItem *>(lpeitem);
+    /*sp_curve = SP_SHAPE(sp_lpe_item)->getCurve();
+    pathvector_before_effect = sp_curve->get_pathvector();*/
+    doOnApply(lpeitem);
+}
+
+void Effect::doBeforeEffect_impl(SPLPEItem const* lpeitem)
+{
+    sp_lpe_item = const_cast<SPLPEItem *>(lpeitem);
+    //printf("(SPLPEITEM*) %p\n", sp_lpe_item);
+    sp_curve = SP_SHAPE(sp_lpe_item)->getCurve();
+    pathvector_before_effect = sp_curve->get_pathvector();
+    
+    doBeforeEffect(lpeitem);
+}
+
 /**
  * Effects can have a parameter path set before they are applied by accepting a nonzero number of
  * mouse clicks. This method activates the pen context, which waits for the specified number of
 
=== modified file 'src/live_effects/effect.h'
--- src/live_effects/effect.h	2014-05-05 07:13:35 +0000
+++ src/live_effects/effect.h	2014-09-07 17:02:32 +0000
@@ -53,8 +53,16 @@
 
     EffectType effectType() const;
 
+    //basically, to get this method called before the derived classes, a bit
+    //of indirection is needed. We first call these methods, then the below.
+    void doOnApply_impl(SPLPEItem const* lpeitem);
+    void doBeforeEffect_impl(SPLPEItem const* lpeitem);
+
     virtual void doOnApply (SPLPEItem const* lpeitem);
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
+    
+    virtual void doAfterEffect (SPLPEItem const* lpeitem);
+    virtual void doOnRemove (SPLPEItem const* lpeitem);
 
     void writeParamsToSVG();
 
@@ -147,6 +155,9 @@
     // instead of normally 'splitting' the path into continuous pwd2 paths and calling doEffect_pwd2 for each.
     bool concatenate_before_pwd2;
 
+    SPLPEItem * sp_lpe_item; // these get stored in doBeforeEffect_impl, and derived classes may do as they please with them.
+    SPCurve * sp_curve;
+    std::vector<Geom::Path> pathvector_before_effect;
 private:
     bool provides_own_flash_paths; // if true, the standard flash path is suppressed
 
 
=== added file 'src/live_effects/lpe-attach-path.cpp'
--- src/live_effects/lpe-attach-path.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-attach-path.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) Johan Engelen 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glibmm/i18n.h>
+#include <math.h>
+
+#include "live_effects/lpe-attach-path.h"
+
+#include "display/curve.h"
+#include "sp-item.h"
+#include "2geom/path.h"
+#include "sp-shape.h"
+#include "sp-text.h"
+#include "2geom/bezier-curve.h"
+#include "2geom/path-sink.h"
+#include "parameter/parameter.h"
+#include "live_effects/parameter/point.h"
+#include "parameter/originalpath.h"
+#include "2geom/affine.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+LPEAttachPath::LPEAttachPath(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    start_path(_("Start path:"), _("Path to attach to the start of this path"), "startpath", &wr, this),
+    start_path_position(_("Start path position:"), _("Position to attach path start to"), "startposition", &wr, this, 0.0),
+    start_path_curve_start(_("Start path curve start:"), _("Starting curve"), "startcurvestart", &wr, this, Geom::Point(20,0)/*, true*/),
+    start_path_curve_end(_("Start path curve end:"), _("Ending curve"), "startcurveend", &wr, this, Geom::Point(20,0)/*, true*/),
+    end_path(_("End path:"), _("Path to attach to the end of this path"), "endpath", &wr, this),
+    end_path_position(_("End path position:"), _("Position to attach path end to"), "endposition", &wr, this, 0.0),
+    end_path_curve_start(_("End path curve start:"), _("Starting curve"), "endcurvestart", &wr, this, Geom::Point(20,0)/*, true*/),
+    end_path_curve_end(_("End path curve end:"), _("Ending curve"), "endcurveend", &wr, this, Geom::Point(20,0)/*, true*/)
+{
+    registerParameter( dynamic_cast<Parameter *>(&start_path) );
+    registerParameter( dynamic_cast<Parameter *>(&start_path_position) );
+    registerParameter( dynamic_cast<Parameter *>(&start_path_curve_start) );
+    registerParameter( dynamic_cast<Parameter *>(&start_path_curve_end) );
+    
+    registerParameter( dynamic_cast<Parameter *>(&end_path) );
+    registerParameter( dynamic_cast<Parameter *>(&end_path_position) );
+    registerParameter( dynamic_cast<Parameter *>(&end_path_curve_start) );
+    registerParameter( dynamic_cast<Parameter *>(&end_path_curve_end) );
+
+    //perceived_path = true;
+    show_orig_path = true;
+    curve_start_previous_origin = start_path_curve_end.getOrigin();
+    curve_end_previous_origin = end_path_curve_end.getOrigin();
+}
+
+LPEAttachPath::~LPEAttachPath()
+{
+
+}
+
+void LPEAttachPath::resetDefaults(SPItem const * item)
+{
+    curve_start_previous_origin = start_path_curve_end.getOrigin();
+    curve_end_previous_origin = end_path_curve_end.getOrigin();
+}
+
+void LPEAttachPath::doEffect (SPCurve * curve)
+{
+    std::vector<Geom::Path> this_pathv = curve->get_pathvector();
+    if (sp_lpe_item && !this_pathv.empty()) {
+        Geom::Path p = Geom::Path(this_pathv.front().initialPoint());
+        
+        bool set_start_end = start_path_curve_end.getOrigin() != curve_start_previous_origin;
+        bool set_end_end = end_path_curve_end.getOrigin() != curve_end_previous_origin;
+        
+        if (start_path.linksToPath()) {
+
+            std::vector<Geom::Path> linked_pathv = start_path.get_pathvector();
+            Geom::Affine linkedtransform = start_path.getObject()->getRelativeTransform(sp_lpe_item);
+
+            if ( !linked_pathv.empty() )
+            {
+                Geom::Path transformedpath = linked_pathv.front() * linkedtransform;
+                start_path_curve_start.setOrigin(this_pathv.front().initialPoint());
+
+                std::vector<Geom::Point> derivs = this_pathv.front().front().pointAndDerivatives(0, 3);
+                
+                for (unsigned deriv_n = 1; deriv_n < derivs.size(); deriv_n++) {
+                    Geom::Coord length = derivs[deriv_n].length();
+                    if ( ! Geom::are_near(length, 0) ) {
+                        if (set_start_end) {
+                            start_path_position.param_set_value(transformedpath.nearestPoint(start_path_curve_end.getOrigin()));
+                        }
+                        
+                        if (start_path_position > transformedpath.size()) {
+                            start_path_position.param_set_value(transformedpath.size());
+                        } else if (start_path_position < 0) {
+                            start_path_position.param_set_value(0);
+                        }
+                        const Geom::Curve *c = start_path_position >= transformedpath.size() ? &transformedpath.back() : &transformedpath.at_index((int)start_path_position);
+
+                        std::vector<Geom::Point> derivs_2 = c->pointAndDerivatives(start_path_position >= transformedpath.size() ? 1 : (start_path_position - (int)start_path_position), 3);
+                        for (unsigned deriv_n_2 = 1; deriv_n_2 < derivs_2.size(); deriv_n_2++) {
+                            Geom::Coord length_2 = derivs[deriv_n_2].length();
+                            if ( ! Geom::are_near(length_2, 0) ) {
+                                start_path_curve_end.setOrigin(derivs_2[0]);
+                                curve_start_previous_origin = start_path_curve_end.getOrigin();
+
+                                double startangle = atan2(start_path_curve_start.getVector().y(), start_path_curve_start.getVector().x());
+                                double endangle = atan2(start_path_curve_end.getVector().y(), start_path_curve_end.getVector().x());
+                                double startderiv = atan2(derivs[deriv_n].y(), derivs[deriv_n].x());
+                                double endderiv = atan2(derivs_2[deriv_n_2].y(), derivs_2[deriv_n_2].x());
+                                Geom::Point pt1 = Geom::Point(start_path_curve_start.getVector().length() * cos(startangle + startderiv), start_path_curve_start.getVector().length() * sin(startangle + startderiv));
+                                Geom::Point pt2 = Geom::Point(start_path_curve_end.getVector().length() * cos(endangle + endderiv), start_path_curve_end.getVector().length() * sin(endangle + endderiv));
+                                p = Geom::Path(derivs_2[0]);
+                                p.appendNew<Geom::CubicBezier>(-pt2 + derivs_2[0], -pt1 + this_pathv.front().initialPoint(), this_pathv.front().initialPoint());
+                                break;
+
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        
+        p.append(this_pathv.front());
+        
+        if (end_path.linksToPath()) {
+
+            std::vector<Geom::Path> linked_pathv = end_path.get_pathvector();
+            Geom::Affine linkedtransform = end_path.getObject()->getRelativeTransform(sp_lpe_item);
+
+            if ( !linked_pathv.empty() )
+            {
+                Geom::Path transformedpath = linked_pathv.front() * linkedtransform;
+                Geom::Curve * last_seg_reverse = this_pathv.front().back().reverse();
+                
+                end_path_curve_start.setOrigin(last_seg_reverse->initialPoint());
+
+                std::vector<Geom::Point> derivs = last_seg_reverse->pointAndDerivatives(0, 3);
+                for (unsigned deriv_n = 1; deriv_n < derivs.size(); deriv_n++) {
+                    Geom::Coord length = derivs[deriv_n].length();
+                    if ( ! Geom::are_near(length, 0) ) {
+                        if (set_end_end) {
+                            end_path_position.param_set_value(transformedpath.nearestPoint(end_path_curve_end.getOrigin()));
+                        }
+                        
+                        if (end_path_position > transformedpath.size()) {
+                            end_path_position.param_set_value(transformedpath.size());
+                        } else if (end_path_position < 0) {
+                            end_path_position.param_set_value(0);
+                        }
+                        const Geom::Curve *c = end_path_position >= transformedpath.size() ? &transformedpath.back() : &transformedpath.at_index((int)end_path_position);
+
+                        std::vector<Geom::Point> derivs_2 = c->pointAndDerivatives(end_path_position >= transformedpath.size() ? 1 : (end_path_position - (int)end_path_position), 3);
+                        for (unsigned deriv_n_2 = 1; deriv_n_2 < derivs_2.size(); deriv_n_2++) {
+                            Geom::Coord length_2 = derivs[deriv_n_2].length();
+                            if ( ! Geom::are_near(length_2, 0) ) {
+                                
+                                end_path_curve_end.setOrigin(derivs_2[0]);
+                                curve_end_previous_origin = end_path_curve_end.getOrigin();
+                                
+                                double startangle = atan2(end_path_curve_start.getVector().y(), end_path_curve_start.getVector().x());
+                                double endangle = atan2(end_path_curve_end.getVector().y(), end_path_curve_end.getVector().x());
+                                double startderiv = atan2(derivs[deriv_n].y(), derivs[deriv_n].x());
+                                double endderiv = atan2(derivs_2[deriv_n_2].y(), derivs_2[deriv_n_2].x());
+                                Geom::Point pt1 = Geom::Point(end_path_curve_start.getVector().length() * cos(startangle + startderiv), end_path_curve_start.getVector().length() * sin(startangle + startderiv));
+                                Geom::Point pt2 = Geom::Point(end_path_curve_end.getVector().length() * cos(endangle + endderiv), end_path_curve_end.getVector().length() * sin(endangle + endderiv));
+                                p.appendNew<Geom::CubicBezier>(-pt1 + this_pathv.front().finalPoint(), -pt2 + derivs_2[0], derivs_2[0]);
+
+                                break;
+
+                            }
+                        }
+                        break;
+                    }
+                }
+                delete last_seg_reverse;
+            }
+        }
+        Geom::PathVector outvector;
+        outvector.push_back(p);
+        curve->set_pathvector(outvector);
+    }
+}
+
+} // 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-attach-path.h'
--- src/live_effects/lpe-attach-path.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-attach-path.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,52 @@
+#ifndef INKSCAPE_LPE_ATTACH_PATH_H
+#define INKSCAPE_LPE_ATTACH_PATH_H
+
+/*
+ * Inkscape::LPEAttachPath
+ *
+ * Copyright (C) Ted Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
+#include "live_effects/parameter/point.h"
+#include "live_effects/parameter/originalpath.h"
+#include "live_effects/parameter/vector.h"
+#include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/transformedpoint.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+class LPEAttachPath : public Effect {
+public:
+    LPEAttachPath(LivePathEffectObject *lpeobject);
+    virtual ~LPEAttachPath();
+
+    virtual void doEffect (SPCurve * curve);
+    virtual void resetDefaults(SPItem const * item);
+
+private:
+    LPEAttachPath(const LPEAttachPath&);
+    LPEAttachPath& operator=(const LPEAttachPath&);
+
+    Geom::Point curve_start_previous_origin;
+    Geom::Point curve_end_previous_origin;
+        
+    OriginalPathParam start_path;
+    ScalarParam start_path_position;
+    TransformedPointParam start_path_curve_start;
+    VectorParam start_path_curve_end;
+
+    OriginalPathParam end_path;
+    ScalarParam end_path_position;
+    TransformedPointParam end_path_curve_start;
+    VectorParam end_path_curve_end;
+};
+
+}; //namespace LivePathEffect
+}; //namespace Inkscape
+
+#endif
 
=== added file 'src/live_effects/lpe-bounding-box.cpp'
--- src/live_effects/lpe-bounding-box.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-bounding-box.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glibmm/i18n.h>
+
+#include "live_effects/lpe-bounding-box.h"
+
+#include "display/curve.h"
+#include "sp-item.h"
+#include "2geom/path.h"
+#include "sp-shape.h"
+#include "sp-text.h"
+#include "2geom/bezier-curve.h"
+#include "lpe-bounding-box.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+LPEBoundingBox::LPEBoundingBox(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    linked_path(_("Linked path:"), _("Path from which to take the original path data"), "linkedpath", &wr, this),
+    visual_bounds(_("Visual Bounds"), _("Uses the visual bounding box"), "visualbounds", &wr, this)
+{
+    registerParameter( dynamic_cast<Parameter *>(&linked_path) );
+    registerParameter( dynamic_cast<Parameter *>(&visual_bounds) );
+    //perceived_path = true;
+}
+
+LPEBoundingBox::~LPEBoundingBox()
+{
+
+}
+
+void LPEBoundingBox::doEffect (SPCurve * curve)
+{
+    if (curve) {
+        if ( linked_path.linksToPath() && linked_path.getObject() ) {
+            SPItem * item = linked_path.getObject();
+            Geom::OptRect bbox = visual_bounds.get_value() ? item->visualBounds() : item->geometricBounds();
+            Geom::Path p(Geom::Point(bbox->left(), bbox->top()));
+            p.appendNew<Geom::LineSegment>(Geom::Point(bbox->right(), bbox->top()));
+            p.appendNew<Geom::LineSegment>(Geom::Point(bbox->right(), bbox->bottom()));
+            p.appendNew<Geom::LineSegment>(Geom::Point(bbox->left(), bbox->bottom()));
+            p.appendNew<Geom::LineSegment>(Geom::Point(bbox->left(), bbox->top()));
+            std::vector<Geom::Path> out;
+            out.push_back(p);
+            curve->set_pathvector(out);
+        }
+    }
+}
+
+} // 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-bounding-box.h'
--- src/live_effects/lpe-bounding-box.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-bounding-box.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,37 @@
+#ifndef INKSCAPE_LPE_BOUNDING_BOX_H
+#define INKSCAPE_LPE_BOUNDING_BOX_H
+
+/*
+ * Inkscape::LPEFillBetweenStrokes
+ *
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/effect.h"
+#include "live_effects/parameter/originalpath.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+class LPEBoundingBox : public Effect {
+public:
+    LPEBoundingBox(LivePathEffectObject *lpeobject);
+    virtual ~LPEBoundingBox();
+
+    virtual void doEffect (SPCurve * curve);
+
+private:
+    OriginalPathParam  linked_path;
+    BoolParam visual_bounds;
+
+private:
+    LPEBoundingBox(const LPEBoundingBox&);
+    LPEBoundingBox& operator=(const LPEBoundingBox&);
+};
+
+}; //namespace LivePathEffect
+}; //namespace Inkscape
+
+#endif
 
=== added file 'src/live_effects/lpe-ellipse_5pts.cpp'
--- src/live_effects/lpe-ellipse_5pts.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-ellipse_5pts.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,214 @@
+/** \file
+ * LPE "Ellipse through 5 points" implementation
+ */
+
+/*
+ * Authors:
+ *   Theodore Janeczko
+ *
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/lpe-ellipse_5pts.h"
+
+// You might need to include other 2geom files. You can add them here:
+#include <glibmm/i18n.h>
+#include <2geom/path.h>
+#include <2geom/circle.h>
+#include <2geom/ellipse.h>
+#include <2geom/path-sink.h>
+#include "inkscape.h"
+#include "desktop.h"
+#include "message-stack.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+LPEEllipse5Pts::LPEEllipse5Pts(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject)
+{
+    //perceived_path = true;
+}
+
+LPEEllipse5Pts::~LPEEllipse5Pts()
+{
+}
+
+static double _det3(double (*mat)[3])
+{
+    for (int i = 0; i < 2; i++)
+    {
+        for (int j = i + 1; j < 3; j++)
+        {
+            for (int k = i + 1; k < 3; k++)
+            {
+                mat[j][k] = (mat[j][k] * mat[i][i] - mat[j][i] * mat[i][k]);
+                if (i) mat[j][k] /= mat[i-1][i-1];
+            }
+        }
+    }
+    return mat[2][2];
+}
+static double _det5(double (*mat)[5])
+{
+    for (int i = 0; i < 4; i++)
+    {
+        for (int j = i + 1; j < 5; j++)
+        {
+            for (int k = i + 1; k < 5; k++)
+            {
+                mat[j][k] = (mat[j][k] * mat[i][i] - mat[j][i] * mat[i][k]);
+                if (i) mat[j][k] /= mat[i-1][i-1];
+            }
+        }
+    }
+    return mat[4][4];
+}
+
+std::vector<Geom::Path>
+LPEEllipse5Pts::doEffect_path (std::vector<Geom::Path> const & path_in)
+{
+    std::vector<Geom::Path> path_out = std::vector<Geom::Path>();
+
+    if (path_in[0].size() < 4) {
+        
+        SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Five points required for constructing an ellipse"));
+        return path_in;
+    }
+    // we assume that the path has >= 3 nodes
+    Geom::Point A = path_in[0].initialPoint();
+    Geom::Point B = path_in[0].pointAt(1);
+    Geom::Point C = path_in[0].pointAt(2);
+    Geom::Point D = path_in[0].pointAt(3);
+    Geom::Point E = path_in[0].pointAt(4);
+
+    using namespace Geom;
+
+    double rowmajor_matrix[5][6] =
+    {
+        {A.x()*A.x(), A.x()*A.y(), A.y()*A.y(), A.x(), A.y(), 1},
+        {B.x()*B.x(), B.x()*B.y(), B.y()*B.y(), B.x(), B.y(), 1},
+        {C.x()*C.x(), C.x()*C.y(), C.y()*C.y(), C.x(), C.y(), 1},
+        {D.x()*D.x(), D.x()*D.y(), D.y()*D.y(), D.x(), D.y(), 1},
+        {E.x()*E.x(), E.x()*E.y(), E.y()*E.y(), E.x(), E.y(), 1}
+    };
+    
+    double mat_a[5][5] =
+    {
+        {rowmajor_matrix[0][1], rowmajor_matrix[1][1], rowmajor_matrix[2][1], rowmajor_matrix[3][1], rowmajor_matrix[4][1]},
+        {rowmajor_matrix[0][2], rowmajor_matrix[1][2], rowmajor_matrix[2][2], rowmajor_matrix[3][2], rowmajor_matrix[4][2]},
+        {rowmajor_matrix[0][3], rowmajor_matrix[1][3], rowmajor_matrix[2][3], rowmajor_matrix[3][3], rowmajor_matrix[4][3]},
+        {rowmajor_matrix[0][4], rowmajor_matrix[1][4], rowmajor_matrix[2][4], rowmajor_matrix[3][4], rowmajor_matrix[4][4]},
+        {rowmajor_matrix[0][5], rowmajor_matrix[1][5], rowmajor_matrix[2][5], rowmajor_matrix[3][5], rowmajor_matrix[4][5]}
+    };
+    double mat_b[5][5] =
+    {
+        {rowmajor_matrix[0][0], rowmajor_matrix[1][0], rowmajor_matrix[2][0], rowmajor_matrix[3][0], rowmajor_matrix[4][0]},
+        {rowmajor_matrix[0][2], rowmajor_matrix[1][2], rowmajor_matrix[2][2], rowmajor_matrix[3][2], rowmajor_matrix[4][2]},
+        {rowmajor_matrix[0][3], rowmajor_matrix[1][3], rowmajor_matrix[2][3], rowmajor_matrix[3][3], rowmajor_matrix[4][3]},
+        {rowmajor_matrix[0][4], rowmajor_matrix[1][4], rowmajor_matrix[2][4], rowmajor_matrix[3][4], rowmajor_matrix[4][4]},
+        {rowmajor_matrix[0][5], rowmajor_matrix[1][5], rowmajor_matrix[2][5], rowmajor_matrix[3][5], rowmajor_matrix[4][5]}
+    };
+    double mat_c[5][5] =
+    {
+        {rowmajor_matrix[0][0], rowmajor_matrix[1][0], rowmajor_matrix[2][0], rowmajor_matrix[3][0], rowmajor_matrix[4][0]},
+        {rowmajor_matrix[0][1], rowmajor_matrix[1][1], rowmajor_matrix[2][1], rowmajor_matrix[3][1], rowmajor_matrix[4][1]},
+        {rowmajor_matrix[0][3], rowmajor_matrix[1][3], rowmajor_matrix[2][3], rowmajor_matrix[3][3], rowmajor_matrix[4][3]},
+        {rowmajor_matrix[0][4], rowmajor_matrix[1][4], rowmajor_matrix[2][4], rowmajor_matrix[3][4], rowmajor_matrix[4][4]},
+        {rowmajor_matrix[0][5], rowmajor_matrix[1][5], rowmajor_matrix[2][5], rowmajor_matrix[3][5], rowmajor_matrix[4][5]}
+    };
+    double mat_d[5][5] =
+    {
+        {rowmajor_matrix[0][0], rowmajor_matrix[1][0], rowmajor_matrix[2][0], rowmajor_matrix[3][0], rowmajor_matrix[4][0]},
+        {rowmajor_matrix[0][1], rowmajor_matrix[1][1], rowmajor_matrix[2][1], rowmajor_matrix[3][1], rowmajor_matrix[4][1]},
+        {rowmajor_matrix[0][2], rowmajor_matrix[1][2], rowmajor_matrix[2][2], rowmajor_matrix[3][2], rowmajor_matrix[4][2]},
+        {rowmajor_matrix[0][4], rowmajor_matrix[1][4], rowmajor_matrix[2][4], rowmajor_matrix[3][4], rowmajor_matrix[4][4]},
+        {rowmajor_matrix[0][5], rowmajor_matrix[1][5], rowmajor_matrix[2][5], rowmajor_matrix[3][5], rowmajor_matrix[4][5]}
+    };
+    double mat_e[5][5] =
+    {
+        {rowmajor_matrix[0][0], rowmajor_matrix[1][0], rowmajor_matrix[2][0], rowmajor_matrix[3][0], rowmajor_matrix[4][0]},
+        {rowmajor_matrix[0][1], rowmajor_matrix[1][1], rowmajor_matrix[2][1], rowmajor_matrix[3][1], rowmajor_matrix[4][1]},
+        {rowmajor_matrix[0][2], rowmajor_matrix[1][2], rowmajor_matrix[2][2], rowmajor_matrix[3][2], rowmajor_matrix[4][2]},
+        {rowmajor_matrix[0][3], rowmajor_matrix[1][3], rowmajor_matrix[2][3], rowmajor_matrix[3][3], rowmajor_matrix[4][3]},
+        {rowmajor_matrix[0][5], rowmajor_matrix[1][5], rowmajor_matrix[2][5], rowmajor_matrix[3][5], rowmajor_matrix[4][5]}
+    };
+    double mat_f[5][5] =
+    {
+        {rowmajor_matrix[0][0], rowmajor_matrix[1][0], rowmajor_matrix[2][0], rowmajor_matrix[3][0], rowmajor_matrix[4][0]},
+        {rowmajor_matrix[0][1], rowmajor_matrix[1][1], rowmajor_matrix[2][1], rowmajor_matrix[3][1], rowmajor_matrix[4][1]},
+        {rowmajor_matrix[0][2], rowmajor_matrix[1][2], rowmajor_matrix[2][2], rowmajor_matrix[3][2], rowmajor_matrix[4][2]},
+        {rowmajor_matrix[0][3], rowmajor_matrix[1][3], rowmajor_matrix[2][3], rowmajor_matrix[3][3], rowmajor_matrix[4][3]},
+        {rowmajor_matrix[0][4], rowmajor_matrix[1][4], rowmajor_matrix[2][4], rowmajor_matrix[3][4], rowmajor_matrix[4][4]}
+    };
+    
+    double a1 = _det5(mat_a);
+    double b1 = -_det5(mat_b);
+    double c1 = _det5(mat_c);
+    double d1 = -_det5(mat_d);
+    double e1 = _det5(mat_e);
+    double f1 = -_det5(mat_f);
+    
+    double mat_check[][3] = 
+    {
+        {a1, b1/2, d1/2},
+        {b1/2, c1, e1/2},
+        {d1/2, e1/2, f1}
+    };
+    
+    if (_det3(mat_check) == 0 || a1*c1 - b1*b1/4 <= 0) {
+        SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No ellipse found for specified points"));
+        return path_in;
+    }
+    
+    Geom::Ellipse el(a1, b1, c1, d1, e1, f1);
+    
+    double s, e;
+    double x0, y0, x1, y1, x2, y2, x3, y3;
+    double len;
+
+    // figure out if we have a slice, guarding against rounding errors
+
+    Path p(Geom::Point(cos(0), sin(0)));
+
+    double end = 2 * M_PI;
+    for (s = 0; s < end; s += M_PI_2) {
+        e = s + M_PI_2;
+        if (e > end)
+            e = end;
+        len = 4*tan((e - s)/4)/3;
+        x0 = cos(s);
+        y0 = sin(s);
+        x1 = x0 + len * cos(s + M_PI_2);
+        y1 = y0 + len * sin(s + M_PI_2);
+        x3 = cos(e);
+        y3 = sin(e);
+        x2 = x3 + len * cos(e - M_PI_2);
+        y2 = y3 + len * sin(e - M_PI_2);
+        p.appendNew<Geom::CubicBezier>(Geom::Point(x1,y1), Geom::Point(x2,y2), Geom::Point(x3,y3));
+    }
+    
+    Geom::Affine aff = Geom::Scale(el.ray(Geom::X), el.ray(Geom::Y)) * Geom::Rotate(el.rot_angle()) * Geom::Translate(el.center());
+    
+    path_out.push_back(p * aff);
+
+    return path_out;
+}
+
+/* ######################## */
+
+} //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-ellipse_5pts.h'
--- src/live_effects/lpe-ellipse_5pts.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-ellipse_5pts.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,50 @@
+#ifndef INKSCAPE_LPE_ELLIPSE_5PTS_H
+#define INKSCAPE_LPE_ELLIPSE_5PTS_H
+
+/** \file
+ * LPE "Ellipse through 5 points" implementation
+ */
+
+/*
+ * Authors:
+ *   Theodore Janeczko
+ *
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
+#include "live_effects/parameter/point.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+class LPEEllipse5Pts : public Effect {
+public:
+    LPEEllipse5Pts(LivePathEffectObject *lpeobject);
+    virtual ~LPEEllipse5Pts();
+
+    virtual std::vector<Geom::Path> doEffect_path (std::vector<Geom::Path> const & path_in);
+
+private:
+    LPEEllipse5Pts(const LPEEllipse5Pts&);
+    LPEEllipse5Pts& operator=(const LPEEllipse5Pts&);
+};
+
+} //namespace LivePathEffect
+} //namespace Inkscape
+
+#endif
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
 
=== added file 'src/live_effects/lpe-fill-between-many.cpp'
--- src/live_effects/lpe-fill-between-many.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-fill-between-many.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * 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-item.h"
+#include "2geom/path.h"
+#include "sp-shape.h"
+#include "sp-text.h"
+#include "2geom/bezier-curve.h"
+
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+LPEFillBetweenMany::LPEFillBetweenMany(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    linked_paths(_("Linked path:"), _("Paths from which to take the original path data"), "linkedpaths", &wr, this)
+{
+    registerParameter( dynamic_cast<Parameter *>(&linked_paths) );
+    //perceived_path = true;
+}
+
+LPEFillBetweenMany::~LPEFillBetweenMany()
+{
+
+}
+
+void LPEFillBetweenMany::doEffect (SPCurve * curve)
+{
+    std::vector<Geom::Path> res_pathv;
+    SPItem * firstObj = NULL;
+    for (std::vector<PathAndDirection*>::iterator iter = linked_paths._vector.begin(); iter != linked_paths._vector.end(); iter++) {
+        SPObject *obj;
+        if ((*iter)->ref.isAttached() && (obj = (*iter)->ref.getObject()) && SP_IS_ITEM(obj) && !(*iter)->_pathvector.empty()) {
+            Geom::Path linked_path;
+            if ((*iter)->reversed) {
+                linked_path = (*iter)->_pathvector.front().reverse();
+            } else {
+                linked_path = (*iter)->_pathvector.front();
+            }
+            
+            if (!res_pathv.empty()) {
+                linked_path = linked_path * SP_ITEM(obj)->getRelativeTransform(firstObj);
+                res_pathv.front().appendNew<Geom::LineSegment>(linked_path.initialPoint());
+                res_pathv.front().append(linked_path);
+            } else {
+                firstObj = SP_ITEM(obj);
+                res_pathv.push_back(linked_path);
+            }
+        }
+    }
+    if (!res_pathv.empty()) {
+        res_pathv.front().close();
+    }
+    curve->set_pathvector(res_pathv);
+}
+
+} // 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-fill-between-many.h'
--- src/live_effects/lpe-fill-between-many.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-fill-between-many.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,36 @@
+#ifndef INKSCAPE_LPE_FILL_BETWEEN_MANY_H
+#define INKSCAPE_LPE_FILL_BETWEEN_MANY_H
+
+/*
+ * Inkscape::LPEFillBetweenStrokes
+ *
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/effect.h"
+#include "live_effects/parameter/originalpatharray.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+class LPEFillBetweenMany : public Effect {
+public:
+    LPEFillBetweenMany(LivePathEffectObject *lpeobject);
+    virtual ~LPEFillBetweenMany();
+    
+    virtual void doEffect (SPCurve * curve);
+
+private:
+    OriginalPathArrayParam linked_paths;
+
+private:
+    LPEFillBetweenMany(const LPEFillBetweenMany&);
+    LPEFillBetweenMany& operator=(const LPEFillBetweenMany&);
+};
+
+}; //namespace LivePathEffect
+}; //namespace Inkscape
+
+#endif
 
=== added file 'src/live_effects/lpe-fill-between-strokes.cpp'
--- src/live_effects/lpe-fill-between-strokes.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-fill-between-strokes.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glibmm/i18n.h>
+
+#include "live_effects/lpe-fill-between-strokes.h"
+
+#include "display/curve.h"
+#include "sp-item.h"
+#include "2geom/path.h"
+#include "sp-shape.h"
+#include "sp-text.h"
+#include "2geom/bezier-curve.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+LPEFillBetweenStrokes::LPEFillBetweenStrokes(LivePathEffectObject *lpeobject) :
+    Effect(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)
+{
+    registerParameter( dynamic_cast<Parameter *>(&linked_path) );
+    registerParameter( dynamic_cast<Parameter *>(&second_path) );
+    registerParameter( dynamic_cast<Parameter *>(&reverse_second) );
+    //perceived_path = true;
+}
+
+LPEFillBetweenStrokes::~LPEFillBetweenStrokes()
+{
+
+}
+
+void LPEFillBetweenStrokes::doEffect (SPCurve * curve)
+{
+    if (curve) {
+        if ( linked_path.linksToPath() && second_path.linksToPath() && linked_path.getObject() && second_path.getObject() ) {
+            std::vector<Geom::Path> linked_pathv = linked_path.get_pathvector();
+            std::vector<Geom::Path> second_pathv = second_path.get_pathvector();
+            std::vector<Geom::Path> result_linked_pathv;
+            std::vector<Geom::Path> result_second_pathv;
+            Geom::Affine second_transform = second_path.getObject()->getRelativeTransform(linked_path.getObject());
+
+            for (std::vector<Geom::Path>::iterator iter = linked_pathv.begin(); iter != linked_pathv.end(); ++iter)
+            {
+                result_linked_pathv.push_back((*iter));
+            }
+            for (std::vector<Geom::Path>::iterator iter = second_pathv.begin(); iter != second_pathv.end(); ++iter)
+            {
+                result_second_pathv.push_back((*iter) * second_transform);
+            }
+
+            if ( !result_linked_pathv.empty() && !result_second_pathv.empty() && !result_linked_pathv.front().closed() ) {
+                if (reverse_second.get_value())
+                {
+                    result_linked_pathv.front().appendNew<Geom::LineSegment>(result_second_pathv.front().finalPoint());
+                    result_linked_pathv.front().append(result_second_pathv.front().reverse());
+                }
+                else
+                {
+                    result_linked_pathv.front().appendNew<Geom::LineSegment>(result_second_pathv.front().initialPoint());
+                    result_linked_pathv.front().append(result_second_pathv.front());
+                }
+                curve->set_pathvector(result_linked_pathv);
+            }
+            else if ( !result_linked_pathv.empty() ) {
+                curve->set_pathvector(result_linked_pathv);
+            }
+            else if ( !result_second_pathv.empty() ) {
+                curve->set_pathvector(result_second_pathv);
+            }
+        }
+        else if ( linked_path.linksToPath() && linked_path.getObject() ) {
+            std::vector<Geom::Path> linked_pathv = linked_path.get_pathvector();
+            std::vector<Geom::Path> result_pathv;
+
+            for (std::vector<Geom::Path>::iterator iter = linked_pathv.begin(); iter != linked_pathv.end(); ++iter)
+            {
+                result_pathv.push_back((*iter));
+            }
+            if ( !result_pathv.empty() ) {
+                curve->set_pathvector(result_pathv);
+            }
+        }
+        else if ( second_path.linksToPath() && second_path.getObject() ) {
+            std::vector<Geom::Path> second_pathv = second_path.get_pathvector();
+            std::vector<Geom::Path> result_pathv;
+
+            for (std::vector<Geom::Path>::iterator iter = second_pathv.begin(); iter != second_pathv.end(); ++iter)
+            {
+                result_pathv.push_back((*iter));
+            }
+            if ( !result_pathv.empty() ) {
+                curve->set_pathvector(result_pathv);
+            }
+        }
+    }
+}
+
+} // 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-fill-between-strokes.h'
--- src/live_effects/lpe-fill-between-strokes.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-fill-between-strokes.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,38 @@
+#ifndef INKSCAPE_LPE_FILL_BETWEEN_STROKES_H
+#define INKSCAPE_LPE_FILL_BETWEEN_STROKES_H
+
+/*
+ * Inkscape::LPEFillBetweenStrokes
+ *
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/effect.h"
+#include "live_effects/parameter/originalpath.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+class LPEFillBetweenStrokes : public Effect {
+public:
+    LPEFillBetweenStrokes(LivePathEffectObject *lpeobject);
+    virtual ~LPEFillBetweenStrokes();
+    
+    virtual void doEffect (SPCurve * curve);
+
+private:
+    OriginalPathParam  linked_path;
+    OriginalPathParam  second_path;
+    BoolParam reverse_second;
+
+private:
+    LPEFillBetweenStrokes(const LPEFillBetweenStrokes&);
+    LPEFillBetweenStrokes& operator=(const LPEFillBetweenStrokes&);
+};
+
+}; //namespace LivePathEffect
+}; //namespace Inkscape
+
+#endif
 
=== added file 'src/live_effects/lpe-jointype.cpp'
--- src/live_effects/lpe-jointype.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-jointype.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,184 @@
+/** \file
+ * LPE "Join Type" implementation
+ */
+ /* Authors:
+ *  
+ *	 Liam P White
+ *
+ * Copyright (C) 2014 Authors
+ *
+ * Released under GNU GPL v2, read the file 'COPYING' for more information
+ */
+
+#include <math.h>
+
+#include "live_effects/parameter/enum.h"
+#include "live_effects/pathoutlineprovider.h"
+
+#include "sp-shape.h"
+#include "style.h"
+#include "xml/repr.h"
+#include "sp-paint-server.h"
+#include "svg/svg-color.h"
+#include "desktop-style.h"
+#include "svg/css-ostringstream.h"
+#include "display/curve.h"
+
+#include <2geom/path.h>
+#include <2geom/svg-elliptical-arc.h>
+
+#include "lpe-jointype.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+static const Util::EnumData<unsigned> JoinTypeData[] = {
+	{LINEJOIN_STRAIGHT, N_("Beveled"), "bevel"},
+    {LINEJOIN_ROUND, N_("Rounded"), "round"},
+    {LINEJOIN_POINTY, N_("Miter"), "miter"},
+	{LINEJOIN_REFLECTED,  N_("Reflected"), "extrapolated"},
+    {LINEJOIN_EXTRAPOLATED, N_("Extrapolated arc"), "extrp_arc"}
+};
+
+static const Util::EnumData<unsigned> CapTypeData[] = {
+	{BUTT_STRAIGHT, N_("Butt"), "butt"},
+	{BUTT_ROUND, N_("Rounded"), "round"},
+	{BUTT_SQUARE, N_("Square"), "square"},
+	{BUTT_POINTY, N_("Peak"), "peak"},
+	{BUTT_LEANED, N_("Leaned"), "leaned"}
+};
+
+static const Util::EnumDataConverter<unsigned> CapTypeConverter(CapTypeData, sizeof(CapTypeData)/sizeof(*CapTypeData));
+static const Util::EnumDataConverter<unsigned> JoinTypeConverter(JoinTypeData, sizeof(JoinTypeData)/sizeof(*JoinTypeData));
+
+LPEJoinType::LPEJoinType(LivePathEffectObject *lpeobject) :
+	Effect(lpeobject),
+	line_width(_("Line width"), _("Thickness of the stroke"), "line_width", &wr, this, 1.),
+	linecap_type(_("Line cap"), _("The end shape of the stroke"), "linecap_type", CapTypeConverter, &wr, this, butt_straight),
+	linejoin_type(_("Join:"), _("Determines the shape of the path's corners"),  "linejoin_type", JoinTypeConverter, &wr, this, LINEJOIN_EXTRAPOLATED),
+	start_lean(_("Start path lean"), _("Start path lean"), "start_lean", &wr, this, 0.),
+	end_lean(_("End path lean"), _("End path lean"), "end_lean", &wr, this, 0.),
+	miter_limit(_("Miter limit:"), _("Maximum length of the miter join (in units of stroke width)"), "miter_limit", &wr, this, 100.),
+	attempt_force_join(_("Force miter"), _("Overrides the miter limit and forces a join."), "attempt_force_join", &wr, this, true)
+{
+	show_orig_path = true;
+	registerParameter( dynamic_cast<Parameter *>(&linecap_type) );
+	registerParameter( dynamic_cast<Parameter *>(&line_width) );
+	registerParameter( dynamic_cast<Parameter *>(&linejoin_type) );
+	registerParameter( dynamic_cast<Parameter *>(&start_lean) );
+	registerParameter( dynamic_cast<Parameter *>(&end_lean) );
+	registerParameter( dynamic_cast<Parameter *>(&miter_limit) );
+	registerParameter( dynamic_cast<Parameter *>(&attempt_force_join) );
+	was_initialized = false;
+	start_lean.param_set_range(-1,1);
+	start_lean.param_set_increments(0.1, 0.1);
+	start_lean.param_set_digits(4);
+	end_lean.param_set_range(-1,1);
+	end_lean.param_set_increments(0.1, 0.1);
+	end_lean.param_set_digits(4);
+}
+
+LPEJoinType::~LPEJoinType()
+{
+}
+
+//from LPEPowerStroke -- sets fill if stroke color because we will
+//be converting to a fill to make the new join.
+
+void LPEJoinType::doOnApply(SPLPEItem const* lpeitem)
+{
+	if (SP_IS_SHAPE(lpeitem)) {
+        SPLPEItem* item = const_cast<SPLPEItem*>(lpeitem);
+        double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed : 1.;
+        
+        SPCSSAttr *css = sp_repr_css_attr_new ();
+        if (true) {
+            if (lpeitem->style->stroke.isPaintserver()) {
+                SPPaintServer * server = lpeitem->style->getStrokePaintServer();
+                if (server) {
+                    Glib::ustring str;
+                    str += "url(#";
+                    str += server->getId();
+                    str += ")";
+                    sp_repr_css_set_property (css, "fill", str.c_str());
+                }
+            } else if (lpeitem->style->stroke.isColor()) {
+                gchar c[64];
+                sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+                sp_repr_css_set_property (css, "fill", c);
+            } else {
+                sp_repr_css_set_property (css, "fill", "none");
+            }
+        } else {
+            sp_repr_css_unset_property (css, "fill");
+        }
+        
+        sp_repr_css_set_property(css, "stroke", "none");
+        
+        sp_desktop_apply_css_recursive(item, css, true);
+        sp_repr_css_attr_unref (css);
+	if (!was_initialized)
+	{
+		was_initialized = true;
+		line_width.param_set_value(width);
+	}
+    } else {
+        g_warning("LPE Join Type can only be applied to paths (not groups).");
+    }
+}
+
+//from LPEPowerStroke -- sets stroke color from existing fill color
+
+void LPEJoinType::doOnRemove(SPLPEItem const* lpeitem)
+{
+	
+	if (SP_IS_SHAPE(lpeitem)) {
+        SPLPEItem *item = const_cast<SPLPEItem*>(lpeitem);
+
+        SPCSSAttr *css = sp_repr_css_attr_new ();
+        if (true) {
+            if (lpeitem->style->fill.isPaintserver()) {
+                SPPaintServer * server = lpeitem->style->getFillPaintServer();
+                if (server) {
+                    Glib::ustring str;
+                    str += "url(#";
+                    str += server->getId();
+                    str += ")";
+                    sp_repr_css_set_property (css, "stroke", str.c_str());
+                }
+            } else if (lpeitem->style->fill.isColor()) {
+                gchar c[64];
+                sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+                sp_repr_css_set_property (css, "stroke", c);
+            } else {
+                sp_repr_css_set_property (css, "stroke", "none");
+            }
+        } else {
+            sp_repr_css_unset_property (css, "stroke");
+        }
+
+	Inkscape::CSSOStringStream os;
+        os << fabs(line_width);
+        sp_repr_css_set_property (css, "stroke-width", os.str().c_str());
+
+        sp_repr_css_set_property(css, "fill", "none");
+
+        sp_desktop_apply_css_recursive(item, css, true);
+        sp_repr_css_attr_unref (css);
+        item->updateRepr();
+    }
+}
+
+//NOTE: I originally had all the outliner functions defined in here, but they were actually useful
+//enough for other LPEs so I moved them all into pathoutlineprovider.cpp. The code here is just a 
+//wrapper around it.
+std::vector<Geom::Path> LPEJoinType::doEffect_path(std::vector<Geom::Path> const & path_in)
+{       
+	return Outline::PathVectorOutline(path_in, line_width, static_cast<ButtTypeMod>(linecap_type.get_value()), 
+                                      static_cast<LineJoinType>(linejoin_type.get_value()),
+						              (attempt_force_join ? std::numeric_limits<double>::max() : miter_limit),
+                                      start_lean/2 ,end_lean/2);
+}
+
+} //namespace LivePathEffect
+} //namespace Inkscape
 
=== added file 'src/live_effects/lpe-jointype.h'
--- src/live_effects/lpe-jointype.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-jointype.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,45 @@
+/* Authors:
+ * Liam P White
+ *
+ * Copyright (C) 2014 Authors
+ *
+ * Released under GNU GPL v2, read the file COPYING for more information
+ */
+#ifndef INKSCAPE_LPE_JOINTYPE_H
+#define INKSCAPE_LPE_JOINTYPE_H
+ 
+#include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
+#include "live_effects/parameter/point.h"
+#include "live_effects/parameter/enum.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+ 
+class LPEJoinType : public Effect {
+public:
+	LPEJoinType(LivePathEffectObject *lpeobject);
+	virtual ~LPEJoinType();
+	
+	virtual void doOnApply(SPLPEItem const* lpeitem);
+	virtual void doOnRemove(SPLPEItem const* lpeitem);
+	virtual std::vector <Geom::Path> doEffect_path (std::vector<Geom::Path> const & path_in);
+
+private:
+	LPEJoinType(const LPEJoinType&);
+	LPEJoinType& operator=(const LPEJoinType&);
+	
+	ScalarParam line_width;
+	EnumParam<unsigned> linecap_type;
+	EnumParam<unsigned> linejoin_type;
+	ScalarParam start_lean;
+	ScalarParam end_lean;
+	ScalarParam miter_limit;
+	BoolParam attempt_force_join;
+	bool was_initialized;
+};
+
+} //namespace LivePathEffect
+} //namespace Inkscape
+
+#endif
 
=== modified file 'src/live_effects/lpe-knot.cpp'
--- src/live_effects/lpe-knot.cpp	2014-08-31 18:17:26 +0000
+++ src/live_effects/lpe-knot.cpp	2014-09-07 17:02:32 +0000
@@ -537,6 +537,10 @@
 {
     using namespace Geom;
     original_bbox(lpeitem);
+    
+    if (SP_IS_PATH(lpeitem)) {
+        supplied_path = SP_PATH(lpeitem)->getCurve()->get_pathvector();
+    }
 
     gpaths.clear();
     gstroke_widths.clear();
 
=== modified file 'src/live_effects/lpe-knot.h'
--- src/live_effects/lpe-knot.h	2014-06-16 21:34:16 +0000
+++ src/live_effects/lpe-knot.h	2014-09-07 17:02:32 +0000
@@ -64,7 +64,8 @@
   void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
 
 protected:
-    virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
+  virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
+  std::vector<Geom::Path> supplied_path; //for knotholder business
   
 private:
   void updateSwitcher();
 
=== modified file 'src/live_effects/lpe-powerstroke-interpolators.h'
--- src/live_effects/lpe-powerstroke-interpolators.h	2014-08-23 17:14:02 +0000
+++ src/live_effects/lpe-powerstroke-interpolators.h	2014-09-07 17:02:32 +0000
@@ -28,6 +28,7 @@
   INTERP_CUBICBEZIER,
   INTERP_CUBICBEZIER_JOHAN,
   INTERP_SPIRO,
+  INTERP_CUBICBEZIER_SMOOTH,
   INTERP_CENTRIPETAL_CATMULLROM
 };
 
@@ -134,6 +135,43 @@
     CubicBezierJohan& operator=(const CubicBezierJohan&);
 };
 
+/// @todo invent name for this class
+class CubicBezierSmooth : public Interpolator {
+public:
+    CubicBezierSmooth(double beta = 0.2) {
+        _beta = beta;
+    };
+    virtual ~CubicBezierSmooth() {};
+
+    virtual Path interpolateToPath(std::vector<Point> const &points) const {
+        Path fit;
+        fit.start(points.at(0));
+        unsigned int num_points = points.size();
+        for (unsigned int i = 1; i < num_points; ++i) {
+            Point p0 = points.at(i-1);
+            Point p1 = points.at(i);
+            Point dx = Point(p1[X] - p0[X], 0);
+            if (i == 1) {
+                fit.appendNew<CubicBezier>(p0, p1-0.75*dx, p1);
+            } else if (i == points.size() - 1) {
+                fit.appendNew<CubicBezier>(p0+0.75*dx, p1, p1);
+            } else {
+                fit.appendNew<CubicBezier>(p0+_beta*dx, p1-_beta*dx, p1);
+            }
+        }
+        return fit;
+    };
+
+    void setBeta(double beta) {
+        _beta = beta;
+    }
+
+    double _beta;
+
+private:
+    CubicBezierSmooth(const CubicBezierSmooth&);
+    CubicBezierSmooth& operator=(const CubicBezierSmooth&);
+};
 
 class SpiroInterpolator : public Interpolator {
 public:
@@ -261,6 +299,8 @@
         return new Geom::Interpolate::CubicBezierJohan();
       case INTERP_SPIRO:
         return new Geom::Interpolate::SpiroInterpolator();
+      case INTERP_CUBICBEZIER_SMOOTH:
+        return new Geom::Interpolate::CubicBezierSmooth();
       case INTERP_CENTRIPETAL_CATMULLROM:
         return new Geom::Interpolate::CentripetalCatmullRomInterpolator();
       default:
 
=== modified file 'src/live_effects/lpe-powerstroke.cpp'
--- src/live_effects/lpe-powerstroke.cpp	2014-08-23 16:39:36 +0000
+++ src/live_effects/lpe-powerstroke.cpp	2014-09-07 17:02:32 +0000
@@ -15,6 +15,11 @@
 
 #include "sp-shape.h"
 #include "style.h"
+#include "xml/repr.h"
+#include "sp-paint-server.h"
+#include "svg/svg-color.h"
+#include "desktop-style.h"
+#include "svg/css-ostringstream.h"
 #include "display/curve.h"
 
 #include <2geom/path.h>
@@ -185,6 +190,7 @@
 namespace LivePathEffect {
 
 static const Util::EnumData<unsigned> InterpolatorTypeData[] = {
+    {Geom::Interpolate::INTERP_CUBICBEZIER_SMOOTH,  N_("CubicBezierSmooth"), "CubicBezierSmooth"},
     {Geom::Interpolate::INTERP_LINEAR          , N_("Linear"), "Linear"},
     {Geom::Interpolate::INTERP_CUBICBEZIER          , N_("CubicBezierFit"), "CubicBezierFit"},
     {Geom::Interpolate::INTERP_CUBICBEZIER_JOHAN     , N_("CubicBezierJohan"), "CubicBezierJohan"},
@@ -223,9 +229,7 @@
     {LINEJOIN_EXTRP_MITER,  N_("Extrapolated"),      "extrapolated"},
     {LINEJOIN_MITER, N_("Miter"),     "miter"},
     {LINEJOIN_SPIRO, N_("Spiro"),     "spiro"},
-#ifdef LPE_ENABLE_TEST_EFFECTS
     {LINEJOIN_EXTRP_MITER_ARC, N_("Extrapolated arc"),     "extrp_arc"}, 
-#endif
 };
 static const Util::EnumDataConverter<unsigned> LineJoinTypeConverter(LineJoinTypeData, sizeof(LineJoinTypeData)/sizeof(*LineJoinTypeData));
 
@@ -233,12 +237,12 @@
     Effect(lpeobject),
     offset_points(_("Offset points"), _("Offset points"), "offset_points", &wr, this),
     sort_points(_("Sort points"), _("Sort offset points according to their time value along the curve"), "sort_points", &wr, this, true),
-    interpolator_type(_("Interpolator type:"), _("Determines which kind of interpolator will be used to interpolate between stroke width along the path"), "interpolator_type", InterpolatorTypeConverter, &wr, this, Geom::Interpolate::INTERP_CUBICBEZIER_JOHAN),
+    interpolator_type(_("Interpolator type:"), _("Determines which kind of interpolator will be used to interpolate between stroke width along the path"), "interpolator_type", InterpolatorTypeConverter, &wr, this, Geom::Interpolate::INTERP_CUBICBEZIER),
     interpolator_beta(_("Smoothness:"), _("Sets the smoothness for the CubicBezierJohan interpolator; 0 = linear interpolation, 1 = smooth"), "interpolator_beta", &wr, this, 0.2),
-    start_linecap_type(_("Start cap:"), _("Determines the shape of the path's start"), "start_linecap_type", LineCapTypeConverter, &wr, this, LINECAP_ROUND),
-    linejoin_type(_("Join:"), _("Determines the shape of the path's corners"), "linejoin_type", LineJoinTypeConverter, &wr, this, LINEJOIN_ROUND),
+    start_linecap_type(_("Start cap:"), _("Determines the shape of the path's start"), "start_linecap_type", LineCapTypeConverter, &wr, this, LINECAP_BUTT),
+    linejoin_type(_("Join:"), _("Determines the shape of the path's corners"), "linejoin_type", LineJoinTypeConverter, &wr, this, LINEJOIN_EXTRP_MITER_ARC),
     miter_limit(_("Miter limit:"), _("Maximum length of the miter (in units of stroke width)"), "miter_limit", &wr, this, 4.),
-    end_linecap_type(_("End cap:"), _("Determines the shape of the path's end"), "end_linecap_type", LineCapTypeConverter, &wr, this, LINECAP_ROUND)
+    end_linecap_type(_("End cap:"), _("Determines the shape of the path's end"), "end_linecap_type", LineCapTypeConverter, &wr, this, LINECAP_BUTT)
 {
     show_orig_path = true;
 
@@ -267,20 +271,52 @@
 LPEPowerStroke::doOnApply(SPLPEItem const* lpeitem)
 {
     if (SP_IS_SHAPE(lpeitem)) {
+        SPLPEItem* item = const_cast<SPLPEItem*>(lpeitem);
         std::vector<Geom::Point> points;
         Geom::PathVector const &pathv = SP_SHAPE(lpeitem)->_curve->get_pathvector();
-        double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed : 1.;
+        double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed / 2 : 1.;
+        
+        SPCSSAttr *css = sp_repr_css_attr_new ();
+        if (true) {
+            if (lpeitem->style->stroke.isPaintserver()) {
+                SPPaintServer * server = lpeitem->style->getStrokePaintServer();
+                if (server) {
+                    Glib::ustring str;
+                    str += "url(#";
+                    str += server->getId();
+                    str += ")";
+                    sp_repr_css_set_property (css, "fill", str.c_str());
+                }
+            } else if (lpeitem->style->stroke.isColor()) {
+                gchar c[64];
+                sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+                sp_repr_css_set_property (css, "fill", c);
+            } else {
+                sp_repr_css_set_property (css, "fill", "none");
+            }
+        } else {
+            sp_repr_css_unset_property (css, "fill");
+        }
+        
+        sp_repr_css_set_property(css, "stroke", "none");
+        
+        sp_desktop_apply_css_recursive(item, css, true);
+        sp_repr_css_attr_unref (css);
+        
+        item->updateRepr();
         if (pathv.empty()) {
-            points.push_back( Geom::Point(0.,width) );
+            points.push_back( Geom::Point(0.2,width) );
             points.push_back( Geom::Point(0.5,width) );
-            points.push_back( Geom::Point(1.,width) );
+            points.push_back( Geom::Point(0.8,width) );
         } else {
             Geom::Path const &path = pathv.front();
             Geom::Path::size_type const size = path.size_default();
-            points.push_back( Geom::Point(0.,width) );
+            if (!path.closed()) {
+            	points.push_back( Geom::Point(0.2,width) );
+            }
             points.push_back( Geom::Point(0.5*size,width) );
             if (!path.closed()) {
-                points.push_back( Geom::Point(size,width) );
+                points.push_back( Geom::Point(size - 0.2,width) );
             }
         }
         offset_points.param_set_and_write_new_value(points);
@@ -289,6 +325,45 @@
     }
 }
 
+void LPEPowerStroke::doOnRemove(SPLPEItem const* lpeitem)
+{
+    if (SP_IS_SHAPE(lpeitem)) {
+        SPLPEItem *item = const_cast<SPLPEItem*>(lpeitem);
+        SPCSSAttr *css = sp_repr_css_attr_new ();
+        if (true) {
+            if (lpeitem->style->fill.isPaintserver()) {
+                SPPaintServer * server = lpeitem->style->getFillPaintServer();
+                if (server) {
+                    Glib::ustring str;
+                    str += "url(#";
+                    str += server->getId();
+                    str += ")";
+                    sp_repr_css_set_property (css, "stroke", str.c_str());
+                }
+            } else if (lpeitem->style->fill.isColor()) {
+                gchar c[64];
+                sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+                sp_repr_css_set_property (css, "stroke", c);
+            } else {
+                sp_repr_css_set_property (css, "stroke", "none");
+            }
+        } else {
+            sp_repr_css_unset_property (css, "stroke");
+        }
+
+        Inkscape::CSSOStringStream os;
+        os << offset_points.median_width() * 2;
+        sp_repr_css_set_property (css, "stroke-width", os.str().c_str());
+
+        sp_repr_css_set_property(css, "fill", "none");
+
+        sp_desktop_apply_css_recursive(item, css, true);
+        sp_repr_css_attr_unref (css);
+
+        item->updateRepr();
+    }
+}
+
 void
 LPEPowerStroke::adjustForNewPath(std::vector<Geom::Path> const & path_in)
 {
@@ -588,6 +663,9 @@
     if (Geom::Interpolate::CubicBezierJohan *johan = dynamic_cast<Geom::Interpolate::CubicBezierJohan*>(interpolator)) {
         johan->setBeta(interpolator_beta);
     }
+    if (Geom::Interpolate::CubicBezierSmooth *smooth = dynamic_cast<Geom::Interpolate::CubicBezierSmooth*>(interpolator)) {
+        smooth->setBeta(interpolator_beta);
+    }
     Geom::Path strokepath = interpolator->interpolateToPath(ts);
     delete interpolator;
 
 
=== modified file 'src/live_effects/lpe-powerstroke.h'
--- src/live_effects/lpe-powerstroke.h	2014-03-27 01:33:44 +0000
+++ src/live_effects/lpe-powerstroke.h	2014-09-07 17:02:32 +0000
@@ -25,9 +25,11 @@
     LPEPowerStroke(LivePathEffectObject *lpeobject);
     virtual ~LPEPowerStroke();
 
+    
     virtual std::vector<Geom::Path> doEffect_path (std::vector<Geom::Path> const & path_in);
 
     virtual void doOnApply(SPLPEItem const* lpeitem);
+    virtual void doOnRemove(SPLPEItem const* lpeitem);
 
     // methods called by path-manipulator upon edits
     void adjustForNewPath(std::vector<Geom::Path> const & path_in);
 
=== modified file 'src/live_effects/lpe-tangent_to_curve.cpp'
--- src/live_effects/lpe-tangent_to_curve.cpp	2014-03-27 01:33:44 +0000
+++ src/live_effects/lpe-tangent_to_curve.cpp	2014-09-07 17:02:32 +0000
@@ -16,8 +16,6 @@
 #include <glibmm/i18n.h>
 
 #include "live_effects/lpe-tangent_to_curve.h"
-// FIXME: The following are only needed to convert the path's SPCurve* to pwd2.
-//        There must be a more convenient way to achieve this.
 #include "sp-path.h"
 #include "display/curve.h"
 
@@ -108,13 +106,13 @@
     {
         KnotHolderEntity *e = new TtC::KnotHolderEntityLeftEnd(this);
         e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                    _("Adjust the \"left\" end of the tangent") );
+                    _("Adjust the <b>left</b> end of the tangent") );
         knotholder->add(e);
     }
     {
         KnotHolderEntity *e = new TtC::KnotHolderEntityRightEnd(this);
         e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                   _("Adjust the \"right\" end of the tangent") );
+                   _("Adjust the <b>right</b> end of the tangent") );
         knotholder->add(e);
     }
 };
@@ -130,14 +128,13 @@
 
     Geom::Point const s = snap_knot_position(p, state);
 
-    // FIXME: There must be a better way of converting the path's SPCurve* to pwd2.
-    SPCurve *curve = SP_PATH(item)->get_curve_for_edit();
-    Geom::PathVector pathv = curve->get_pathvector();
-    Piecewise<D2<SBasis> > pwd2;
-    for (unsigned int i=0; i < pathv.size(); i++) {
-        pwd2.concat(pathv[i].toPwSb());
+    if ( !SP_IS_SHAPE(lpe->sp_lpe_item) ) {
+        //lpe->t_attach.param_set_value(0);
+        g_warning("LPEItem is not a path! %s:%d\n", __FILE__, __LINE__);
+        return;
     }
-
+    Piecewise<D2<SBasis> > pwd2 = paths_to_pw( lpe->pathvector_before_effect );
+    
     double t0 = nearest_point(s, pwd2);
     lpe->t_attach.param_set_value(t0);
 
 
=== modified file 'src/live_effects/lpe-tangent_to_curve.h'
--- src/live_effects/lpe-tangent_to_curve.h	2012-04-07 14:09:58 +0000
+++ src/live_effects/lpe-tangent_to_curve.h	2014-09-07 17:02:32 +0000
@@ -34,7 +34,6 @@
 public:
     LPETangentToCurve(LivePathEffectObject *lpeobject);
     virtual ~LPETangentToCurve();
-
     virtual Geom::Piecewise<Geom::D2<Geom::SBasis> >
       doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
 
 
=== added file 'src/live_effects/lpe-taperstroke.cpp'
--- src/live_effects/lpe-taperstroke.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-taperstroke.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,630 @@
+/**
+ * @file
+ * Taper Stroke path effect, provided as an alternative to Power Strokes
+ * for otherwise constant-width paths.
+ *
+ * Authors:
+ *   Liam P White <[e-mail]>
+ *
+ * Copyright (C) 2014 Authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/lpe-taperstroke.h"
+
+#include <2geom/path.h>
+#include <2geom/shape.h>
+#include <2geom/path.h>
+#include <2geom/circle.h>
+#include <2geom/sbasis-to-bezier.h>
+#include "pathoutlineprovider.h"
+#include "display/curve.h"
+#include "sp-shape.h"
+#include "style.h"
+#include "xml/repr.h"
+#include "sp-paint-server.h"
+#include "svg/svg-color.h"
+#include "desktop-style.h"
+#include "svg/css-ostringstream.h"
+#include "svg/svg.h"
+
+//#include <glibmm/i18n.h>
+
+#include "knot-holder-entity.h"
+#include "knotholder.h"
+
+template<typename T>
+inline bool withinRange(T value, T low, T high) {
+    return (value > low && value < high);
+}
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+namespace TpS {
+    class KnotHolderEntityAttachBegin : public LPEKnotHolderEntity {
+    public:
+        KnotHolderEntityAttachBegin(LPETaperStroke * effect) : LPEKnotHolderEntity(effect) {}
+        virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+        virtual Geom::Point knot_get() const;
+    };
+    
+    class KnotHolderEntityAttachEnd : public LPEKnotHolderEntity {
+    public:
+        KnotHolderEntityAttachEnd(LPETaperStroke * effect) : LPEKnotHolderEntity(effect) {}
+        virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+        virtual Geom::Point knot_get() const;
+    };
+} // TpS
+
+static const Util::EnumData<unsigned> JoinType[] = {
+    {LINEJOIN_STRAIGHT,         N_("Beveled"),          "bevel"},
+    {LINEJOIN_ROUND,            N_("Rounded"),          "round"},
+    {LINEJOIN_REFLECTED,        N_("Reflected"),        "reflected"},
+    {LINEJOIN_POINTY,           N_("Miter"),            "miter"},
+    {LINEJOIN_EXTRAPOLATED,     N_("Extrapolated"),     "extrapolated"}
+};
+
+static const Util::EnumDataConverter<unsigned> JoinTypeConverter(JoinType, sizeof (JoinType)/sizeof(*JoinType));
+
+LPETaperStroke::LPETaperStroke(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    line_width(_("Stroke width"), _("The (non-tapered) width of the path"), "stroke_width", &wr, this, 1.),
+    attach_start(_("Start offset"), _("Taper distance from path start"), "attach_start", &wr, this, 0.2),
+    attach_end(_("End offset"), _("The ending position of the taper"), "end_offset", &wr, this, 0.2),
+    smoothing(_("Taper smoothing"), _("Amount of smoothing to apply to the tapers"), "smoothing", &wr, this, 0.5),
+    join_type(_("Join type"), _("Join type for non-smooth nodes"), "jointype", JoinTypeConverter, &wr, this, LINEJOIN_EXTRAPOLATED),
+    miter_limit(_("Miter limit"), _("Limit for miter joins"), "miter_limit", &wr, this, 100.)
+{
+    show_orig_path = true;
+    _provides_knotholder_entities = true;
+
+    attach_start.param_set_digits(3);
+    attach_end.param_set_digits(3);
+
+
+    registerParameter( dynamic_cast<Parameter *>(&line_width) );
+    registerParameter( dynamic_cast<Parameter *>(&attach_start) );
+    registerParameter( dynamic_cast<Parameter *>(&attach_end) );
+    registerParameter( dynamic_cast<Parameter *>(&smoothing) );
+    registerParameter( dynamic_cast<Parameter *>(&join_type) );
+    registerParameter( dynamic_cast<Parameter *>(&miter_limit) );
+}
+
+LPETaperStroke::~LPETaperStroke()
+{
+
+}
+
+//from LPEPowerStroke -- sets fill if stroke color because we will
+//be converting to a fill to make the new join.
+
+void LPETaperStroke::doOnApply(SPLPEItem const* lpeitem)
+{
+    if (SP_IS_SHAPE(lpeitem)) {
+        SPLPEItem* item = const_cast<SPLPEItem*>(lpeitem);
+        double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed : 1.;
+
+        SPCSSAttr *css = sp_repr_css_attr_new ();
+        if (true) {
+            if (lpeitem->style->stroke.isPaintserver()) {
+                SPPaintServer * server = lpeitem->style->getStrokePaintServer();
+                if (server) {
+                    Glib::ustring str;
+                    str += "url(#";
+                    str += server->getId();
+                    str += ")";
+                    sp_repr_css_set_property (css, "fill", str.c_str());
+                }
+            } else if (lpeitem->style->stroke.isColor()) {
+                gchar c[64];
+                sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+                sp_repr_css_set_property (css, "fill", c);
+            } else {
+                sp_repr_css_set_property (css, "fill", "none");
+            }
+        } else {
+            sp_repr_css_unset_property (css, "fill");
+        }
+
+        sp_repr_css_set_property(css, "stroke", "none");
+
+        sp_desktop_apply_css_recursive(item, css, true);
+        sp_repr_css_attr_unref (css);
+
+        line_width.param_set_value(width);
+    } else {
+        g_warning("LPE Join Type can only be applied to paths (not groups).");
+    }
+}
+
+//from LPEPowerStroke -- sets stroke color from existing fill color
+
+void LPETaperStroke::doOnRemove(SPLPEItem const* lpeitem)
+{
+
+    if (SP_IS_SHAPE(lpeitem)) {
+        SPLPEItem *item = const_cast<SPLPEItem*>(lpeitem);
+
+        SPCSSAttr *css = sp_repr_css_attr_new ();
+        if (true) {
+            if (lpeitem->style->fill.isPaintserver()) {
+                SPPaintServer * server = lpeitem->style->getFillPaintServer();
+                if (server) {
+                    Glib::ustring str;
+                    str += "url(#";
+                    str += server->getId();
+                    str += ")";
+                    sp_repr_css_set_property (css, "stroke", str.c_str());
+                }
+            } else if (lpeitem->style->fill.isColor()) {
+                gchar c[64];
+                sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+                sp_repr_css_set_property (css, "stroke", c);
+            } else {
+                sp_repr_css_set_property (css, "stroke", "none");
+            }
+        } else {
+            sp_repr_css_unset_property (css, "stroke");
+        }
+
+        Inkscape::CSSOStringStream os;
+        os << fabs(line_width);
+        sp_repr_css_set_property (css, "stroke-width", os.str().c_str());
+
+        sp_repr_css_set_property(css, "fill", "none");
+
+        sp_desktop_apply_css_recursive(item, css, true);
+        sp_repr_css_attr_unref (css);
+        item->updateRepr();
+    }
+}
+
+//actual effect impl here
+
+Geom::Path return_at_first_cusp (Geom::Path const & path_in, double /*smooth_tolerance*/ = 0.05)
+{
+    return Geom::split_at_cusps(path_in)[0];
+}
+
+Geom::Piecewise<Geom::D2<Geom::SBasis> > stretch_along(Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2_in, Geom::Path pattern, double width);
+
+//references to pointers, because magic
+void subdivideCurve(Geom::Curve * curve_in, Geom::Coord t, Geom::Curve *& val_first, Geom::Curve *& val_second);
+
+Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in)
+{
+    Geom::Path first_cusp = return_at_first_cusp(path_in[0]);
+    Geom::Path last_cusp = return_at_first_cusp(path_in[0].reverse());
+
+    bool zeroStart = false;
+    bool zeroEnd = false;
+    bool metInMiddle = false;
+    
+    //there is a pretty good chance that people will try to drag the knots
+    //on top of each other, so block it
+
+    unsigned size = path_in[0].size();
+    if (size == first_cusp.size()) {
+        //check to see if the knots were dragged over each other
+        //if so, reset the end offset, but still allow the start offset.
+        if ( attach_start >= (size - attach_end) ) {
+            attach_end.param_set_value( size - attach_start );
+	    metInMiddle = true;
+        }
+    }
+    
+    if (attach_start == size - attach_end) {
+        metInMiddle = true;
+    }
+    if (attach_end == size - attach_start) {
+        metInMiddle = true;
+    }
+
+    //don't let it be integer
+    {
+        if (double(unsigned(attach_start)) == attach_start) {
+            attach_start.param_set_value(attach_start - 0.00001);
+        }
+        if (double(unsigned(attach_end)) == attach_end) {
+            attach_end.param_set_value(attach_end -     0.00001);
+        }
+    }
+
+    unsigned allowed_start = first_cusp.size();
+    unsigned allowed_end = last_cusp.size();
+
+    //don't let the knots be farther than they are allowed to be
+    {
+        if ((unsigned)attach_start >= allowed_start) {
+            attach_start.param_set_value((double)allowed_start - 0.00001);
+        }
+        if ((unsigned)attach_end >= allowed_end) {
+            attach_end.param_set_value((double)allowed_end - 0.00001);
+        }
+    }
+    
+    //don't let it be zero
+    if (attach_start < 0.0000001 || withinRange(double(attach_start), 0.00000001, 0.000001)) {
+        attach_start.param_set_value( 0.0000001 );
+        zeroStart = true;
+    }
+    if (attach_end < 0.0000001 || withinRange(double(attach_end), 0.00000001, 0.000001)) {
+        attach_end.param_set_value( 0.0000001 );
+        zeroEnd = true;
+    }
+
+    //remember, Path::operator () means get point at time t
+    start_attach_point = first_cusp(attach_start);
+    end_attach_point = last_cusp(attach_end);
+    Geom::PathVector pathv_out;
+
+    //the following function just splits it up into three pieces.
+    pathv_out = doEffect_simplePath(path_in);
+
+    //now for the actual tapering. We use the stretch_along method to get this done.
+
+    Geom::PathVector real_pathv;
+    Geom::Path real_path;
+    Geom::PathVector pat_vec;
+    Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2;
+    Geom::Path throwaway_path;
+
+    if (!zeroStart) {
+        //Construct the pattern (pat_str stands for pattern string) (and yes, this is easier, trust me)
+        std::stringstream pat_str;
+        pat_str << "M 1,0 C " << 1 - (double)smoothing << ",0 0,0.5 0,0.5 0,0.5 " << 1 - (double)smoothing << ",1 1,1";
+
+        pat_vec = sp_svg_read_pathv(pat_str.str().c_str());
+        pwd2.concat(stretch_along(pathv_out[0].toPwSb(), pat_vec[0], -fabs(line_width)));
+        throwaway_path = Geom::path_from_piecewise(pwd2, LPE_CONVERSION_TOLERANCE)[0];
+
+        real_path.append(throwaway_path);
+    }
+    
+    if (!metInMiddle) {
+        //append the outside outline of the path (with direction)
+        throwaway_path = Outline::PathOutsideOutline(pathv_out[1],
+                         -fabs(line_width), static_cast<LineJoinType>(join_type.get_value()), miter_limit);
+        if (!zeroStart && real_path.size() >= 1 && throwaway_path.size() >= 1) {
+            if (Geom::distance(real_path.finalPoint(), throwaway_path.initialPoint()) > 0.0000001) {
+                real_path.appendNew<Geom::LineSegment>(throwaway_path.initialPoint());
+            } else {
+                real_path.setFinal(throwaway_path.initialPoint());
+            }
+        }
+        real_path.append(throwaway_path);
+    }
+
+    if (!zeroEnd) {
+        //append the ending taper
+        std::stringstream pat_str_1;
+        pat_str_1 << "M 0,1 C " << (double)smoothing << ",1 1,0.5 1,0.5 1,0.5 " << double(smoothing) << ",0 0,0";
+        pat_vec = sp_svg_read_pathv(pat_str_1.str().c_str());
+
+        pwd2 = Geom::Piecewise<Geom::D2<Geom::SBasis> > ();
+        pwd2.concat(stretch_along(pathv_out[2].toPwSb(), pat_vec[0], -fabs(line_width)));
+
+        throwaway_path = Geom::path_from_piecewise(pwd2, LPE_CONVERSION_TOLERANCE)[0];
+        if (Geom::distance(real_path.finalPoint(), throwaway_path.initialPoint()) > 0.0000001 && real_path.size() >= 1) {
+            real_path.appendNew<Geom::LineSegment>(throwaway_path.initialPoint());
+        } else {
+            real_path.setFinal(throwaway_path.initialPoint());
+        }
+        real_path.append(throwaway_path);
+    }
+    
+    if (!metInMiddle) {
+        //append the inside outline of the path (against direction)
+        throwaway_path = Outline::PathOutsideOutline(pathv_out[1].reverse(),
+                         -fabs(line_width), static_cast<LineJoinType>(join_type.get_value()), miter_limit);
+        
+        if (Geom::distance(real_path.finalPoint(), throwaway_path.initialPoint()) > 0.0000001 && real_path.size() >= 1) {
+            real_path.appendNew<Geom::LineSegment>(throwaway_path.initialPoint());
+        } else {
+            real_path.setFinal(throwaway_path.initialPoint());
+        }
+        real_path.append(throwaway_path);
+    }
+    
+    if (Geom::distance(real_path.finalPoint(), real_path.initialPoint()) > 0.0000001) {
+        real_path.appendNew<Geom::LineSegment>(real_path.initialPoint());
+    } else {
+        real_path.setFinal(real_path.initialPoint());
+    }
+    real_path.close();
+    
+    real_pathv.push_back(real_path);
+
+    return real_pathv;
+}
+
+//in all cases, this should return a PathVector with three elements.
+Geom::PathVector LPETaperStroke::doEffect_simplePath(Geom::PathVector const & path_in)
+{
+    unsigned size = path_in[0].size();
+
+    //do subdivision and get out
+    unsigned loc = (unsigned)attach_start;
+    Geom::Curve * curve_start = path_in[0] [loc].duplicate();
+
+    std::vector<Geom::Path> pathv_out;
+    Geom::Path path_out = Geom::Path();
+
+    Geom::Path trimmed_start = Geom::Path();
+    Geom::Path trimmed_end = Geom::Path();
+
+    for (unsigned i = 0; i < loc; i++) {
+        trimmed_start.append(path_in[0] [i]);
+    }
+
+    Geom::Curve * temp;
+    subdivideCurve(curve_start, attach_start - loc, temp, curve_start);
+    trimmed_start.append(*temp);
+    if (temp) delete temp; temp = 0;
+
+    //special case: path is one segment long
+    //special case: what if the two knots occupy the same segment?
+    if ((size == 1) || ( size - unsigned(attach_end) - 1 == loc )) {
+        Geom::Coord t = Geom::nearest_point(end_attach_point, *curve_start);
+
+        //it is just a dumb segment
+        //we have to do some shifting here because the value changed when we reduced the length
+        //of the previous segment.
+
+        subdivideCurve(curve_start, t, curve_start, temp);
+        trimmed_end.append(*temp);
+        if (temp) delete temp; temp = 0;
+        
+        for (unsigned j = (size - attach_end) + 1; j < size; j++) {
+            trimmed_end.append(path_in[0] [j]);
+        }
+
+        path_out.append(*curve_start);
+        pathv_out.push_back(trimmed_start);
+        pathv_out.push_back(path_out);
+        pathv_out.push_back(trimmed_end);
+        return pathv_out;
+    }
+
+    pathv_out.push_back(trimmed_start);
+
+    //append almost all of the rest of the path, ignore the curves that the knot is past (we'll get to it in a minute)
+    path_out.append(*curve_start);
+
+    for (unsigned k = loc + 1; k < (size - unsigned(attach_end)) - 1; k++) {
+        path_out.append(path_in[0] [k]);
+    }
+
+    //deal with the last segment in a very similar fashion to the first
+    loc = size - attach_end;
+
+    Geom::Curve * curve_end = path_in[0] [loc].duplicate();
+
+    Geom::Coord t = Geom::nearest_point(end_attach_point, *curve_end);
+
+    subdivideCurve(curve_end, t, curve_end, temp);
+    trimmed_end.append(*temp);
+    if (temp) delete temp; temp = 0;
+
+    for (unsigned j = (size - attach_end) + 1; j < size; j++) {
+        trimmed_end.append(path_in[0] [j]);
+    }
+
+    path_out.append(*curve_end);
+    pathv_out.push_back(path_out);
+
+    pathv_out.push_back(trimmed_end);
+
+    if (curve_end) delete curve_end;
+    if (curve_start) delete curve_start;
+    return pathv_out;
+}
+
+
+//most of the below code is verbatim from Pattern Along Path. However, it needed a little
+//tweaking to get it to work right in this case.
+Geom::Piecewise<Geom::D2<Geom::SBasis> > stretch_along(Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2_in, Geom::Path pattern, double prop_scale)
+{
+    using namespace Geom;
+
+    // Don't allow empty path parameter:
+    if ( pattern.empty() ) {
+        return pwd2_in;
+    }
+
+    /* Much credit should go to jfb and mgsloan of lib2geom development for the code below! */
+    Piecewise<D2<SBasis> > output;
+    std::vector<Geom::Piecewise<Geom::D2<Geom::SBasis> > > pre_output;
+
+    D2<Piecewise<SBasis> > patternd2 = make_cuts_independent(pattern.toPwSb());
+    Piecewise<SBasis> x0 = Piecewise<SBasis>(patternd2[0]);
+    Piecewise<SBasis> y0 = Piecewise<SBasis>(patternd2[1]);
+    OptInterval pattBndsX = bounds_exact(x0);
+    OptInterval pattBndsY = bounds_exact(y0);
+    if (pattBndsX && pattBndsY) {
+        x0 -= pattBndsX->min();
+        y0 -= pattBndsY->middle();
+
+        double xspace  = 0;
+        double noffset = 0;
+        double toffset = 0;
+        //Prevent more than 90% overlap...
+        if (xspace < -pattBndsX->extent()*.9) {
+            xspace = -pattBndsX->extent()*.9;
+        }
+
+        y0+=noffset;
+
+        std::vector<Geom::Piecewise<Geom::D2<Geom::SBasis> > > paths_in;
+        paths_in = split_at_discontinuities(pwd2_in);
+
+        for (unsigned idx = 0; idx < paths_in.size(); idx++) {
+            Geom::Piecewise<Geom::D2<Geom::SBasis> > path_i = paths_in[idx];
+            Piecewise<SBasis> x = x0;
+            Piecewise<SBasis> y = y0;
+            Piecewise<D2<SBasis> > uskeleton = arc_length_parametrization(path_i,2,.1);
+            uskeleton = remove_short_cuts(uskeleton,.01);
+            Piecewise<D2<SBasis> > n = rot90(derivative(uskeleton));
+            n = force_continuity(remove_short_cuts(n,.1));
+
+            int nbCopies = 0;
+            double scaling = 1;
+            nbCopies = 1;
+            scaling = (uskeleton.domain().extent() - toffset)/pattBndsX->extent();
+
+            double pattWidth = pattBndsX->extent() * scaling;
+
+            if (scaling != 1.0) {
+                x*=scaling;
+            }
+            if ( false ) {
+                y*=(scaling*prop_scale);
+            } else {
+                if (prop_scale != 1.0) y *= prop_scale;
+            }
+            x += toffset;
+
+            double offs = 0;
+            for (int i=0; i<nbCopies; i++) {
+                if (false) {
+                    Geom::Piecewise<Geom::D2<Geom::SBasis> > output_piece = compose(uskeleton,x+offs)+y*compose(n,x+offs);
+                    std::vector<Geom::Piecewise<Geom::D2<Geom::SBasis> > > splited_output_piece = split_at_discontinuities(output_piece);
+                    pre_output.insert(pre_output.end(), splited_output_piece.begin(), splited_output_piece.end() );
+                } else {
+                    output.concat(compose(uskeleton,x+offs)+y*compose(n,x+offs));
+                }
+                offs+=pattWidth;
+            }
+        }
+        return output;
+    } else {
+        return pwd2_in;
+    }
+}
+
+void subdivideCurve(Geom::Curve * curve_in, Geom::Coord t, Geom::Curve *& val_first, Geom::Curve *& val_second)
+{
+    if (Geom::LineSegment* linear = dynamic_cast<Geom::LineSegment*>(curve_in)) {
+        //special case for line segments
+        std::pair<Geom::LineSegment, Geom::LineSegment> seg_pair = linear->subdivide(t);
+        val_first = seg_pair.first.duplicate();
+        val_second = seg_pair.second.duplicate();
+    } else {
+        //all other cases:
+        Geom::CubicBezier cubic = Geom::sbasis_to_cubicbezier(curve_in->toSBasis());
+        std::pair<Geom::CubicBezier, Geom::CubicBezier> cubic_pair = cubic.subdivide(t);
+        val_first = cubic_pair.first.duplicate();
+        val_second = cubic_pair.second.duplicate();
+    }
+}
+
+
+void LPETaperStroke::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+{
+    {
+        KnotHolderEntity *e = new TpS::KnotHolderEntityAttachBegin(this);
+        e->create(  desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+                    _("Start point of the taper"), SP_KNOT_SHAPE_CIRCLE );
+        knotholder->add(e);
+    }
+    {
+        KnotHolderEntity *e = new TpS::KnotHolderEntityAttachEnd(this);
+        e->create(	desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+                    _("End point of the taper"), SP_KNOT_SHAPE_CIRCLE );
+        knotholder->add(e);
+    }
+}
+
+namespace TpS {
+void KnotHolderEntityAttachBegin::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
+{
+    using namespace Geom;
+
+    LPETaperStroke* lpe = dynamic_cast<LPETaperStroke *>(_effect);
+
+    Geom::Point const s = snap_knot_position(p, state);
+
+    if (!SP_IS_SHAPE(lpe->sp_lpe_item) ) {
+        g_warning("LPEItem is not a path! %s:%d\n", __FILE__, __LINE__);
+        return;
+    }
+    
+    SPCurve* curve;
+    if ( !(curve = SP_SHAPE(lpe->sp_lpe_item)->getCurve()) ) {
+        //oops
+        //lpe->attach_start.param_set_value(0);
+        return;
+    }
+    //in case you are wondering, the above are simply sanity checks. we never want to actually
+    //use that object.
+    
+    Geom::PathVector pathv = lpe->pathvector_before_effect;
+    
+    Piecewise<D2<SBasis> > pwd2;
+    Geom::Path p_in = return_at_first_cusp(pathv[0]);
+    pwd2.concat(p_in.toPwSb());
+
+    double t0 = nearest_point(s, pwd2);
+    lpe->attach_start.param_set_value(t0);
+
+    // FIXME: this should not directly ask for updating the item. It should write to SVG, which triggers updating.
+    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
+}
+void KnotHolderEntityAttachEnd::knot_set(Geom::Point const &p, Geom::Point const& /*origin*/, guint state)
+{
+    using namespace Geom;
+
+    LPETaperStroke* lpe = dynamic_cast<LPETaperStroke *>(_effect);
+
+    Geom::Point const s = snap_knot_position(p, state);
+
+    if (!SP_IS_SHAPE(lpe->sp_lpe_item) ) {
+        g_warning("LPEItem is not a path! %s:%d\n", __FILE__, __LINE__);
+        return;
+    }
+    
+    SPCurve* curve;
+    if ( !(curve = SP_SHAPE(lpe->sp_lpe_item)->getCurve()) ) {
+        //oops
+        //lpe->attach_end.param_set_value(0);
+        return;
+    }
+    Geom::PathVector pathv = lpe->pathvector_before_effect;
+    Geom::Path p_in = return_at_first_cusp(pathv[0].reverse());
+    Piecewise<D2<SBasis> > pwd2 = p_in.toPwSb();
+    
+    double t0 = nearest_point(s, pwd2);
+    lpe->attach_end.param_set_value(t0);
+
+    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
+}
+Geom::Point KnotHolderEntityAttachBegin::knot_get() const
+{
+    LPETaperStroke const * lpe = dynamic_cast<LPETaperStroke const*> (_effect);
+    return lpe->start_attach_point;
+}
+Geom::Point KnotHolderEntityAttachEnd::knot_get() const
+{
+    LPETaperStroke const * lpe = dynamic_cast<LPETaperStroke const*> (_effect);
+    return lpe->end_attach_point;
+}
+}
+
+
+/* ######################## */
+
+} //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:fileencoding=utf-8:textwidth=99 :
 
=== added file 'src/live_effects/lpe-taperstroke.h'
--- src/live_effects/lpe-taperstroke.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-taperstroke.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,72 @@
+/** @file
+ * @brief Taper Stroke path effect (meant as a replacement for using Power Strokes for tapering)
+ */
+/* Authors:
+ *   Liam P White <[e-mail]>
+ * Copyright (C) 2014 Authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifndef INKSCAPE_LPE_TAPERSTROKE_H
+#define INKSCAPE_LPE_TAPERSTROKE_H
+
+#include "live_effects/parameter/enum.h"
+#include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
+#include "live_effects/parameter/vector.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+namespace TpS {
+// we need a separate namespace to avoid clashes with other LPEs
+class KnotHolderEntityAttachBegin;
+class KnotHolderEntityAttachEnd;
+}
+
+class LPETaperStroke : public Effect {
+public:
+    LPETaperStroke(LivePathEffectObject *lpeobject);
+    virtual ~LPETaperStroke();
+
+    virtual void doOnApply(SPLPEItem const* lpeitem);
+    virtual void doOnRemove(SPLPEItem const* lpeitem);
+
+    virtual Geom::PathVector doEffect_path (Geom::PathVector const& path_in);
+    Geom::PathVector doEffect_simplePath(Geom::PathVector const& path_in);
+
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
+
+    friend class TpS::KnotHolderEntityAttachBegin;
+    friend class TpS::KnotHolderEntityAttachEnd;
+private:
+    ScalarParam line_width;
+    ScalarParam attach_start;
+    ScalarParam attach_end;
+    ScalarParam smoothing;
+    EnumParam<unsigned> join_type;
+    ScalarParam miter_limit;
+
+    Geom::Point start_attach_point;
+    Geom::Point end_attach_point;
+
+    LPETaperStroke(const LPETaperStroke&);
+    LPETaperStroke& operator=(const LPETaperStroke&);
+};
+
+} //namespace LivePathEffect
+} //namespace Inkscape
+
+#endif
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
 
=== modified file 'src/live_effects/parameter/Makefile_insert'
--- src/live_effects/parameter/Makefile_insert	2014-07-02 11:14:35 +0000
+++ src/live_effects/parameter/Makefile_insert	2014-09-07 17:02:32 +0000
@@ -20,12 +20,16 @@
 	live_effects/parameter/path.h	\
 	live_effects/parameter/originalpath.cpp	\
 	live_effects/parameter/originalpath.h	\
+	live_effects/parameter/originalpatharray.cpp	\
+	live_effects/parameter/originalpatharray.h	\
 	live_effects/parameter/powerstrokepointarray.cpp	\
 	live_effects/parameter/powerstrokepointarray.h	\
 	live_effects/parameter/filletchamferpointarray.cpp	\
 	live_effects/parameter/filletchamferpointarray.h	\
 	live_effects/parameter/text.cpp	\
 	live_effects/parameter/text.h	\
+	live_effects/parameter/transformedpoint.cpp	\
+	live_effects/parameter/transformedpoint.h	\
 	live_effects/parameter/togglebutton.cpp	\
 	live_effects/parameter/togglebutton.h	\
 	live_effects/parameter/unit.cpp	\
 
=== modified file 'src/live_effects/parameter/filletchamferpointarray.cpp'
--- src/live_effects/parameter/filletchamferpointarray.cpp	2014-08-24 10:37:18 +0000
+++ src/live_effects/parameter/filletchamferpointarray.cpp	2014-09-07 17:02:32 +0000
@@ -8,11 +8,14 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <glibmm.h>
+
 #include "ui/dialog/lpe-fillet-chamfer-properties.h"
 #include "live_effects/parameter/filletchamferpointarray.h"
 #include <2geom/piecewise.h>
 #include <2geom/sbasis-to-bezier.h>
 #include <2geom/sbasis-geometric.h>
+#include <gtkmm.h>
 
 #include "live_effects/effect.h"
 #include "svg/svg.h"
 
=== added file 'src/live_effects/parameter/originalpatharray.cpp'
--- src/live_effects/parameter/originalpatharray.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/originalpatharray.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,497 @@
+/*
+ * Copyright (C) Johan Engelen 2008 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H
+#include <glibmm/threads.h>
+#endif
+
+#include "live_effects/parameter/originalpatharray.h"
+
+#include <gtkmm/widget.h>
+#include <gtkmm/icontheme.h>
+#include <gtkmm/imagemenuitem.h>
+#include <gtkmm/separatormenuitem.h>
+#include <gtkmm/scrolledwindow.h>
+
+#include <glibmm/i18n.h>
+
+#include "inkscape.h"
+#include "icon-size.h"
+#include "widgets/icon.h"
+#include "ui/clipboard.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "originalpath.h"
+#include "uri.h"
+#include "display/curve.h"
+
+#include <2geom/coord.h>
+#include <2geom/point.h>
+#include "sp-shape.h"
+#include "sp-text.h"
+#include "live_effects/effect.h"
+
+#include "verbs.h"
+#include "document-undo.h"
+#include "document.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+class OriginalPathArrayParam::ModelColumns : public Gtk::TreeModel::ColumnRecord
+{
+public:
+
+    ModelColumns()
+    {
+        add(_colObject);
+        add(_colLabel);
+        add(_colReverse);
+    }
+    virtual ~ModelColumns() {}
+
+    Gtk::TreeModelColumn<PathAndDirection*> _colObject;
+    Gtk::TreeModelColumn<Glib::ustring> _colLabel;
+    Gtk::TreeModelColumn<bool> _colReverse;
+};
+
+OriginalPathArrayParam::OriginalPathArrayParam( const Glib::ustring& label,
+        const Glib::ustring& tip,
+        const Glib::ustring& key,
+        Inkscape::UI::Widget::Registry* wr,
+        Effect* effect )
+: Parameter(label, tip, key, wr, effect), 
+        _vector(),
+        _tree(),
+        _text_renderer(),
+        _toggle_renderer(),
+        _scroller()
+{    
+    _model = new ModelColumns();
+    _store = Gtk::TreeStore::create(*_model);
+    _tree.set_model(_store);
+
+    _tree.set_reorderable(true);
+    _tree.enable_model_drag_dest (Gdk::ACTION_MOVE);
+    
+    _text_renderer = manage(new Gtk::CellRendererText());
+    int nameColNum = _tree.append_column(_("Name"), *_text_renderer) - 1;
+    _name_column = _tree.get_column(nameColNum);
+    _name_column->add_attribute(_text_renderer->property_text(), _model->_colLabel);
+
+    _tree.set_expander_column( *_tree.get_column(nameColNum) );
+    _tree.set_search_column(_model->_colLabel);
+    
+    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);
+    
+    //quick little hack -- newer versions of gtk gave the item zero space allotment
+    _scroller.set_size_request(-1, 120);
+
+    _scroller.add(_tree);
+    _scroller.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC );
+    //_scroller.set_shadow_type(Gtk::SHADOW_IN);
+    
+    oncanvas_editable = true;
+    
+}
+
+OriginalPathArrayParam::~OriginalPathArrayParam()
+{
+    while (!_vector.empty()) {
+        PathAndDirection *w = _vector.back();
+        _vector.pop_back();
+        unlink(w);
+        delete w;
+    }
+    delete _model;
+}
+
+void OriginalPathArrayParam::on_reverse_toggled(const Glib::ustring& path)
+{
+    Gtk::TreeModel::iterator iter = _store->get_iter(path);
+    Gtk::TreeModel::Row row = *iter;
+    PathAndDirection *w = row[_model->_colObject];
+    row[_model->_colReverse] = !row[_model->_colReverse];
+    w->reversed = row[_model->_colReverse];
+    
+    gchar * full = param_getSVGValue();
+    param_write_to_repr(full);
+    g_free(full);
+    DocumentUndo::done(param_effect->getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
+                       _("Link path parameter to path"));
+}
+
+void OriginalPathArrayParam::param_set_default()
+{
+    
+}
+
+Gtk::Widget* OriginalPathArrayParam::param_newWidget()
+{
+    Gtk::VBox* vbox = Gtk::manage(new Gtk::VBox());
+    Gtk::HBox* hbox = Gtk::manage(new Gtk::HBox());
+
+    vbox->pack_start(_scroller, Gtk::PACK_EXPAND_WIDGET);
+    
+    
+    { // Paste path to link button
+        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon( GTK_STOCK_PASTE, Inkscape::ICON_SIZE_BUTTON) );
+        Gtk::Button *pButton = Gtk::manage(new Gtk::Button());
+        pButton->set_relief(Gtk::RELIEF_NONE);
+        pIcon->show();
+        pButton->add(*pIcon);
+        pButton->show();
+        pButton->signal_clicked().connect(sigc::mem_fun(*this, &OriginalPathArrayParam::on_link_button_click));
+        hbox->pack_start(*pButton, Gtk::PACK_SHRINK);
+        pButton->set_tooltip_text(_("Link to path"));
+    }
+    
+    { // Remove linked path
+        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon( GTK_STOCK_REMOVE, Inkscape::ICON_SIZE_BUTTON) );
+        Gtk::Button *pButton = Gtk::manage(new Gtk::Button());
+        pButton->set_relief(Gtk::RELIEF_NONE);
+        pIcon->show();
+        pButton->add(*pIcon);
+        pButton->show();
+        pButton->signal_clicked().connect(sigc::mem_fun(*this, &OriginalPathArrayParam::on_remove_button_click));
+        hbox->pack_start(*pButton, Gtk::PACK_SHRINK);
+        pButton->set_tooltip_text(_("Remove Path"));
+    }
+    
+    { // Move Down
+        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon( GTK_STOCK_GO_DOWN, Inkscape::ICON_SIZE_BUTTON) );
+        Gtk::Button *pButton = Gtk::manage(new Gtk::Button());
+        pButton->set_relief(Gtk::RELIEF_NONE);
+        pIcon->show();
+        pButton->add(*pIcon);
+        pButton->show();
+        pButton->signal_clicked().connect(sigc::mem_fun(*this, &OriginalPathArrayParam::on_down_button_click));
+        hbox->pack_end(*pButton, Gtk::PACK_SHRINK);
+        pButton->set_tooltip_text(_("Move Down"));
+    }
+    
+    { // Move Down
+        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon( GTK_STOCK_GO_UP, Inkscape::ICON_SIZE_BUTTON) );
+        Gtk::Button *pButton = Gtk::manage(new Gtk::Button());
+        pButton->set_relief(Gtk::RELIEF_NONE);
+        pIcon->show();
+        pButton->add(*pIcon);
+        pButton->show();
+        pButton->signal_clicked().connect(sigc::mem_fun(*this, &OriginalPathArrayParam::on_up_button_click));
+        hbox->pack_end(*pButton, Gtk::PACK_SHRINK);
+        pButton->set_tooltip_text(_("Move Up"));
+    }
+    
+    vbox->pack_end(*hbox, Gtk::PACK_SHRINK);
+    
+    vbox->show_all_children(true);
+    
+    return vbox;
+}
+
+bool OriginalPathArrayParam::_selectIndex(const Gtk::TreeIter& iter, int* i)
+{
+    if ((*i)-- <= 0) {
+        _tree.get_selection()->select(iter);
+        return true;
+    }
+    return false;
+}
+
+void OriginalPathArrayParam::on_up_button_click()
+{
+    Gtk::TreeModel::iterator iter = _tree.get_selection()->get_selected();
+    if (iter) {
+        Gtk::TreeModel::Row row = *iter;
+        
+        int i = -1;
+        std::vector<PathAndDirection*>::iterator piter = _vector.begin();
+        for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); piter = iter, i++, iter++) {
+            if (*iter == row[_model->_colObject]) {
+                _vector.erase(iter);
+                _vector.insert(piter, row[_model->_colObject]);
+                break;
+            }
+        }
+        
+        gchar * full = param_getSVGValue();
+        param_write_to_repr(full);
+        g_free(full);
+        
+        DocumentUndo::done(param_effect->getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
+                       _("Move path up"));
+        
+        _store->foreach_iter(sigc::bind<int*>(sigc::mem_fun(*this, &OriginalPathArrayParam::_selectIndex), &i));
+    }
+}
+
+void OriginalPathArrayParam::on_down_button_click()
+{
+    Gtk::TreeModel::iterator iter = _tree.get_selection()->get_selected();
+    if (iter) {
+        Gtk::TreeModel::Row row = *iter;
+
+        int i = 0;
+        for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); i++, iter++) {
+            if (*iter == row[_model->_colObject]) {
+                std::vector<PathAndDirection*>::iterator niter = _vector.erase(iter);
+                if (niter != _vector.end()) {
+                    niter++;
+                    i++;
+                }
+                _vector.insert(niter, row[_model->_colObject]);
+                break;
+            }
+        }
+        
+        gchar * full = param_getSVGValue();
+        param_write_to_repr(full);
+        g_free(full);
+        
+        DocumentUndo::done(param_effect->getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
+                       _("Move path down"));
+        
+        _store->foreach_iter(sigc::bind<int*>(sigc::mem_fun(*this, &OriginalPathArrayParam::_selectIndex), &i));
+    }
+}
+
+void OriginalPathArrayParam::on_remove_button_click()
+{
+    Gtk::TreeModel::iterator iter = _tree.get_selection()->get_selected();
+    if (iter) {
+        Gtk::TreeModel::Row row = *iter;
+        remove_link(row[_model->_colObject]);
+        
+        gchar * full = param_getSVGValue();
+        param_write_to_repr(full);
+        g_free(full);
+        
+        DocumentUndo::done(param_effect->getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
+                       _("Remove path"));
+    }
+    
+}
+
+void
+OriginalPathArrayParam::on_link_button_click()
+{
+    Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
+    Glib::ustring pathid = cm->getShapeOrTextObjectId(SP_ACTIVE_DESKTOP);
+
+    if (pathid == "") {
+        return;
+    }
+    // add '#' at start to make it an uri.
+    pathid.insert(pathid.begin(), '#');
+    
+    Inkscape::SVGOStringStream os;
+    bool foundOne = false;
+    for (std::vector<PathAndDirection*>::const_iterator iter = _vector.begin(); iter != _vector.end(); iter++) {
+        if (foundOne) {
+            os << "|";
+        } else {
+            foundOne = true;
+        }
+        os << (*iter)->href << "," << ((*iter)->reversed ? "1" : "0");
+    }
+    
+    if (foundOne) {
+        os << "|";
+    }
+    
+    os << pathid.c_str() << ",0";
+    
+    param_write_to_repr(os.str().c_str());
+    DocumentUndo::done(param_effect->getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
+                       _("Link path parameter to path"));
+}
+
+void OriginalPathArrayParam::unlink(PathAndDirection* to)
+{
+    to->linked_modified_connection.disconnect();
+    to->linked_delete_connection.disconnect();
+    to->ref.detach();
+    to->_pathvector = Geom::PathVector();
+    if (to->href) {
+        g_free(to->href);
+        to->href = NULL;
+    }    
+}
+
+void OriginalPathArrayParam::remove_link(PathAndDirection* to)
+{
+    unlink(to);
+    for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); iter++) {
+        if (*iter == to) {
+            PathAndDirection *w = *iter;
+            _vector.erase(iter);
+            delete w;
+            return;
+        }
+    }
+}
+
+void OriginalPathArrayParam::linked_delete(SPObject */*deleted*/, PathAndDirection* to)
+{
+    //remove_link(to);
+    
+    gchar * full = param_getSVGValue();
+    param_write_to_repr(full);
+    g_free(full);
+}
+
+bool OriginalPathArrayParam::_updateLink(const Gtk::TreeIter& iter, PathAndDirection* pd)
+{
+    Gtk::TreeModel::Row row = *iter;
+    if (row[_model->_colObject] == pd) {
+        SPObject *obj = pd->ref.getObject();
+        row[_model->_colLabel] = obj && obj->getId() ? ( obj->label() ? obj->label() : obj->getId() ) : pd->href;
+        return true;
+    }
+    return false;
+}
+
+void OriginalPathArrayParam::linked_changed(SPObject */*old_obj*/, SPObject *new_obj, PathAndDirection* to)
+{
+    to->linked_delete_connection.disconnect();
+    to->linked_modified_connection.disconnect();
+    to->linked_transformed_connection.disconnect();
+    
+    if (new_obj && SP_IS_ITEM(new_obj)) {
+        to->linked_delete_connection = new_obj->connectDelete(sigc::bind<PathAndDirection*>(sigc::mem_fun(*this, &OriginalPathArrayParam::linked_delete), to));
+        to->linked_modified_connection = new_obj->connectModified(sigc::bind<PathAndDirection*>(sigc::mem_fun(*this, &OriginalPathArrayParam::linked_modified), to));
+        to->linked_transformed_connection = SP_ITEM(new_obj)->connectTransformed(sigc::bind<PathAndDirection*>(sigc::mem_fun(*this, &OriginalPathArrayParam::linked_transformed), to));
+
+        linked_modified(new_obj, SP_OBJECT_MODIFIED_FLAG, to);
+    } else {
+        to->_pathvector = Geom::PathVector();
+        SP_OBJECT(param_effect->getLPEObj())->requestModified(SP_OBJECT_MODIFIED_FLAG);
+        _store->foreach_iter(sigc::bind<PathAndDirection*>(sigc::mem_fun(*this, &OriginalPathArrayParam::_updateLink), to));
+    }
+}
+
+void OriginalPathArrayParam::linked_transformed(Geom::Affine const *mp, SPItem* original, PathAndDirection* to)
+{
+    
+}
+
+void OriginalPathArrayParam::setPathVector(SPObject *linked_obj, guint flags, PathAndDirection* to)
+{
+    if (!to) {
+        return;
+    }
+    SPCurve *curve = NULL;
+    if (SP_IS_SHAPE(linked_obj)) {
+        curve = SP_SHAPE(linked_obj)->getCurveBeforeLPE();
+    }
+    if (SP_IS_TEXT(linked_obj)) {
+        curve = SP_TEXT(linked_obj)->getNormalizedBpath();
+    }
+
+    if (curve == NULL) {
+        // curve invalid, set empty pathvector
+        to->_pathvector = Geom::PathVector();
+    } else {
+        to->_pathvector = curve->get_pathvector();
+        curve->unref();
+    }
+}
+
+void OriginalPathArrayParam::linked_modified(SPObject *linked_obj, guint flags, PathAndDirection* to)
+{
+    if (!to) {
+        return;
+    }
+    setPathVector(linked_obj, flags, to);
+    SP_OBJECT(param_effect->getLPEObj())->requestModified(SP_OBJECT_MODIFIED_FLAG);
+    _store->foreach_iter(sigc::bind<PathAndDirection*>(sigc::mem_fun(*this, &OriginalPathArrayParam::_updateLink), to));
+}
+
+//void PathParam::linked_transformed(Geom::Affine const *rel_transf, SPItem *moved_item)
+//{
+//    linked_transformed_callback(rel_transf, moved_item);
+//}
+
+bool OriginalPathArrayParam::param_readSVGValue(const gchar* strvalue)
+{
+    if (strvalue) {
+        while (!_vector.empty()) {
+            PathAndDirection *w = _vector.back();
+            unlink(w);
+            _vector.pop_back();
+            delete w;
+        }
+        _store->clear();
+
+        gchar ** strarray = g_strsplit(strvalue, "|", 0);
+        for (gchar ** iter = strarray; *iter != NULL; iter++) {
+            if ((*iter)[0] == '#') {
+                gchar ** substrarray = g_strsplit(*iter, ",", 0);
+                PathAndDirection* w = new PathAndDirection((SPObject *)param_effect->getLPEObj());
+                w->href = g_strdup(*substrarray);
+                w->reversed = *(substrarray+1) != NULL && (*(substrarray+1))[0] == '1';
+
+                w->linked_changed_connection = w->ref.changedSignal().connect(sigc::bind<PathAndDirection *>(sigc::mem_fun(*this, &OriginalPathArrayParam::linked_changed), w));
+                w->ref.attach(URI(w->href));
+
+                _vector.push_back(w);
+
+                Gtk::TreeModel::iterator iter = _store->append();
+                Gtk::TreeModel::Row row = *iter;
+                SPObject *obj = w->ref.getObject();
+
+                row[_model->_colObject] = w;
+                row[_model->_colLabel] = obj ? ( obj->label() ? obj->label() : obj->getId() ) : w->href;
+                row[_model->_colReverse] = w->reversed;
+                g_strfreev (substrarray);
+            }
+        }
+        g_strfreev (strarray);
+        return true;
+    }
+    return false;
+}
+
+gchar * OriginalPathArrayParam::param_getSVGValue() const
+{
+    Inkscape::SVGOStringStream os;
+    bool foundOne = false;
+    for (std::vector<PathAndDirection*>::const_iterator iter = _vector.begin(); iter != _vector.end(); iter++) {
+        if (foundOne) {
+            os << "|";
+        } else {
+            foundOne = true;
+        }
+        os << (*iter)->href << "," << ((*iter)->reversed ? "1" : "0");
+    }
+    gchar * str = g_strdup(os.str().c_str());
+    return str;
+}
+
+} /* 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/originalpatharray.h'
--- src/live_effects/parameter/originalpatharray.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/originalpatharray.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,123 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_ORIGINALPATHARRAY_H
+#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_ORIGINALPATHARRAY_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ *
+* Copyright (C) Johan Engelen 2008 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <vector>
+
+#include <gtkmm/box.h>
+#include <gtkmm/treeview.h>
+#include <gtkmm/treestore.h>
+#include <gtkmm/scrolledwindow.h>
+
+#include "live_effects/parameter/parameter.h"
+#include "live_effects/parameter/path-reference.h"
+
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "path-reference.h"
+#include "sp-object.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+class PathAndDirection {
+public:
+    PathAndDirection(SPObject *owner)
+    : href(NULL),
+    ref(owner),
+    _pathvector(Geom::PathVector()),
+    reversed(false)
+    {
+        
+    }
+    gchar *href;
+    URIReference ref;
+    //SPItem *obj;
+    std::vector<Geom::Path> _pathvector;
+    bool reversed;
+    
+    sigc::connection linked_changed_connection;
+    sigc::connection linked_delete_connection;
+    sigc::connection linked_modified_connection;
+    sigc::connection linked_transformed_connection;
+};
+    
+class OriginalPathArrayParam : public Parameter {
+public:
+    class ModelColumns;
+    
+    OriginalPathArrayParam( const Glib::ustring& label,
+                const Glib::ustring& tip,
+                const Glib::ustring& key,
+                Inkscape::UI::Widget::Registry* wr,
+                Effect* effect);
+
+    virtual ~OriginalPathArrayParam();
+
+    virtual Gtk::Widget * param_newWidget();
+    virtual bool param_readSVGValue(const gchar * strvalue);
+    virtual gchar * param_getSVGValue() const;
+    virtual void param_set_default();
+    
+    /** Disable the canvas indicators of parent class by overriding this method */
+    virtual void param_editOncanvas(SPItem * /*item*/, SPDesktop * /*dt*/) {};
+    /** Disable the canvas indicators of parent class by overriding this method */
+    virtual void addCanvasIndicators(SPLPEItem const* /*lpeitem*/, std::vector<Geom::PathVector> & /*hp_vec*/) {};
+    
+    std::vector<PathAndDirection*> _vector;
+    
+protected:
+    bool _updateLink(const Gtk::TreeIter& iter, PathAndDirection* pd);
+    bool _selectIndex(const Gtk::TreeIter& iter, int* i);
+    void unlink(PathAndDirection* to);
+    void remove_link(PathAndDirection* to);
+    void setPathVector(SPObject *linked_obj, guint flags, PathAndDirection* to);
+    
+    void linked_changed(SPObject *old_obj, SPObject *new_obj, PathAndDirection* to);
+    void linked_modified(SPObject *linked_obj, guint flags, PathAndDirection* to);
+    void linked_transformed(Geom::Affine const *mp, SPItem *original, PathAndDirection* to);
+    void linked_delete(SPObject *deleted, PathAndDirection* to);
+    
+    ModelColumns *_model;
+    Glib::RefPtr<Gtk::TreeStore> _store;
+    Gtk::TreeView _tree;
+    Gtk::CellRendererText *_text_renderer;
+    Gtk::CellRendererToggle *_toggle_renderer;
+    Gtk::TreeView::Column *_name_column;
+    Gtk::ScrolledWindow _scroller;
+    
+    void on_link_button_click();
+    void on_remove_button_click();
+    void on_up_button_click();
+    void on_down_button_click();
+    void on_reverse_toggled(const Glib::ustring& path);
+    
+private:
+    OriginalPathArrayParam(const OriginalPathArrayParam&);
+    OriginalPathArrayParam& operator=(const OriginalPathArrayParam&);
+};
+
+} //namespace LivePathEffect
+
+} //namespace Inkscape
+
+#endif
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
 
=== modified file 'src/live_effects/parameter/powerstrokepointarray.cpp'
--- src/live_effects/parameter/powerstrokepointarray.cpp	2014-07-27 01:17:50 +0000
+++ src/live_effects/parameter/powerstrokepointarray.cpp	2014-09-07 17:02:32 +0000
@@ -4,8 +4,7 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
+#include "ui/dialog/lpe-powerstroke-properties.h"
 #include "live_effects/parameter/powerstrokepointarray.h"
 
 #include "live_effects/effect.h"
@@ -21,6 +20,8 @@
 #include "desktop.h"
 #include "live_effects/lpeobject.h"
 
+#include <glibmm/i18n.h>
+
 namespace Inkscape {
 
 namespace LivePathEffect {
@@ -102,6 +103,23 @@
     }
 }
 
+float PowerStrokePointArrayParam::median_width()
+{
+	size_t size = _vector.size();
+	if (size > 0)
+	{
+		if (size % 2 == 0)
+		{
+			return (_vector[size / 2 - 1].y() + _vector[size / 2].y()) / 2;
+		}
+		else
+		{
+			return _vector[size / 2].y();
+		}
+	}
+	return 1;
+}
+
 void
 PowerStrokePointArrayParam::set_pwd2(Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in, Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_normal_in)
 {
@@ -117,7 +135,7 @@
     knot_mode  = mode;
     knot_color = color;
 }
-
+/*
 class PowerStrokePointArrayParamKnotHolderEntity : public KnotHolderEntity {
 public:
     PowerStrokePointArrayParamKnotHolderEntity(PowerStrokePointArrayParam *p, unsigned int index);
@@ -127,7 +145,7 @@
     virtual Geom::Point knot_get() const;
     virtual void knot_click(guint state);
 
-    /** Checks whether the index falls within the size of the parameter's vector */
+    // Checks whether the index falls within the size of the parameter's vector
     bool valid_index(unsigned int index) const {
         return (_pparam->_vector.size() > index);
     };
@@ -135,7 +153,7 @@
 private:
     PowerStrokePointArrayParam *_pparam;
     unsigned int _index;
-};
+};*/
 
 PowerStrokePointArrayParamKnotHolderEntity::PowerStrokePointArrayParamKnotHolderEntity(PowerStrokePointArrayParam *p, unsigned int index) 
   : _pparam(p), 
@@ -184,6 +202,12 @@
     return canvas_point;
 }
 
+void PowerStrokePointArrayParamKnotHolderEntity::knot_set_offset(Geom::Point offset)
+{
+	_pparam->_vector.at(_index) = Geom::Point(offset.x(), offset.y() / 2);
+	this->parent_holder->knot_ungrabbed_handler(this->knot, 0);
+}
+
 void
 PowerStrokePointArrayParamKnotHolderEntity::knot_click(guint state)
 {
@@ -226,10 +250,15 @@
             // add knot to knotholder
             PowerStrokePointArrayParamKnotHolderEntity *e = new PowerStrokePointArrayParamKnotHolderEntity(_pparam, _index+1);
             e->create( this->desktop, this->item, parent_holder, Inkscape::CTRL_TYPE_UNKNOWN,
-                       _("<b>Stroke width control point</b>: drag to alter the stroke width. <b>Ctrl+click</b> adds a control point, <b>Ctrl+Alt+click</b> deletes it."),
+                       _("<b>Stroke width control point</b>: drag to alter the stroke width. <b>Ctrl+click</b> adds a control point, <b>Ctrl+Alt+click</b> deletes it, <b>Shift+click</b> launches width dialog."),
                         _pparam->knot_shape, _pparam->knot_mode, _pparam->knot_color);
             parent_holder->add(e);
         }
+    }
+    else if ((state & GDK_MOD1_MASK) || (state & GDK_SHIFT_MASK))
+    {
+    	Geom::Point offset = Geom::Point(_pparam->_vector.at(_index).x(), _pparam->_vector.at(_index).y() * 2);
+    	Inkscape::UI::Dialogs::PowerstrokePropertiesDialog::showDialog(this->desktop, offset, this);
     } 
 }
 
@@ -238,7 +267,7 @@
     for (unsigned int i = 0; i < _vector.size(); ++i) {
         PowerStrokePointArrayParamKnotHolderEntity *e = new PowerStrokePointArrayParamKnotHolderEntity(this, i);
         e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                   _("<b>Stroke width control point</b>: drag to alter the stroke width. <b>Ctrl+click</b> adds a control point, <b>Ctrl+Alt+click</b> deletes it."),
+                   _("<b>Stroke width control point</b>: drag to alter the stroke width. <b>Ctrl+click</b> adds a control point, <b>Ctrl+Alt+click</b> deletes it, <b>Shift+click</b> launches width dialog."),
                    knot_shape, knot_mode, knot_color);
         knotholder->add(e);
     }
 
=== modified file 'src/live_effects/parameter/powerstrokepointarray.h'
--- src/live_effects/parameter/powerstrokepointarray.h	2014-03-27 01:33:44 +0000
+++ src/live_effects/parameter/powerstrokepointarray.h	2014-09-07 17:02:32 +0000
@@ -20,8 +20,6 @@
 
 namespace LivePathEffect {
 
-class PowerStrokePointArrayParamKnotHolderEntity;
-
 class PowerStrokePointArrayParam : public ArrayParam<Geom::Point> {
 public:
     PowerStrokePointArrayParam( const Glib::ustring& label,
@@ -37,6 +35,8 @@
 
     void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
 
+    float median_width();
+
     virtual bool providesKnotHolderEntities() const { return true; }
     virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
 
@@ -60,6 +60,25 @@
     Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2_normal;
 };
 
+class PowerStrokePointArrayParamKnotHolderEntity : public KnotHolderEntity {
+public:
+    PowerStrokePointArrayParamKnotHolderEntity(PowerStrokePointArrayParam *p, unsigned int index);
+    virtual ~PowerStrokePointArrayParamKnotHolderEntity() {}
+
+    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+    virtual Geom::Point knot_get() const;
+    virtual void knot_set_offset(Geom::Point offset);
+    virtual void knot_click(guint state);
+
+    /** Checks whether the index falls within the size of the parameter's vector */
+    bool valid_index(unsigned int index) const {
+        return (_pparam->_vector.size() > index);
+    };
+
+private:
+    PowerStrokePointArrayParam *_pparam;
+    unsigned int _index;
+};
 
 } //namespace LivePathEffect
 
 
=== added file 'src/live_effects/parameter/transformedpoint.cpp'
--- src/live_effects/parameter/transformedpoint.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/transformedpoint.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) Theodore Janeczko 2012 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "ui/widget/registered-widget.h"
+#include "live_effects/parameter/transformedpoint.h"
+#include "sp-lpe-item.h"
+#include "knotholder.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+
+#include "live_effects/effect.h"
+#include "desktop.h"
+#include "verbs.h"
+
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+TransformedPointParam::TransformedPointParam( const Glib::ustring& label, const Glib::ustring& tip,
+                        const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
+                        Effect* effect, Geom::Point default_vector,
+                        bool dontTransform)
+    : Parameter(label, tip, key, wr, effect),
+      defvalue(default_vector),
+      origin(0.,0.),
+      vector(default_vector),
+      noTransform(dontTransform)
+{
+    vec_knot_shape = SP_KNOT_SHAPE_DIAMOND;
+    vec_knot_mode  = SP_KNOT_MODE_XOR;
+    vec_knot_color = 0xffffb500;
+}
+
+TransformedPointParam::~TransformedPointParam()
+{
+
+}
+
+void
+TransformedPointParam::param_set_default()
+{
+    setOrigin(Geom::Point(0.,0.));
+    setVector(defvalue);
+}
+
+bool
+TransformedPointParam::param_readSVGValue(const gchar * strvalue)
+{
+    gchar ** strarray = g_strsplit(strvalue, ",", 4);
+    if (!strarray) {
+        return false;
+    }
+    double val[4];
+    unsigned int i = 0;
+    while (i < 4 && strarray[i]) {
+        if (sp_svg_number_read_d(strarray[i], &val[i]) != 0) {
+            i++;
+        } else {
+            break;
+        }
+    }
+    g_strfreev (strarray);
+    if (i == 4) {
+        setOrigin( Geom::Point(val[0], val[1]) );
+        setVector( Geom::Point(val[2], val[3]) );
+        return true;
+    }
+    return false;
+}
+
+gchar *
+TransformedPointParam::param_getSVGValue() const
+{
+    Inkscape::SVGOStringStream os;
+    os << origin << " , " << vector;
+    gchar * str = g_strdup(os.str().c_str());
+    return str;
+}
+
+Gtk::Widget *
+TransformedPointParam::param_newWidget()
+{
+    Inkscape::UI::Widget::RegisteredVector * pointwdg = Gtk::manage(
+        new Inkscape::UI::Widget::RegisteredVector( param_label,
+                                                    param_tooltip,
+                                                    param_key,
+                                                    *param_wr,
+                                                    param_effect->getRepr(),
+                                                    param_effect->getSPDoc() ) );
+    pointwdg->setPolarCoords();
+    pointwdg->setValue( vector, origin );
+    pointwdg->clearProgrammatically();
+    pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change vector 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
+TransformedPointParam::set_and_write_new_values(Geom::Point const &new_origin, Geom::Point const &new_vector)
+{
+    setValues(new_origin, new_vector);
+    gchar * str = param_getSVGValue();
+    param_write_to_repr(str);
+    g_free(str);
+}
+
+void
+TransformedPointParam::param_transform_multiply(Geom::Affine const& postmul, bool /*set*/)
+{
+    if (!noTransform) {
+        set_and_write_new_values( origin * postmul, vector * postmul.withoutTranslation() );
+    }
+}
+
+
+void
+TransformedPointParam::set_vector_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color)
+{
+    vec_knot_shape = shape;
+    vec_knot_mode  = mode;
+    vec_knot_color = color;
+}
+
+void
+TransformedPointParam::set_oncanvas_color(guint32 color)
+{
+    vec_knot_color = color;
+}
+
+class TransformedPointParamKnotHolderEntity_Vector : public KnotHolderEntity {
+public:
+    TransformedPointParamKnotHolderEntity_Vector(TransformedPointParam *p) : param(p) { }
+    virtual ~TransformedPointParamKnotHolderEntity_Vector() {}
+
+    virtual void knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint /*state*/) {
+        Geom::Point const s = p - param->origin;
+        /// @todo implement angle snapping when holding CTRL
+        param->setVector(s);
+        sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+    };
+    virtual Geom::Point knot_get() const{
+        return param->origin + param->vector;
+    };
+    virtual void knot_click(guint /*state*/){
+        g_print ("This is the vector handle associated to parameter '%s'\n", param->param_key.c_str());
+    };
+
+private:
+    TransformedPointParam *param;
+};
+
+void
+TransformedPointParam::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+{
+    TransformedPointParamKnotHolderEntity_Vector *vector_e = new TransformedPointParamKnotHolderEntity_Vector(this);
+    vector_e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), vec_knot_shape, vec_knot_mode, vec_knot_color);
+    knotholder->add(vector_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/transformedpoint.h'
--- src/live_effects/parameter/transformedpoint.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/transformedpoint.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,87 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_TRANSFORMED_POINT_H
+#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_TRANSFORMED_POINT_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ *
+ * Copyright (C) Theodore Janeczko 2012 <[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 TransformedPointParam : public Parameter {
+public:
+    TransformedPointParam( const Glib::ustring& label,
+                const Glib::ustring& tip,
+                const Glib::ustring& key,
+                Inkscape::UI::Widget::Registry* wr,
+                Effect* effect,
+                Geom::Point default_vector = Geom::Point(1,0),
+                bool dontTransform = false);
+    virtual ~TransformedPointParam();
+
+    virtual Gtk::Widget * param_newWidget();
+    inline const gchar *handleTip() const { return param_tooltip.c_str(); }
+
+    virtual bool param_readSVGValue(const gchar * strvalue);
+    virtual gchar * param_getSVGValue() const;
+
+    Geom::Point getVector() const { return vector; };
+    Geom::Point getOrigin() const { return origin; };
+    void setValues(Geom::Point const &new_origin, Geom::Point const &new_vector) { setVector(new_vector); setOrigin(new_origin); };
+    void setVector(Geom::Point const &new_vector) { vector = new_vector; };
+    void setOrigin(Geom::Point const &new_origin) { origin = new_origin; };
+    virtual void param_set_default();
+
+    void set_and_write_new_values(Geom::Point const &new_origin, Geom::Point const &new_vector);
+
+    virtual void param_transform_multiply(Geom::Affine const &postmul, bool set);
+
+    void set_vector_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
+    //void set_origin_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
+    void set_oncanvas_color(guint32 color);
+
+    virtual bool providesKnotHolderEntities() const { return true; }
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+
+private:
+    TransformedPointParam(const TransformedPointParam&);
+    TransformedPointParam& operator=(const TransformedPointParam&);
+
+    Geom::Point defvalue;
+
+    Geom::Point origin;
+    Geom::Point vector;
+
+    bool noTransform;
+    
+    /// The looks of the vector and origin knots oncanvas
+    SPKnotShapeType vec_knot_shape;
+    SPKnotModeType  vec_knot_mode;
+    guint32         vec_knot_color;
+//    SPKnotShapeType ori_knot_shape;
+//    SPKnotModeType  ori_knot_mode;
+//    guint32         ori_knot_color;
+
+//    friend class VectorParamKnotHolderEntity_Origin;
+    friend class TransformedPointParamKnotHolderEntity_Vector;
+};
+
+
+} //namespace LivePathEffect
+
+} //namespace Inkscape
+
+#endif
 
=== added file 'src/live_effects/pathoutlineprovider.cpp'
--- src/live_effects/pathoutlineprovider.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/pathoutlineprovider.cpp	2014-09-07 17:02:32 +0000
@@ -0,0 +1,795 @@
+#include <glib.h> //g_critical
+
+#include "pathoutlineprovider.h"
+#include "livarot/path-description.h"
+#include <2geom/angle.h>
+#include <2geom/path.h>
+#include <2geom/circle.h>
+#include <2geom/sbasis-to-bezier.h>
+#include <2geom/shape.h>
+#include <2geom/transforms.h>
+#include <2geom/path-sink.h>
+#include "helper/geom-nodetype.h"
+#include <svg/svg.h>
+
+namespace Geom {
+/**
+* Refer to: Weisstein, Eric W. "Circle-Circle Intersection."
+		 From MathWorld--A Wolfram Web Resource.
+		 http://mathworld.wolfram.com/Circle-CircleIntersection.html
+*
+* @return 0 if no intersection
+* @return 1 if one circle is contained in the other
+* @return 2 if intersections are found (they are written to p0 and p1)
+*/
+static int circle_circle_intersection(Circle const &circle0, Circle const &circle1,
+                                      Point & p0, Point & p1)
+{
+    Point X0 = circle0.center();
+    double r0 = circle0.ray();
+    Point X1 = circle1.center();
+    double r1 = circle1.ray();
+
+    /* dx and dy are the vertical and horizontal distances between
+    * the circle centers.
+    */
+    Point D = X1 - X0;
+
+    /* Determine the straight-line distance between the centers. */
+    double d = L2(D);
+
+    /* Check for solvability. */
+    if (d > (r0 + r1)) {
+        /* no solution. circles do not intersect. */
+        return 0;
+    }
+    if (d <= fabs(r0 - r1)) {
+        /* no solution. one circle is contained in the other */
+        return 1;
+    }
+
+    /* 'point 2' is the point where the line through the circle
+    * intersection points crosses the line between the circle
+    * centers.
+    */
+
+    /* Determine the distance from point 0 to point 2. */
+    double a = ((r0*r0) - (r1*r1) + (d*d)) / (2.0 * d) ;
+
+    /* Determine the coordinates of point 2. */
+    Point p2 = X0 + D * (a/d);
+
+    /* Determine the distance from point 2 to either of the
+    * intersection points.
+    */
+    double h = std::sqrt((r0*r0) - (a*a));
+
+    /* Now determine the offsets of the intersection points from
+    * point 2.
+    */
+    Point r = (h/d)*rot90(D);
+
+    /* Determine the absolute intersection points. */
+    p0 = p2 + r;
+    p1 = p2 - r;
+
+    return 2;
+}
+/**
+* Find circle that touches inside of the curve, with radius matching the curvature, at time value \c t.
+* Because this method internally uses unitTangentAt, t should be smaller than 1.0 (see unitTangentAt).
+*/
+static Circle touching_circle( D2<SBasis> const &curve, double t, double tol=0.01 )
+{
+    D2<SBasis> dM=derivative(curve);
+    if ( are_near(L2sq(dM(t)),0.) ) {
+        dM=derivative(dM);
+    }
+    if ( are_near(L2sq(dM(t)),0.) ) {   // try second time
+        dM=derivative(dM);
+    }
+    Piecewise<D2<SBasis> > unitv = unitVector(dM,tol);
+    Piecewise<SBasis> dMlength = dot(Piecewise<D2<SBasis> >(dM),unitv);
+    Piecewise<SBasis> k = cross(derivative(unitv),unitv);
+    k = divide(k,dMlength,tol,3);
+    double curv = k(t); // note that this value is signed
+
+    Geom::Point normal = unitTangentAt(curve, t).cw();
+    double radius = 1/curv;
+    Geom::Point center = curve(t) + radius*normal;
+    return Geom::Circle(center, fabs(radius));
+}
+
+std::vector<Geom::Path> split_at_cusps(const Geom::Path& in)
+{
+    PathVector out = PathVector();
+    Path temp = Path();
+
+    for (unsigned i = 0; i < in.size(); i++) {
+        temp.append(in[i]);
+        if ( get_nodetype(in[i], in[i + 1]) != Geom::NODE_SMOOTH ) {
+            out.push_back(temp);
+            temp = Path();
+        }
+    }
+    if (temp.size() > 0) {
+        out.push_back(temp);
+    }
+    return out;
+}
+
+Geom::CubicBezier sbasis_to_cubicbezier(Geom::D2<Geom::SBasis> const & sbasis_in)
+{
+    std::vector<Geom::Point> temp;
+    sbasis_to_bezier(temp, sbasis_in, 4);
+    return Geom::CubicBezier( temp );
+}
+
+static boost::optional<Geom::Point> intersection_point(Geom::Point const & origin_a, Geom::Point const & vector_a, Geom::Point const & origin_b, Geom::Point const & vector_b)
+{
+    Geom::Coord denom = cross(vector_b, vector_a);
+    if (!Geom::are_near(denom,0.)) {
+        Geom::Coord t = (cross(origin_a,vector_b) + cross(vector_b,origin_b)) / denom;
+        return origin_a + t * vector_a;
+    }
+    return boost::none;
+}
+
+} // namespace Geom
+
+namespace Outline {
+
+typedef Geom::D2<Geom::SBasis> D2SB;
+typedef Geom::Piecewise<D2SB> PWD2;
+
+// UTILITY
+
+unsigned bezierOrder (const Geom::Curve* curve_in)
+{
+    using namespace Geom;
+    if ( const BezierCurve* bz = dynamic_cast<const BezierCurve*>(curve_in) ) {
+        return bz->order();
+    }
+    return 0;
+}
+
+/** 
+ * @return true if the angle formed by the curves and their handles is greater than 180 degrees clockwise, otherwise false.
+ */
+bool outside_angle (const Geom::Curve& cbc1, const Geom::Curve& cbc2)
+{
+    Geom::Point start_point;
+    Geom::Point cross_point = cbc1.finalPoint();
+    Geom::Point end_point;
+
+    if (cross_point != cbc2.initialPoint()) {
+        g_warning("Non-contiguous path in Outline::outside_angle()");
+        return false;
+    }
+    
+    Geom::CubicBezier cubicBezier = Geom::sbasis_to_cubicbezier(cbc1.toSBasis());
+    start_point = cubicBezier [2];
+
+    /*
+     * Because the node editor does not yet support true quadratics, paths are converted to 
+     * cubic beziers in the node tool with degenerate handles on one side.
+     */
+
+    if (are_near(start_point, cross_point, 0.0000001)) {
+         start_point = cubicBezier [1];
+    }
+    cubicBezier = Geom::sbasis_to_cubicbezier(cbc2.toSBasis());
+    end_point = cubicBezier [1];
+    if (are_near(end_point, cross_point, 0.0000001)) {
+        end_point = cubicBezier [2];
+    }
+
+    // got our three points, now let's see what their clockwise angle is
+
+    // Definition of a Graham scan
+
+    /********************************************************************
+    # Three points are a counter-clockwise turn if ccw > 0, clockwise if
+    # ccw < 0, and collinear if ccw = 0 because ccw is a determinant that
+    # gives the signed area of the triangle formed by p1, p2 and p3.
+    function ccw(p1, p2, p3):
+        return (p2.x - p1.x)*(p3.y - p1.y) - (p2.y - p1.y)*(p3.x - p1.x)
+    *********************************************************************/
+
+    double ccw = ( (cross_point.x() - start_point.x()) * (end_point.y() - start_point.y()) ) -
+                 ( (cross_point.y() - start_point.y()) * (end_point.x() - start_point.x()) );
+    return ccw > 0;
+}
+
+// LINE JOINS
+
+typedef Geom::BezierCurveN<1u> BezierLine;
+
+/**
+ * Removes the crossings on an interior join.
+ * @param path_builder Contains the incoming segment; result is appended to this
+ * @param outgoing The outgoing segment
+ */
+void joinInside(Geom::Path& path_builder, Geom::Curve const& outgoing) {
+    Geom::Curve const& incoming = path_builder.back();
+
+    // Using Geom::crossings to find intersections between two curves
+    Geom::Crossings cross = Geom::crossings(incoming, outgoing);
+    if (!cross.empty()) {
+        // Crossings found, create the join
+        Geom::CubicBezier cubic = Geom::sbasis_to_cubicbezier(incoming.toSBasis());
+        cubic = cubic.subdivide(cross[0].ta).first;
+        // erase the last segment, as we're going to overwrite it now
+        path_builder.erase_last();
+        path_builder.append(cubic, Geom::Path::STITCH_DISCONTINUOUS);
+
+        cubic = Geom::sbasis_to_cubicbezier(outgoing.toSBasis());
+        cubic = cubic.subdivide(cross[0].tb).second;
+        path_builder.append(cubic, Geom::Path::STITCH_DISCONTINUOUS);
+    } else {
+        // No crossings occurred, or Geom::crossings() failed; default to bevel
+        if (Geom::are_near(incoming.finalPoint(), outgoing.initialPoint())) {
+            path_builder.appendNew<BezierLine>(outgoing.initialPoint());
+        } else {
+            path_builder.setFinal(outgoing.initialPoint());
+        }
+    }
+}
+
+/**
+ * Try to create a miter join. Falls back to bevel if no miter can be created.
+ * @param path_builder Path to append curves to; back() is the incoming curve
+ * @param outgoing Outgoing curve.
+ * @param miter_limit When mitering, don't exceed this length
+ * @param line_width The thickness of the line.
+ */
+void miter_curves(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) {
+    using namespace Geom;
+    Curve const& incoming = path_builder.back();
+    Point tang1 = unitTangentAt(Geom::reverse(incoming.toSBasis()), 0.);
+    Point tang2 = unitTangentAt(outgoing.toSBasis(), 0);
+
+    boost::optional <Point> p = intersection_point (incoming.finalPoint(), tang1, outgoing.initialPoint(), tang2);
+    if (p) {
+        // check size of miter
+        Point point_on_path = incoming.finalPoint() - rot90(tang1) * line_width;
+        Coord len = distance(*p, point_on_path);
+        if (len <= miter_limit) {
+            // miter OK
+            path_builder.appendNew<BezierLine>(*p);
+        }
+    }
+    path_builder.appendNew<BezierLine>(outgoing.initialPoint());
+}
+
+/**
+ * Smoothly extrapolate curves along a circular route. Falls back to miter if necessary.
+ * @param path_builder Path to append curves to; back() is the incoming curve
+ * @param outgoing Outgoing curve.
+ * @param miter_limit When mitering, don't exceed this length
+ * @param line_width The thickness of the line. Used for miter fallback.
+ */
+void extrapolate_curves(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width) {
+    Geom::Curve const& incoming = path_builder.back();
+    Geom::Point endPt = outgoing.initialPoint();
+
+    // The method used when extrapolating curves fails to work when either side of the join to be extrapolated
+    // is a line segment. When this situation is encountered, fall back to a regular miter join.
+    bool lineProblem = (dynamic_cast<const BezierLine *>(&incoming)) || (dynamic_cast<const BezierLine *>(&outgoing));
+    if (lineProblem == false) {
+        // Geom::Point tang1 = Geom::unitTangentAt(Geom::reverse(incoming.toSBasis()), 0.);
+        Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0);
+
+        Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.);
+        Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0);
+
+        Geom::Point points[2];
+        int solutions = Geom::circle_circle_intersection(circle1, circle2, points[0], points[1]);
+        if (solutions == 2) {
+            Geom::Point sol(0,0);
+            if ( dot(tang2,points[0]-endPt) > 0 ) {
+                // points[0] is bad, choose points[1]
+                sol = points[1];
+            } else if ( dot(tang2,points[1]-endPt) > 0 ) { // points[0] could be good, now check points[1]
+                // points[1] is bad, choose points[0]
+                sol = points[0];
+            } else {
+                // both points are good, choose nearest
+                sol = ( distanceSq(endPt, points[0]) < distanceSq(endPt, points[1]) ) ? points[0] : points[1];
+            }
+
+            Geom::EllipticalArc *arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true);
+            Geom::EllipticalArc *arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true);
+            try {
+                if (arc0) {
+                    path_builder.append (arc0->toSBasis());
+                    delete arc0;
+                    arc0 = NULL;
+                } else { 
+                    throw std::exception();
+                }
+
+                if (arc1) {
+                    path_builder.append (arc1->toSBasis());
+                    delete arc1;
+                    arc1 = NULL;
+                } else {
+                    throw std::exception();
+                }
+
+            } catch (std::exception const & ex) {
+                g_warning("Error extrapolating line join: %s\n", ex.what());
+                path_builder.appendNew<Geom::LineSegment>(endPt);
+            }
+        } else {
+            // 1 or no solutions found, default to miter
+            miter_curves(path_builder, outgoing, miter_limit, line_width);
+        }
+    } else {
+        // Line segments exist
+        miter_curves(path_builder, outgoing, miter_limit, line_width);
+    }
+}
+
+/**
+ * Extrapolate curves by reflecting them along the line that would be given by beveling the join.
+ * @param path_builder Path to append curves to; back() is the incoming curve
+ * @param outgoing Outgoing curve.
+ * @param miter_limit When mitering, don't exceed this length
+ * @param line_width The thickness of the line. Used for miter fallback.
+ */
+void reflect_curves(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width)
+{
+    using namespace Geom;
+    Curve const& incoming = path_builder.back();
+    // On the outside, we'll take the incoming curve, the outgoing curve, and
+    // reflect them over the line formed by taking the unit tangent vector at times
+    // 0 and 1, respectively, rotated by 90 degrees.
+    Crossings cross;
+
+    // reflect curves along the line that would be given by beveling the join
+    Point tang1 = unitTangentAt(reverse(incoming.toSBasis()), 0.);
+    D2SB newcurve1 = incoming.toSBasis() * reflection(-rot90(tang1), incoming.finalPoint());
+    CubicBezier bzr1 = sbasis_to_cubicbezier(reverse(newcurve1));
+
+    Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0.);
+    D2SB newcurve2 = outgoing.toSBasis() * reflection(-rot90(tang2), outgoing.initialPoint());
+    CubicBezier bzr2 = sbasis_to_cubicbezier(reverse(newcurve2));
+
+    cross = crossings(bzr1, bzr2);
+    if (cross.empty()) {
+        // paths don't cross, fall back to miter
+        miter_curves(path_builder, outgoing, miter_limit, line_width);
+    } else {
+        // reflected join
+        std::pair<CubicBezier, CubicBezier> sub1 = bzr1.subdivide(cross[0].ta);
+        std::pair<CubicBezier, CubicBezier> sub2 = bzr2.subdivide(cross[0].tb);
+
+        // TODO it seems as if a bug in 2geom sometimes doesn't catch the first 
+        // crossing of paths, but the second instead; but only sometimes.
+        path_builder.appendNew <CubicBezier> (sub1.first[1], sub1.first[2], sub2.second[0]);
+        path_builder.appendNew <CubicBezier> (sub2.second[1], sub2.second[2], outgoing.initialPoint());
+    }
+}
+
+// Ideal function pointer we want to pass
+typedef void JoinFunc(Geom::Path& /*path_builder*/, Geom::Curve const& /*outgoing*/, double /*miter_limit*/, double /*line_width*/);
+
+/**
+ * Helper function for repeated logic in outlineHalf.
+ */
+static void outlineHelper(Geom::Path& path_builder, Geom::PathVector* path_vec, bool outside, double width, double miter, JoinFunc func) {
+    Geom::Curve * cbc2 = path_vec->front()[0].duplicate();
+
+    if (outside) {
+        func(path_builder, *cbc2, miter, width);
+    } else {
+        joinInside(path_builder, *cbc2);
+    }
+
+    // store it
+    Geom::Path temp_path = path_vec->front();
+    if (!outside) {
+        // erase the first segment since the inside join code already appended it
+        temp_path.erase(temp_path.begin());
+    }
+    
+    if (temp_path.initialPoint() != path_builder.finalPoint()) {
+        temp_path.setInitial(path_builder.finalPoint());
+    }
+    
+    path_builder.append(temp_path);
+    
+    delete cbc2;
+}
+
+/**
+ * Offsets exactly one half of a bezier spline (path).
+ * @param path_in The input path to use. (To create the other side use path_in.reverse() )
+ * @param line_width the line width to use (usually you want to divide this by 2)
+ * @param miter_limit the miter parameter
+ * @param func Join function to apply at each join.
+ */
+
+Geom::Path outlineHalf(const Geom::Path& path_in, double line_width, double miter_limit, JoinFunc func) {
+    // NOTE: it is important to notice the distinction between a Geom::Path and a livarot ::Path here!
+    // if you do not see "Geom::" there is a different function set!
+
+    Geom::PathVector pv = split_at_cusps(path_in);
+
+    ::Path to_outline;
+    ::Path outlined_result;
+
+    Geom::Path path_builder = Geom::Path(); // the path to store the result in
+    Geom::PathVector* path_vec; // needed because livarot returns a pointer (TODO make this not a pointer)
+
+    // Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well
+    const size_t k = pv.size();
+    for (size_t u = 0; u < k; u += 2) {
+        to_outline = Path();
+        outlined_result = Path();
+
+        to_outline.LoadPath(pv[u], Geom::identity(), false, false);
+        to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10);
+        // now a curve has been outside outlined and loaded into outlined_result
+
+        // get the Geom::Path
+        path_vec = outlined_result.MakePathVector();
+
+        // on the first run through, there is no join
+        if (u == 0) {
+            path_builder.start(path_vec->front().initialPoint());
+            path_builder.append(path_vec->front());
+        } else {
+            outlineHelper(path_builder, path_vec, outside_angle(pv[u-1][pv[u-1].size()-1], pv[u][0]), line_width, miter_limit, func);
+        }
+
+        // outline the next segment, but don't store it yet
+        if (path_vec)
+            delete path_vec;
+        path_vec = NULL;
+
+        // odd number of paths
+        if (u < k - 1) {
+            outlined_result = Path();
+            to_outline = Path();
+
+            to_outline.LoadPath(pv[u+1], Geom::Affine(), false, false);
+            to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10);
+
+            path_vec = outlined_result.MakePathVector();
+            outlineHelper(path_builder, path_vec, outside_angle(pv[u][pv[u].size()-1], pv[u+1][0]), line_width, miter_limit, func);
+
+            if (path_vec)
+                delete path_vec;
+            path_vec = NULL;
+        }
+    }
+    
+    if (path_in.closed()) {
+        Geom::Curve * cbc1;
+        Geom::Curve * cbc2;
+        
+        if ( path_in[path_in.size()].isDegenerate() ) {
+            // handle case for last segment curved
+            outlined_result = Path();
+            to_outline = Path();
+            
+            Geom::Path oneCurve; oneCurve.append(path_in[0]);
+
+            to_outline.LoadPath(oneCurve, Geom::Affine(), false, false);
+            to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10);
+
+            path_vec = outlined_result.MakePathVector();
+
+            cbc1 = path_builder[path_builder.size() - 1].duplicate();
+            cbc2 = path_vec->front()[0].duplicate();
+            
+            delete path_vec;
+        } else {
+            // handle case for last segment straight
+            // since the path doesn't actually give us access to it, we'll do it ourselves
+            outlined_result = Path();
+            to_outline = Path();
+            
+            Geom::Path oneCurve; oneCurve.append(Geom::LineSegment(path_in.finalPoint(), path_in.initialPoint()));
+
+            to_outline.LoadPath(oneCurve, Geom::Affine(), false, false);
+            to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10);
+
+            path_vec = outlined_result.MakePathVector();
+
+            cbc1 = path_builder[path_builder.size() - 1].duplicate();
+            cbc2 = (*path_vec)[0]  [0].duplicate();
+            
+            outlineHelper(path_builder, path_vec, outside_angle(path_in[path_in.size()-1], oneCurve[0]), line_width, miter_limit, func);
+
+            delete cbc1;
+            cbc1 = cbc2->duplicate();
+            delete path_vec;
+            
+            oneCurve = Geom::Path(); oneCurve.append(path_in[0]);
+            
+            to_outline.LoadPath(oneCurve, Geom::Affine(), false, false);
+            to_outline.OutsideOutline(&outlined_result, line_width / 2, join_straight, butt_straight, 10);
+
+            path_vec = outlined_result.MakePathVector();
+            delete cbc2; cbc2 = (*path_vec)[0] [0].duplicate();
+            delete path_vec;
+        }
+        
+        Geom::Path temporary;
+        temporary.append(*cbc1);
+        
+        Geom::Curve const & prev_curve = path_in[path_in.size()].isDegenerate() ? path_in[path_in.size() - 1] : path_in[path_in.size()];
+        Geom::Path isStraight;
+        isStraight.append(prev_curve);
+        isStraight.append(path_in[0]);
+        // does closing path require a join?
+        if (Geom::split_at_cusps(isStraight).size() > 1) {       
+            bool outside = outside_angle(prev_curve, path_in[0]);
+            if (outside) {
+                func(temporary, *cbc2, miter_limit, line_width);
+            } else {
+                joinInside(temporary, *cbc2);
+                path_builder.erase(path_builder.begin());
+            }
+
+            // extract the appended curves
+            path_builder.erase_last();
+            if (Geom::are_near(path_builder.finalPoint(), temporary.initialPoint())) {
+                path_builder.setFinal(temporary.initialPoint());
+            } else {
+                path_builder.appendNew<BezierLine>(temporary.initialPoint());
+            }
+            path_builder.append(temporary);
+        } else {
+            // closing path does not require a join
+            path_builder.setFinal(path_builder.initialPoint());
+        }
+        path_builder.close();
+        
+        if (cbc1) delete cbc1;
+        if (cbc2) delete cbc2;
+    }
+
+    return path_builder;
+}
+
+Geom::PathVector outlinePath(const Geom::PathVector& path_in, double line_width, LineJoinType join, ButtTypeMod butt, double miter_lim, bool extrapolate, double start_lean, double end_lean)
+{
+    Geom::PathVector path_out;
+
+    unsigned pv_size = path_in.size();
+    for (unsigned i = 0; i < pv_size; i++) {
+
+        if (path_in[i].size() > 1) {
+            Geom::Path with_direction;
+            Geom::Path against_direction;
+
+            with_direction = Outline::outlineHalf(path_in[i], -line_width, miter_lim, extrapolate ? extrapolate_curves : reflect_curves);
+            against_direction = Outline::outlineHalf(path_in[i].reverse(), -line_width, miter_lim, extrapolate ? extrapolate_curves : reflect_curves);
+            
+            Geom::PathBuilder pb;
+
+            pb.moveTo(with_direction.initialPoint());
+            pb.append(with_direction);
+
+            //add in our line caps
+            if (!path_in[i].closed()) {
+                switch (butt) {
+                case BUTT_STRAIGHT:
+                    pb.lineTo(against_direction.initialPoint());
+                    break;
+                case BUTT_ROUND:
+                    pb.arcTo((-line_width) / 2, (-line_width) / 2, 0., true, true, against_direction.initialPoint() );
+                    break;
+                case BUTT_POINTY: {
+                    Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(path_in[i].back().toSBasis()), 0.);
+                    double radius = 0.5 * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint());
+                    Geom::Point midpoint = 0.5 * (with_direction.finalPoint() + against_direction.initialPoint()) + radius*end_deriv;
+                    pb.lineTo(midpoint);
+                    pb.lineTo(against_direction.initialPoint());
+                    break;
+                }
+                case BUTT_SQUARE: {
+                    Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(path_in[i].back().toSBasis()), 0.);
+                    double radius = 0.5 * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint());
+                    pb.lineTo(with_direction.finalPoint() + radius*end_deriv);
+                    pb.lineTo(against_direction.initialPoint() + radius*end_deriv);
+                    pb.lineTo(against_direction.initialPoint());
+                    break;
+                }
+                case BUTT_LEANED: {
+                    Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(path_in[i].back().toSBasis()), 0.);
+                    double maxRadius = (end_lean+0.5) * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint());
+                    double minRadius = ((end_lean*-1)+0.5) * Geom::distance(with_direction.finalPoint(), against_direction.initialPoint());
+                    pb.lineTo(with_direction.finalPoint() + maxRadius*end_deriv);
+                    pb.lineTo(against_direction.initialPoint() + minRadius*end_deriv);
+                    pb.lineTo(against_direction.initialPoint());
+                    break;
+                }
+                }
+            } else {
+                pb.moveTo(against_direction.initialPoint());
+            }
+
+            pb.append(against_direction);
+
+            //cap (if necessary)
+            if (!path_in[i].closed()) {
+                switch (butt) {
+                case BUTT_STRAIGHT:
+                    pb.lineTo(with_direction.initialPoint());
+                    break;
+                case BUTT_ROUND:
+                    pb.arcTo((-line_width) / 2, (-line_width) / 2, 0., true, true, with_direction.initialPoint() );
+                    break;
+                case BUTT_POINTY: {
+                    Geom::Point end_deriv = -Geom::unitTangentAt(path_in[i].front().toSBasis(), 0.);
+                    double radius = 0.5 * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint());
+                    Geom::Point midpoint = 0.5 * (against_direction.finalPoint() + with_direction.initialPoint()) + radius*end_deriv;
+                    pb.lineTo(midpoint);
+                    pb.lineTo(with_direction.initialPoint());
+                    break;
+                }
+                case BUTT_SQUARE: {
+                    Geom::Point end_deriv = -Geom::unitTangentAt(path_in[i].front().toSBasis(), 0.);
+                    double radius = 0.5 * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint());
+                    pb.lineTo(against_direction.finalPoint() + radius*end_deriv);
+                    pb.lineTo(with_direction.initialPoint() + radius*end_deriv);
+                    pb.lineTo(with_direction.initialPoint());
+                    break;
+                }
+                case BUTT_LEANED: {
+                    Geom::Point end_deriv = -Geom::unitTangentAt(path_in[i].front().toSBasis(), 0.);
+                    double maxRadius = (start_lean+0.5) * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint());
+                    double minRadius = ((start_lean*-1)+0.5) * Geom::distance(against_direction.finalPoint(), with_direction.initialPoint());
+                    pb.lineTo(against_direction.finalPoint() + minRadius*end_deriv);
+                    pb.lineTo(with_direction.initialPoint() + maxRadius*end_deriv);
+                    pb.lineTo(with_direction.initialPoint());
+                    break;
+                }
+                }
+            }
+            pb.flush();
+            path_out.push_back(pb.peek()[0]);
+            if (path_in[i].closed()) {
+                path_out.push_back(pb.peek()[1]);
+            }
+        } else {
+            Path p = Path();
+            Path outlinepath = Path();
+            ButtType original_butt;
+            switch (butt) {
+            case BUTT_STRAIGHT:
+                original_butt = butt_straight;
+               break;
+            case BUTT_ROUND:
+               original_butt = butt_round;
+                break;
+            case butt_pointy: {
+                original_butt = butt_pointy;
+                break;
+            }
+            case BUTT_SQUARE: {
+                original_butt = butt_square;
+                break;
+            }
+            case BUTT_LEANED: {
+                original_butt = butt_straight;
+                break;
+            }
+            }
+            p.LoadPath(path_in[i], Geom::Affine(), false, false);
+            p.Outline(&outlinepath, line_width / 2, static_cast<join_typ>(join), original_butt, miter_lim);
+            Geom::PathVector *pv_p = outlinepath.MakePathVector();
+            //somewhat hack-ish
+            path_out.push_back( (*pv_p)[0].reverse() );
+            if (pv_p) delete pv_p;
+        }
+    }
+    return path_out;
+}
+
+Geom::PathVector PathVectorOutline(Geom::PathVector const & path_in, double line_width, ButtTypeMod linecap_type, LineJoinType linejoin_type, double miter_limit, double start_lean, double end_lean)
+{
+    std::vector<Geom::Path> path_out = std::vector<Geom::Path>();
+    if (path_in.empty()) {
+        return path_out;
+    }
+    Path p = Path();
+    Path outlinepath = Path();
+    for (unsigned i = 0; i < path_in.size(); i++) {
+        p.LoadPath(path_in[i], Geom::Affine(), false, ( (i==0) ? false : true));
+    }
+
+#define miter_lim fabs(line_width * miter_limit)
+
+    //magic!
+    ButtType original_butt;
+    switch (linecap_type) {
+        case BUTT_STRAIGHT:
+            original_butt = butt_straight;
+            break;
+        case BUTT_ROUND:
+            original_butt = butt_round;
+            break;
+        case butt_pointy: {
+            original_butt = butt_pointy;
+            break;
+        }
+        case BUTT_SQUARE: {
+            original_butt = butt_square;
+            break;
+        }
+        case BUTT_LEANED: {
+            original_butt = butt_straight;
+            break;
+        }
+    }
+    if (linejoin_type <= LINEJOIN_POINTY) {
+        p.Outline(&outlinepath, line_width / 2, static_cast<join_typ>(linejoin_type),
+                  original_butt, miter_lim);
+        // fix memory leak
+        std::vector<Geom::Path> *pv_p = outlinepath.MakePathVector();
+        path_out = *pv_p;
+        delete pv_p;
+
+    } else if (linejoin_type == LINEJOIN_REFLECTED) {
+        // reflected arc join
+        path_out = outlinePath(path_in, line_width, static_cast<LineJoinType>(linejoin_type),
+                               linecap_type , miter_lim, false, start_lean, end_lean);
+
+    } else if (linejoin_type == LINEJOIN_EXTRAPOLATED) {
+        // extrapolated arc join
+        path_out = outlinePath(path_in, line_width, LINEJOIN_STRAIGHT, linecap_type, miter_lim, true, start_lean, end_lean);
+    }
+
+#undef miter_lim
+    return path_out;
+}
+
+Geom::Path PathOutsideOutline(Geom::Path const & path_in, double line_width, LineJoinType linejoin_type, double miter_limit)
+{
+
+#define miter_lim fabs(line_width * miter_limit)
+
+    Geom::Path path_out;
+
+    if (linejoin_type <= LINEJOIN_POINTY || path_in.size() <= 1) {
+
+        Geom::PathVector * pathvec;
+
+        Path path_tangent = Path();
+        Path path_outline = Path();
+        path_outline.LoadPath(path_in, Geom::Affine(), false, false);
+        path_outline.OutsideOutline(&path_tangent, line_width / 2, static_cast<join_typ>(linejoin_type), butt_straight, miter_lim);
+
+        pathvec = path_tangent.MakePathVector();
+        path_out = pathvec->front();
+        delete pathvec;
+        return path_out;
+    } else if (linejoin_type == LINEJOIN_REFLECTED) {
+        path_out = outlineHalf(path_in, line_width, miter_lim, reflect_curves);
+        return path_out;
+    } else if (linejoin_type == LINEJOIN_EXTRAPOLATED) {
+        path_out = outlineHalf(path_in, line_width, miter_lim, extrapolate_curves);
+        return path_out;
+    }
+#undef miter_lim
+    return path_out;
+}
+
+} // namespace Outline
+
+/*
+  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:encoding=utf-8 :
 
=== added file 'src/live_effects/pathoutlineprovider.h'
--- src/live_effects/pathoutlineprovider.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/pathoutlineprovider.h	2014-09-07 17:02:32 +0000
@@ -0,0 +1,55 @@
+#ifndef SEEN_PATH_OUTLINE_H
+#define SEEN_PATH_OUTLINE_H
+
+/* Author:
+ *   Liam P. White <[e-mail]>
+ *
+ * Copyright (C) 2014 Author
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <livarot/Path.h>
+#include <livarot/LivarotDefs.h>
+
+enum LineJoinType {
+    LINEJOIN_STRAIGHT,
+    LINEJOIN_ROUND,
+    LINEJOIN_POINTY,
+    LINEJOIN_REFLECTED,
+    LINEJOIN_EXTRAPOLATED
+};
+enum ButtTypeMod {
+    BUTT_STRAIGHT,
+    BUTT_ROUND,
+    BUTT_SQUARE,
+    BUTT_POINTY,
+    BUTT_LEANED
+};
+
+namespace Geom
+{
+    Geom::CubicBezier sbasis_to_cubicbezier(Geom::D2<Geom::SBasis> const & sbasis_in);
+    std::vector<Geom::Path> split_at_cusps(const Geom::Path& in);
+}
+
+namespace Outline 
+{
+    unsigned bezierOrder (const Geom::Curve* curve_in);
+    std::vector<Geom::Path> PathVectorOutline(std::vector<Geom::Path> const & path_in, double line_width, ButtTypeMod linecap_type,
+                                              LineJoinType linejoin_type, double miter_limit, double start_lean = 0, double end_lean = 0);
+    Geom::Path PathOutsideOutline(Geom::Path const & path_in, double line_width, LineJoinType linejoin_type, double miter_limit);
+}
+
+#endif // SEEN_PATH_OUTLINE_H
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 :
 
=== modified file 'src/menus-skeleton.h'
--- src/menus-skeleton.h	2014-03-30 22:08:13 +0000
+++ src/menus-skeleton.h	2014-09-07 17:02:32 +0000
@@ -178,6 +178,9 @@
 "       <verb verb-id=\"DialogLayers\" />\n"
 "   </submenu>\n"
 "   <submenu name=\"" N_("_Object") "\">\n"
+"       <verb verb-id=\"DialogObjects\" />\n"
+"       <verb verb-id=\"DialogTags\" />\n"
+"       <separator/>\n"
 "       <verb verb-id=\"DialogFillStroke\" />\n"
 "       <verb verb-id=\"DialogObjectProperties\" />\n"
 "       <verb verb-id=\"DialogSymbols\" />\n"
 
=== modified file 'src/path-chemistry.cpp'
--- src/path-chemistry.cpp	2014-03-27 01:33:44 +0000
+++ src/path-chemistry.cpp	2014-09-07 17:02:32 +0000
@@ -22,6 +22,7 @@
 #include "xml/repr.h"
 #include "svg/svg.h"
 #include "display/curve.h"
+#include "color.h"
 #include <glib.h>
 #include <glibmm/i18n.h>
 #include "sp-path.h"
@@ -433,6 +434,10 @@
         gchar *title = item->title();
         // remember description
         gchar *desc = item->desc();
+        // remember highlight color
+        guint32 highlight_color = 0;
+        if (item->isHighlightSet())
+            highlight_color = item->highlight_color();
 
         // It's going to resurrect, so we delete without notifying listeners.
         item->deleteObject(false);
@@ -450,6 +455,9 @@
             newObj->setDesc(desc);
             g_free(desc);
         }
+        if (highlight_color && newObj) {
+                SP_ITEM(newObj)->setHighlightColor( highlight_color );
+        }
 
         // move to the saved position
         repr->setPosition(pos > 0 ? pos : 0);
 
=== modified file 'src/selection-chemistry.cpp'
--- src/selection-chemistry.cpp	2014-08-17 14:46:20 +0000
+++ src/selection-chemistry.cpp	2014-09-07 17:02:32 +0000
@@ -2792,54 +2792,53 @@
     if (desktop == NULL) {
         return;
     }
-
-    Inkscape::Selection *selection = sp_desktop_selection(desktop);
-    SPItem *item = selection->singleItem();
-    if (g_slist_length(const_cast<GSList *>(selection->itemList())) != 1 || !item) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>one</b> path to clone."));
-        return;
-    }
-    if ( !(SP_IS_SHAPE(item) || SP_IS_TEXT(item)) ) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select one <b>path</b> to clone."));
-        return;
-    }
-
-    Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
-    Inkscape::XML::Node *parent = item->getRepr()->parent();
-
-    // create the LPE
-    Inkscape::XML::Node *lpe_repr = xml_doc->createElement("inkscape:path-effect");
-    {
-        lpe_repr->setAttribute("effect", "clone_original");
-        gchar *href = g_strdup_printf("#%s", item->getRepr()->attribute("id"));
-        lpe_repr->setAttribute("linkedpath", href);
-        g_free(href);
-        desktop->doc()->getDefs()->getRepr()->addChild(lpe_repr, NULL); // adds to <defs> and assigns the 'id' attribute
-    }
-    const gchar * lpe_id = lpe_repr->attribute("id");
-    Inkscape::GC::release(lpe_repr);
-
-    // create the new path
-    Inkscape::XML::Node *clone = xml_doc->createElement("svg:path");
-    {
-        clone->setAttribute("d", "M 0 0", false);
-        // add the new clone to the top of the original's parent
-        parent->appendChild(clone);
-        SPObject *clone_obj = desktop->doc()->getObjectById(clone->attribute("id"));
-        if (SP_IS_LPE_ITEM(clone_obj)) {
-            gchar *href = g_strdup_printf("#%s", lpe_id);
-            SP_LPE_ITEM(clone_obj)->addPathEffect( href, false );
-            g_free(href);
-        }
-    }
-
-    DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_EDIT_CLONE_ORIGINAL_PATH_LPE,
-                       _("Clone original path"));
-
-    // select the new object:
-    selection->set(clone);
-
-    Inkscape::GC::release(clone);
+    
+    Inkscape::SVGOStringStream os;
+    SPObject * firstItem = NULL;
+    for (const GSList * item = desktop->selection->itemList(); item != NULL; item = item->next) {
+        if (SP_IS_SHAPE(item->data) || SP_IS_TEXT(item->data)) {
+            if (firstItem) {
+                os << "|";
+            } else {
+                firstItem = SP_ITEM(item->data);
+            }
+            os << "#" << SP_ITEM(item->data)->getId() << ",0";
+        }
+    }
+    if (firstItem) {
+        Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
+        SPObject *parent = firstItem->parent;
+
+        // create the LPE
+        Inkscape::XML::Node *lpe_repr = xml_doc->createElement("inkscape:path-effect");
+        {
+            lpe_repr->setAttribute("effect", "fill_between_many");
+            lpe_repr->setAttribute("linkedpaths", os.str().c_str());
+            desktop->doc()->getDefs()->getRepr()->addChild(lpe_repr, NULL); // adds to <defs> and assigns the 'id' attribute
+        }
+        const gchar * lpe_id = lpe_repr->attribute("id");
+        Inkscape::GC::release(lpe_repr);
+
+        // create the new path
+        Inkscape::XML::Node *clone = xml_doc->createElement("svg:path");
+        {
+            clone->setAttribute("d", "M 0 0", false);
+            // add the new clone to the top of the original's parent
+            parent->appendChildRepr(clone);
+            SPObject *clone_obj = desktop->doc()->getObjectById(clone->attribute("id"));
+            if (SP_IS_LPE_ITEM(clone_obj)) {
+                gchar *href = g_strdup_printf("#%s", lpe_id);
+                //sp_lpe_item_add_path_effect( SP_LPE_ITEM(clone_obj), href, false );
+                SP_LPE_ITEM(clone_obj)->addPathEffect(href, false);
+                g_free(href);
+            }
+        }
+
+        DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_EDIT_CLONE_ORIGINAL_PATH_LPE,
+                            _("Fill between strokes"));
+    } else {
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select path(s) to fill."));
+    }
 }
 
 void sp_selection_to_marker(SPDesktop *desktop, bool apply)
@@ -3663,6 +3662,118 @@
     g_free(filepath);
 }
 
+/* Creates a mask or clipPath from selection.
+ * What is a clip group?
+ * A clip group is a tangled mess of XML that allows an object inside a group
+ * to clip the entire group using a few <use>s and generally irritating me.
+ */
+
+void sp_selection_set_clipgroup(SPDesktop *desktop)
+{
+    if (desktop == NULL) {
+        return;
+    }
+    SPDocument* doc = sp_desktop_document(desktop);
+    Inkscape::XML::Document *xml_doc = doc->getReprDoc();
+
+    Inkscape::Selection *selection = sp_desktop_selection(desktop);
+    if (selection->isEmpty()) {
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to create clippath or mask from."));
+        return;
+    }
+        
+    GSList const *l = const_cast<GSList *>(selection->reprList());
+
+    GSList *p = g_slist_copy(const_cast<GSList *>(l));
+    
+    p = g_slist_sort(p, (GCompareFunc) sp_repr_compare_position);
+
+    selection->clear();
+
+    gint topmost = (static_cast<Inkscape::XML::Node *>(g_slist_last(p)->data))->position();
+    Inkscape::XML::Node *topmost_parent = (static_cast<Inkscape::XML::Node *>(g_slist_last(p)->data))->parent();
+
+    Inkscape::XML::Node *inner = xml_doc->createElement("svg:g");
+    inner->setAttribute("inkscape:label", "Clip");
+    
+    while (p) {
+        Inkscape::XML::Node *current = static_cast<Inkscape::XML::Node *>(p->data);
+
+        if (current->parent() == topmost_parent) {
+            Inkscape::XML::Node *spnew = current->duplicate(xml_doc);
+            sp_repr_unparent(current);
+            inner->appendChild(spnew);
+            Inkscape::GC::release(spnew);
+            topmost --; // only reduce count for those items deleted from topmost_parent
+        } else { // move it to topmost_parent first
+            GSList *temp_clip = NULL;
+
+            // At this point, current may already have no item, due to its being a clone whose original is already moved away
+            // So we copy it artificially calculating the transform from its repr->attr("transform") and the parent transform
+            gchar const *t_str = current->attribute("transform");
+            Geom::Affine item_t(Geom::identity());
+            if (t_str)
+                sp_svg_transform_read(t_str, &item_t);
+            item_t *= SP_ITEM(doc->getObjectByRepr(current->parent()))->i2doc_affine();
+            // FIXME: when moving both clone and original from a transformed group (either by
+            // grouping into another parent, or by cut/paste) the transform from the original's
+            // parent becomes embedded into original itself, and this affects its clones. Fix
+            // this by remembering the transform diffs we write to each item into an array and
+            // then, if this is clone, looking up its original in that array and pre-multiplying
+            // it by the inverse of that original's transform diff.
+
+            sp_selection_copy_one(current, item_t, &temp_clip, xml_doc);
+            sp_repr_unparent(current);
+
+            // paste into topmost_parent (temporarily)
+            GSList *copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), &temp_clip);
+            if (temp_clip) g_slist_free(temp_clip);
+            if (copied) { // if success,
+                // take pasted object (now in topmost_parent)
+                Inkscape::XML::Node *in_topmost = static_cast<Inkscape::XML::Node *>(copied->data);
+                // make a copy
+                Inkscape::XML::Node *spnew = in_topmost->duplicate(xml_doc);
+                // remove pasted
+                sp_repr_unparent(in_topmost);
+                // put its copy into group
+                inner->appendChild(spnew);
+                Inkscape::GC::release(spnew);
+                g_slist_free(copied);
+            }
+        }
+        p = g_slist_remove(p, current);
+    }
+    
+    Inkscape::XML::Node *outer = xml_doc->createElement("svg:g");
+    outer->appendChild(inner);
+    topmost_parent->appendChild(outer);
+    outer->setPosition(topmost + 1);
+    
+    Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
+    clone->setAttribute("x", "0", false);
+    clone->setAttribute("y", "0", false);
+    clone->setAttribute("xlink:href", g_strdup_printf("#%s", inner->attribute("id")), false);
+
+    clone->setAttribute("inkscape:transform-center-x", inner->attribute("inkscape:transform-center-x"), false);
+    clone->setAttribute("inkscape:transform-center-y", inner->attribute("inkscape:transform-center-y"), false);
+
+    const Geom::Affine maskTransform(Geom::Affine::identity());
+    GSList *templist = NULL;
+
+    templist = g_slist_append(templist, clone);
+    // add the new clone to the top of the original's parent
+    gchar const *mask_id = SPClipPath::create(templist, doc, &maskTransform);
+    
+    g_slist_free(templist);
+    
+    outer->setAttribute("clip-path", g_strdup_printf("url(#%s)", mask_id));
+
+    Inkscape::GC::release(clone);
+    
+    selection->set(outer);
+    DocumentUndo::done(doc, SP_VERB_OBJECT_SET_CLIPPATH, _("Create Clip Group"));
+}
+
 /**
  * Creates a mask or clipPath from selection.