update to trunk

(bzr r12588.1.40)

11 files changed, 182 insertions, 1165 deletions

diff --git a/src/live_effects/CMakeLists.txt b/src/live_effects/CMakeLists.txt
index c8a02c810..c4b92e579 100644
--- a/src/live_effects/CMakeLists.txt
+++ b/src/live_effects/CMakeLists.txt
@@ -1,4 +1,3 @@
-
 set(live_effects_SRC
 	effect.cpp
 	lpe-angle_bisector.cpp
@@ -6,6 +5,7 @@ set(live_effects_SRC
 	lpe-bendpath.cpp
 	lpe-boolops.cpp
 	lpe-bounding-box.cpp
+	lpe-bspline.cpp
 	lpe-circle_3pts.cpp
 	lpe-circle_with_radius.cpp
 	lpe-clone-original.cpp
@@ -13,7 +13,7 @@ set(live_effects_SRC
 	lpe-copy_rotate.cpp
 	lpe-curvestitch.cpp
 	lpe-dynastroke.cpp
-	lpe-ellipse-5pts.cpp
+	lpe-ellipse_5pts.cpp
 	lpe-envelope.cpp
 	lpe-extrude.cpp
 	lpe-fill-between-many.cpp
@@ -21,8 +21,11 @@ set(live_effects_SRC
 	lpe-fillet-chamfer.cpp
 	lpe-gears.cpp
 	lpe-interpolate.cpp
+	lpe-interpolate_points.cpp
+	lpe-jointype.cpp
 	lpe-knot.cpp
 	lpe-lattice.cpp
+	lpe-lattice2.cpp
 	lpe-line_segment.cpp
 	lpe-mirror_symmetry.cpp
 	lpe-offset.cpp
@@ -30,43 +33,43 @@ set(live_effects_SRC
 	lpe-path_length.cpp
 	lpe-patternalongpath.cpp
 	lpe-perp_bisector.cpp
-	lpe-perspective_path.cpp
 	lpe-perspective-envelope.cpp
+	lpe-perspective_path.cpp
 	lpe-powerstroke.cpp
 	lpe-recursiveskeleton.cpp
 	lpe-rough-hatches.cpp
+	lpe-roughen.cpp
 	lpe-ruler.cpp
 	lpe-show_handles.cpp
 	lpe-simplify.cpp
-	# lpe-skeleton.cpp
+	lpe-skeleton.cpp
 	lpe-sketch.cpp
 	lpe-spiro.cpp
-	lpe-roughen.cpp
 	lpe-tangent_to_curve.cpp
+	lpe-taperstroke.cpp
 	lpe-test-doEffect-stack.cpp
-	lpe-bspline.cpp
 	lpe-text_label.cpp
-	lpe-vonkoch.cpp
 	lpegroupbbox.cpp
 	lpeobject-reference.cpp
+	lpe-vonkoch.cpp
 	lpeobject.cpp
-	spiro.cpp
 	spiro-converters.cpp
+	spiro.cpp
 
 	parameter/array.cpp
 	parameter/bool.cpp
 	parameter/filletchamferpointarray.cpp
-	parameter/parameter.cpp
-	parameter/path.cpp
 	parameter/originalpath.cpp
 	parameter/originalpatharray.cpp
+	parameter/parameter.cpp
 	parameter/path-reference.cpp
+	parameter/path.cpp
 	parameter/point.cpp
 	parameter/powerstrokepointarray.cpp
 	parameter/random.cpp
 	parameter/text.cpp
-	paramter/transformedpoint.cpp
 	parameter/togglebutton.cpp
+	parameter/transformedpoint.cpp
 	parameter/unit.cpp
 	parameter/vector.cpp
 
@@ -80,6 +83,7 @@ set(live_effects_SRC
 	lpe-bendpath.h
 	lpe-boolops.h
 	lpe-bounding-box.h
+	lpe-bspline.h
 	lpe-circle_3pts.h
 	lpe-circle_with_radius.h
 	lpe-clone-original.h
@@ -87,7 +91,7 @@ set(live_effects_SRC
 	lpe-copy_rotate.h
 	lpe-curvestitch.h
 	lpe-dynastroke.h
-	lpe-ellipse-5pts.h
+	lpe-ellipse_5pts.h
 	lpe-envelope.h
 	lpe-extrude.h
 	lpe-fill-between-many.h
@@ -95,8 +99,11 @@ set(live_effects_SRC
 	lpe-fillet-chamfer.h
 	lpe-gears.h
 	lpe-interpolate.h
+	lpe-interpolate_points.h
+	lpe-jointype.h
 	lpe-knot.h
 	lpe-lattice.h
+	lpe-lattice2.h
 	lpe-line_segment.h
 	lpe-mirror_symmetry.h
 	lpe-offset.h
@@ -104,47 +111,47 @@ set(live_effects_SRC
 	lpe-path_length.h
 	lpe-patternalongpath.h
 	lpe-perp_bisector.h
-	lpe-perspective_path.h
 	lpe-perspective-envelope.h
-	lpe-powerstroke.h
+	lpe-perspective_path.h
 	lpe-powerstroke-interpolators.h
+	lpe-powerstroke.h
 	lpe-recursiveskeleton.h
 	lpe-rough-hatches.h
+	lpe-roughen.h
 	lpe-ruler.h
-	lpe-simplify.h
 	lpe-show_handles.h
+	lpe-simplify.h
 	lpe-skeleton.h
 	lpe-sketch.h
 	lpe-spiro.h
-	lpe-roughen.h
 	lpe-tangent_to_curve.h
+	lpe-taperstroke.h
 	lpe-test-doEffect-stack.h
-	lpe-bspline.h
 	lpe-text_label.h
 	lpe-vonkoch.h
 	lpegroupbbox.h
 	lpeobject-reference.h
 	lpeobject.h
-	spiro.h
 	spiro-converters.h
+	spiro.h
 
 	parameter/array.h
 	parameter/bool.h
-	parameter/filletchamferpointarray.h
 	parameter/enum.h
+	parameter/filletchamferpointarray.h
+	parameter/originalpath.h
+	parameter/originalpatharray.h
 	parameter/parameter.h
 	parameter/path-reference.h
 	parameter/path.h
-	parameter/originalpath.h
-	parameter/originalpatharray.h
 	parameter/point.h
 	parameter/powerstrokepointarray.h
 	parameter/random.h
 	parameter/text.h
 	parameter/togglebutton.h
+	parameter/transformedpoint.h
 	parameter/unit.h
 	parameter/vector.h
-
 )
 
 # add_inkscape_lib(live_effects_LIB "${live_effects_SRC}")
diff --git a/src/live_effects/Makefile_insert b/src/live_effects/Makefile_insert
index 8f0a3ac57..dace45739 100644
--- a/src/live_effects/Makefile_insert
+++ b/src/live_effects/Makefile_insert
@@ -109,8 +109,6 @@ ink_common_sources += \
 	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	\
diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp
index b924d8a23..5d5a6e616 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -1,48 +1,16 @@
 /*
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
 #include <gtkmm.h>
-
-#if WITH_GLIBMM_2_32
-# include <glibmm/threads.h>
-#endif
-
-#include <glib.h>
-#include <glibmm/i18n.h>
-
-
-#include "display/curve.h"
-#include <2geom/bezier-curve.h>
-#include <2geom/point.h>
-#include "helper/geom-curves.h"
 #include "live_effects/lpe-bspline.h"
-#include "live_effects/lpeobject.h"
-#include "live_effects/parameter/parameter.h"
 #include "ui/widget/scalar.h"
-#include "xml/repr.h"
-#include "svg/svg.h"
+#include "display/curve.h"
+#include "helper/geom-curves.h"
 #include "sp-path.h"
-#include "style.h"
-#include "document-private.h"
-#include "document.h"
-#include "document-undo.h"
-#include "verbs.h"
-#include "sp-lpe-item.h"
-#include "sp-namedview.h"
-#include "display/sp-canvas.h"
-#include <typeinfo>
-#include <vector>
-#include "util/units.h"
-// For handling un-continuous paths:
-#include "message-stack.h"
-#include "inkscape.h"
-
-using Inkscape::DocumentUndo;
+#include "svg/svg.h"
+#include "xml/repr.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -106,13 +74,15 @@ void LPEBSpline::doEffect(SPCurve *curve)
     }
     // Make copy of old path as it is changed during processing
     Geom::PathVector const original_pathv = curve->get_pathvector();
+
     curve->reset();
 
     for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
             path_it != original_pathv.end(); ++path_it) {
-        if (path_it->empty())
+        if (path_it->empty()){
             continue;
-
+        }
+        hp.push_back(*path_it);
         Geom::Path::const_iterator curve_it1 = path_it->begin();
         Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
         Geom::Path::const_iterator curve_endit = path_it->end_default();
diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h
index 642562b24..8017e39ef 100644
--- a/src/live_effects/lpe-bspline.h
+++ b/src/live_effects/lpe-bspline.h
@@ -6,9 +6,8 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
 #include "live_effects/effect.h"
-#include "live_effects/parameter/bool.h"
+
 #include <vector>
 
 namespace Inkscape {
diff --git a/src/live_effects/lpe-jointype.cpp b/src/live_effects/lpe-jointype.cpp
index bf2526986..0111a0f99 100644
--- a/src/live_effects/lpe-jointype.cpp
+++ b/src/live_effects/lpe-jointype.cpp
@@ -8,7 +8,7 @@
 */
 
 #include "live_effects/parameter/enum.h"
-#include "live_effects/pathoutlineprovider.h"
+#include "helper/geom-pathstroke.h"
 
 #include "sp-shape.h"
 #include "style.h"
@@ -28,19 +28,19 @@ 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"}
+    {JOIN_BEVEL,       N_("Beveled"),    "bevel"},
+    {JOIN_ROUND,       N_("Rounded"),    "round"},
+    {JOIN_MITER,       N_("Miter"),      "miter"},
+    {JOIN_MITER_CLIP,  N_("Miter Clip"), "miter-clip"},
+    {JOIN_EXTRAPOLATE, N_("Extrapolated arc"), "extrp_arc"},
 };
 
 static const Util::EnumData<unsigned> CapTypeData[] = {
-    {BUTT_STRAIGHT, N_("Butt"), "butt"},
+    {BUTT_FLAT, N_("Butt"), "butt"},
     {BUTT_ROUND, N_("Rounded"), "round"},
     {BUTT_SQUARE, N_("Square"), "square"},
-    {BUTT_POINTY, N_("Peak"), "peak"},
-    {BUTT_LEANED, N_("Leaned"), "leaned"}
+    {BUTT_PEAK, N_("Peak"), "peak"},
+    //{BUTT_LEANED, N_("Leaned"), "leaned"}
 };
 
 static const Util::EnumDataConverter<unsigned> CapTypeConverter(CapTypeData, sizeof(CapTypeData)/sizeof(*CapTypeData));
@@ -50,9 +50,9 @@ 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.),
+    linejoin_type(_("Join:"), _("Determines the shape of the path's corners"),  "linejoin_type", JoinTypeConverter, &wr, this, JOIN_EXTRAPOLATE),
+    //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)
 {
@@ -60,17 +60,16 @@ LPEJoinType::LPEJoinType(LivePathEffectObject *lpeobject) :
     registerParameter(&linecap_type);
     registerParameter(&line_width);
     registerParameter(&linejoin_type);
-    registerParameter(&start_lean);
-    registerParameter(&end_lean);
+    //registerParameter(&start_lean);
+    //registerParameter(&end_lean);
     registerParameter(&miter_limit);
     registerParameter(&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);
+    //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()
@@ -87,38 +86,30 @@ void LPEJoinType::doOnApply(SPLPEItem const* 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");
+        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_unset_property (css, "fill");
+            sp_repr_css_set_property (css, "fill", "none");
         }
 
+        sp_repr_css_set_property(css, "fill-rule", "nonzero");
         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).");
+
+        line_width.param_set_value(width);
     }
 }
 
@@ -126,30 +117,25 @@ void LPEJoinType::doOnApply(SPLPEItem const* lpeitem)
 
 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");
+        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->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value)));
+            sp_repr_css_set_property (css, "stroke", c);
         } else {
-            sp_repr_css_unset_property (css, "stroke");
+            sp_repr_css_set_property (css, "stroke", "none");
         }
 
         Inkscape::CSSOStringStream os;
@@ -164,15 +150,18 @@ void LPEJoinType::doOnRemove(SPLPEItem const* lpeitem)
     }
 }
 
-// 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);
+    Geom::PathVector ret;
+    for (size_t i = 0; i < path_in.size(); ++i) {
+        Geom::PathVector tmp = Inkscape::outline(path_in[i], line_width, 
+                                                 (attempt_force_join ? std::numeric_limits<double>::max() : miter_limit),
+                                                 static_cast<LineJoinType>(linejoin_type.get_value()),
+                                                 static_cast<LineCapType>(linecap_type.get_value()));
+        ret.insert(ret.begin(), tmp.begin(), tmp.end());
+    }
+
+    return ret;
 }
 
 } // namespace LivePathEffect
diff --git a/src/live_effects/lpe-jointype.h b/src/live_effects/lpe-jointype.h
index 73705666d..bca0961c9 100644
--- a/src/live_effects/lpe-jointype.h
+++ b/src/live_effects/lpe-jointype.h
@@ -33,11 +33,10 @@ private:
     ScalarParam line_width;

     EnumParam<unsigned> linecap_type;

     EnumParam<unsigned> linejoin_type;

-    ScalarParam start_lean;

-    ScalarParam end_lean;

+    //ScalarParam start_lean;

+    //ScalarParam end_lean;

     ScalarParam miter_limit;

     BoolParam attempt_force_join;

-    bool was_initialized;

 };

 

 } //namespace LivePathEffect

diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp
index d60a13c23..b5885bdb3 100644
--- a/src/live_effects/lpe-perspective-envelope.cpp
+++ b/src/live_effects/lpe-perspective-envelope.cpp
@@ -48,11 +48,11 @@ LPEPerspectiveEnvelope::LPEPerspectiveEnvelope(LivePathEffectObject *lpeobject)
     Down_Right_Point(_("Down Right"), _("Down Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Down_Right_Point", &wr, this)
 {
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter( dynamic_cast<Parameter *>(&deform_type));
-    registerParameter( dynamic_cast<Parameter *>(&Up_Left_Point) );
-    registerParameter( dynamic_cast<Parameter *>(&Up_Right_Point) );
-    registerParameter( dynamic_cast<Parameter *>(&Down_Left_Point) );
-    registerParameter( dynamic_cast<Parameter *>(&Down_Right_Point) );
+    registerParameter(&deform_type);
+    registerParameter(&Up_Left_Point);
+    registerParameter(&Up_Right_Point);
+    registerParameter(&Down_Left_Point);
+    registerParameter(&Down_Right_Point);
 }
 
 LPEPerspectiveEnvelope::~LPEPerspectiveEnvelope()
@@ -340,8 +340,8 @@ LPEPerspectiveEnvelope::resetDefaults(SPItem const* item)
 {
     Effect::resetDefaults(item);
     original_bbox(SP_LPE_ITEM(item));
-    resetGrid();
     setDefaults();
+    resetGrid();
 }
 
 void
diff --git a/src/live_effects/lpe-powerstroke.cpp b/src/live_effects/lpe-powerstroke.cpp
index f7fe9592d..5d9d224e8 100644
--- a/src/live_effects/lpe-powerstroke.cpp
+++ b/src/live_effects/lpe-powerstroke.cpp
@@ -297,7 +297,8 @@ LPEPowerStroke::doOnApply(SPLPEItem const* lpeitem)
         } else {
             sp_repr_css_unset_property (css, "fill");
         }
-        
+
+        sp_repr_css_set_property(css, "fill-rule", "nonzero");        
         sp_repr_css_set_property(css, "stroke", "none");
         
         sp_desktop_apply_css_recursive(item, css, true);
@@ -330,25 +331,21 @@ 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");
+        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()) {
+            char c[64] = {0};
+            sp_svg_write_color (c, sizeof(c), lpeitem->style->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value)));
+            sp_repr_css_set_property (css, "stroke", c);
         } else {
-            sp_repr_css_unset_property (css, "stroke");
+            sp_repr_css_set_property (css, "stroke", "none");
         }
 
         Inkscape::CSSOStringStream os;
diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp
index 7a024147c..2c74af6d6 100644
--- a/src/live_effects/lpe-taperstroke.cpp
+++ b/src/live_effects/lpe-taperstroke.cpp
@@ -19,7 +19,8 @@
 #include <2geom/circle.h>
 #include <2geom/sbasis-to-bezier.h>
 
-#include "pathoutlineprovider.h"
+#include "helper/geom-nodetype.h"
+#include "helper/geom-pathstroke.h"
 #include "display/curve.h"
 #include "sp-shape.h"
 #include "style.h"
@@ -60,11 +61,10 @@ namespace TpS {
 } // 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"}
+    {JOIN_BEVEL,          N_("Beveled"),         "bevel"},
+    {JOIN_ROUND,          N_("Rounded"),         "round"},
+    {JOIN_MITER,          N_("Miter"),           "miter"},
+    {JOIN_EXTRAPOLATE,    N_("Extrapolated"),    "extrapolated"},
 };
 
 static const Util::EnumDataConverter<unsigned> JoinTypeConverter(JoinType, sizeof (JoinType)/sizeof(*JoinType));
@@ -75,7 +75,7 @@ LPETaperStroke::LPETaperStroke(LivePathEffectObject *lpeobject) :
     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),
+    join_type(_("Join type:"), _("Join type for non-smooth nodes"), "jointype", JoinTypeConverter, &wr, this, JOIN_EXTRAPOLATE),
     miter_limit(_("Miter limit:"), _("Limit for miter joins"), "miter_limit", &wr, this, 100.)
 {
     show_orig_path = true;
@@ -102,27 +102,24 @@ void LPETaperStroke::doOnApply(SPLPEItem const* 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");
+        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_unset_property (css, "fill");
+            sp_repr_css_set_property (css, "fill", "none");
         }
 
+        sp_repr_css_set_property(css, "fill-rule", "nonzero");
         sp_repr_css_set_property(css, "stroke", "none");
 
         sp_desktop_apply_css_recursive(item, css, true);
@@ -130,7 +127,7 @@ void LPETaperStroke::doOnApply(SPLPEItem const* lpeitem)
 
         line_width.param_set_value(width);
     } else {
-        printf("WARNING: It only makes sense to apply Join Type to paths (not groups).\n");
+        printf("WARNING: It only makes sense to apply Taper stroke to paths (not groups).\n");
     }
 }
 
@@ -142,25 +139,21 @@ void LPETaperStroke::doOnRemove(SPLPEItem const* 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");
+        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->fill.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->fill_opacity.value)));
+            sp_repr_css_set_property (css, "stroke", c);
         } else {
-            sp_repr_css_unset_property (css, "stroke");
+            sp_repr_css_set_property (css, "stroke", "none");
         }
 
         Inkscape::CSSOStringStream os;
@@ -179,15 +172,22 @@ using Geom::D2;
 using Geom::SBasis;
 // leave Geom::Path
 
-Geom::Path return_at_first_cusp(Geom::Path const & path_in, double /*smooth_tolerance*/ = 0.05) {
-    return Geom::split_at_cusps(path_in)[0];
+static Geom::Path return_at_first_cusp(Geom::Path const & path_in, double /*smooth_tolerance*/ = 0.05)
+{
+    Geom::Path temp;
+
+    for (unsigned i = 0; i < path_in.size(); i++) {
+        temp.append(path_in[i]);
+        if (Geom::get_nodetype(path_in[i], path_in[i + 1]) != Geom::NODE_SMOOTH ) {
+            break;
+        }
+    }
+    
+    return temp;
 }
 
 Piecewise<D2<SBasis> > stretch_along(Piecewise<D2<SBasis> > pwd2_in, Geom::Path pattern, double width);
 
-// references to pointers
-void subdivideCurve(Geom::Curve * curve_in, Geom::Coord t, Geom::Curve *& val_first, Geom::Curve *& val_second);
-
 // actual effect
 
 Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in)
@@ -285,7 +285,7 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in)
     // although this seems obvious, it can probably lead to bugs.
     if (!metInMiddle) {
         // append the outside outline of the path (goes with the direction of the path)
-        throwaway_path = Outline::PathOutsideOutline(pathv_out[1], -fabs(line_width), static_cast<LineJoinType>(join_type.get_value()), miter_limit);
+        throwaway_path = half_outline(pathv_out[1], fabs(line_width)/2., miter_limit, static_cast<LineJoinType>(join_type.get_value()));
         if (!zeroStart && real_path.size() >= 1 && throwaway_path.size() >= 1) {
             if (!Geom::are_near(real_path.finalPoint(), throwaway_path.initialPoint())) {
                 real_path.appendNew<Geom::LineSegment>(throwaway_path.initialPoint());
@@ -317,7 +317,7 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in)
     
     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);
+        throwaway_path = half_outline(pathv_out[1].reverse(), fabs(line_width)/2., miter_limit, static_cast<LineJoinType>(join_type.get_value()));
         
         if (!Geom::are_near(real_path.finalPoint(), throwaway_path.initialPoint()) && real_path.size() >= 1) {
             real_path.appendNew<Geom::LineSegment>(throwaway_path.initialPoint());
@@ -347,85 +347,18 @@ Geom::PathVector LPETaperStroke::doEffect_path(Geom::PathVector const& path_in)
  */
 Geom::PathVector LPETaperStroke::doEffect_simplePath(Geom::PathVector const & path_in)
 {
-    size_t size = path_in[0].size();
-
-    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 (size_t 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 )) {
-
-        // If you look into it, I don't actually think there is a working way to do this
-        // with only point math. So we use nearest_point instead.
-        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 (size_t j = (size - attach_end) + 1; j < size; ++j) {
-            trimmed_end.append(path_in[0] [j]);
-        }
+    Geom::Coord endTime = path_in[0].size() - attach_end;
 
-        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 (size_t 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 (size_t 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;
+    Geom::Path p1 = path_in[0].portion(0., attach_start);
+    Geom::Path p2 = path_in[0].portion(attach_start, endTime);
+    Geom::Path p3 = path_in[0].portion(endTime, path_in[0].size());
+    
+    Geom::PathVector out;
+    out.push_back(p1);
+    out.push_back(p2);
+    out.push_back(p3);
+    
+    return out;
 }
 
 
@@ -513,23 +446,6 @@ Piecewise<D2<SBasis> > stretch_along(Piecewise<D2<SBasis> > pwd2_in, Geom::Path
     }
 }
 
-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);
diff --git a/src/live_effects/pathoutlineprovider.cpp b/src/live_effects/pathoutlineprovider.cpp
deleted file mode 100644
index 21a0fb809..000000000
--- a/src/live_effects/pathoutlineprovider.cpp
+++ /dev/null
@@ -1,803 +0,0 @@
-/* Author:

- *   Liam P. White <inkscapebrony@gmail.com>

- *

- * Copyright (C) 2014 Author

- *

- * Released under GNU GPL, read the file 'COPYING' for more information

- */

-

-#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 <cstdio>

-

-#include "pathoutlineprovider.h"

-#include "livarot/path-description.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()) {

-        printf("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) {

-                printf("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;

-}

-

-#define miter_lim fabs(line_width * miter_limit)

-

-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));

-    }

-

-    // 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);

-    }

-

-    return path_out;

-}

-

-Geom::Path PathOutsideOutline(Geom::Path const & path_in, double line_width, LineJoinType linejoin_type, double 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;

-    }

-    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 :

diff --git a/src/live_effects/pathoutlineprovider.h b/src/live_effects/pathoutlineprovider.h
deleted file mode 100644
index c17584be2..000000000
--- a/src/live_effects/pathoutlineprovider.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef SEEN_PATH_OUTLINE_H
-#define SEEN_PATH_OUTLINE_H
-
-/* Author:
- *   Liam P. White <inkscapebrony@gmail.com>
- *
- * 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 :