Full refactor of the LPE now too much simple code

(bzr r14272.1.6)

4 files changed, 158 insertions, 117 deletions

diff --git a/src/live_effects/lpe-bendpath.cpp b/src/live_effects/lpe-bendpath.cpp
index 9b015245d..d80f8e33a 100644
--- a/src/live_effects/lpe-bendpath.cpp
+++ b/src/live_effects/lpe-bendpath.cpp
@@ -20,7 +20,13 @@
 #include <2geom/d2.h>
 #include <2geom/piecewise.h>
 
+#include "knot-holder-entity.h"
+#include "knotholder.h"
+
+#include <glibmm/i18n.h>
+
 #include <algorithm>
+
 using std::vector;
 
 
@@ -48,29 +54,33 @@ first) but I think we can first forget about them.
 namespace Inkscape {
 namespace LivePathEffect {
 
+Geom::PathVector bp_helper_path;
+namespace BeP {
+class KnotHolderEntityWidthBendPath : public LPEKnotHolderEntity {
+    public:
+        KnotHolderEntityWidthBendPath(LPEBendPath * effect) : LPEKnotHolderEntity(effect) {}
+        virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+        virtual Geom::Point knot_get() const;
+    };
+} // BeP
 
 LPEBendPath::LPEBendPath(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     bend_path(_("Bend path:"), _("Path along which to bend the original path"), "bendpath", &wr, this, "M0,0 L1,0"),
+    original_height(0.0),
     prop_scale(_("_Width:"), _("Width of the path"), "prop_scale", &wr, this, 1.0),
-    width(_("Width distance"), _("Change the width of bend path - <b>Ctrl+Alt+Click</b>: reset"), "width", &wr, this),
     scale_y_rel(_("W_idth in units of length"), _("Scale the width of the path in units of its length"), "scale_y_rel", &wr, this, false),
-    vertical_pattern(_("_Original path is vertical"), _("Rotates the original 90 degrees, before bending it along the bend path"), "vertical", &wr, this, false),
-    height(0.0),
-    original_height(0.0),
-    prop_scale_from_widget(1.0),
-    firstTime(false),
-    secondTime(false)
+    vertical_pattern(_("_Original path is vertical"), _("Rotates the original 90 degrees, before bending it along the bend path"), "vertical", &wr, this, false)
 {
     registerParameter( dynamic_cast<Parameter *>(&bend_path) );
     registerParameter( dynamic_cast<Parameter *>(&prop_scale) );
     registerParameter( dynamic_cast<Parameter *>(&scale_y_rel) );
     registerParameter( dynamic_cast<Parameter *>(&vertical_pattern) );
-    registerParameter( dynamic_cast<Parameter *>(&width) );
 
     prop_scale.param_set_digits(3);
     prop_scale.param_set_increments(0.01, 0.10);
 
+    _provides_knotholder_entities = true;
     concatenate_before_pwd2 = true;
 }
 
@@ -82,56 +92,11 @@ LPEBendPath::~LPEBendPath()
 void
 LPEBendPath::doBeforeEffect (SPLPEItem const* lpeitem)
 {
-    hp.clear();
     // get the item bounding box
     original_bbox(lpeitem);
     original_height = boundingbox_Y.max() - boundingbox_Y.min();
-    Geom::Path path_in = bend_path.get_pathvector().pathAt(Geom::PathVectorTime(0, 0, 0.0));
-    Geom::Point ptA = path_in.pointAt(Geom::PathTime(0, 0.0));
-    Geom::Point B = path_in.pointAt(Geom::PathTime(1, 0.0));
-    Geom::Curve const *first_curve = &path_in.curveAt(Geom::PathTime(0, 0.0));
-    Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*first_curve);
-    Geom::Ray ray(ptA, B);
-    if (cubic) {
-        ray.setPoints(ptA,(*cubic)[1]);
-    }
-    
-    Geom::Angle first_curve_angle = ray.transformed(Geom::Rotate(Geom::deg_to_rad(90))).angle();
-    //This Hack is to fix a boring bug in the first call to the function, we have
-    //a wrong "ptA"
-    if(!firstTime && Geom::are_near(width, Geom::Point())){
-        firstTime = true;
-    } else if(firstTime && Geom::are_near(width, Geom::Point())){
-        Geom::Point default_point = Geom::Point::polar(first_curve_angle, original_height/2.0) + ptA;
-        prop_scale.param_set_value(1.0);
-        height = original_height;
-        width.param_setValue(default_point);
-        width.param_update_default(default_point);
-    } else {
-        double distance_knot =  Geom::distance(width , ptA);
-        width.param_setValue(Geom::Point::polar(first_curve_angle, distance_knot) + ptA);
-        height = distance_knot * 2;
-        if(secondTime){
-            prop_scale.param_set_value(1);
-            height = original_height;
-            width.param_setValue(Geom::Point::polar(first_curve_angle, height/2.0) + ptA);
-            secondTime = false;
-        } else if(prop_scale_from_widget == prop_scale){
-            prop_scale.param_set_value(height/original_height);
-        } else {
-            height = original_height * prop_scale;
-            width.param_setValue(Geom::Point::polar(first_curve_angle, height/2.0) + ptA);
-        }
-        if(firstTime){
-            firstTime = false;
-            secondTime = true;
-        }
-    }
-    prop_scale_from_widget = prop_scale;
-    Geom::Path hp_path(width);
-    hp_path.appendNew<Geom::LineSegment>(ptA);
-    hp.push_back(hp_path);
     SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+    
     item->apply_to_clippath(item);
     item->apply_to_mask(item);
 }
@@ -206,9 +171,54 @@ LPEBendPath::resetDefaults(SPItem const* item)
 void
 LPEBendPath::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
 {
-    hp_vec.push_back(hp);
+    hp_vec.push_back(bp_helper_path);
 }
 
+void 
+LPEBendPath::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+{
+    KnotHolderEntity *e = new BeP::KnotHolderEntityWidthBendPath(this);
+    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Change the width"), SP_KNOT_SHAPE_CIRCLE);
+    knotholder->add(e);
+}
+
+namespace BeP {
+
+void 
+KnotHolderEntityWidthBendPath::knot_set(Geom::Point const &p, Geom::Point const& /*origin*/, guint state)
+{
+    LPEBendPath *lpe = dynamic_cast<LPEBendPath *> (_effect);
+
+    Geom::Point const s = snap_knot_position(p, state);
+    Geom::Path path_in = lpe->bend_path.get_pathvector().pathAt(Geom::PathVectorTime(0, 0, 0.0));
+    Geom::Point ptA = path_in.pointAt(Geom::PathTime(0, 0.0));
+    lpe->prop_scale.param_set_value(Geom::distance(s , ptA)/(lpe->original_height/2.0));
+    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
+}
+
+Geom::Point 
+KnotHolderEntityWidthBendPath::knot_get() const
+{
+    LPEBendPath *lpe = dynamic_cast<LPEBendPath *> (_effect);
+
+    bp_helper_path.clear();
+    Geom::Path path_in = lpe->bend_path.get_pathvector().pathAt(Geom::PathVectorTime(0, 0, 0.0));
+    Geom::Point ptA = path_in.pointAt(Geom::PathTime(0, 0.0));
+    Geom::Point B = path_in.pointAt(Geom::PathTime(1, 0.0));
+    Geom::Curve const *first_curve = &path_in.curveAt(Geom::PathTime(0, 0.0));
+    Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*first_curve);
+    Geom::Ray ray(ptA, B);
+    if (cubic) {
+        ray.setPoints(ptA,(*cubic)[1]);
+    }
+    Geom::Angle first_curve_angle = ray.transformed(Geom::Rotate(Geom::deg_to_rad(90))).angle();
+    Geom::Point result_point = Geom::Point::polar(first_curve_angle, (lpe->original_height * lpe->prop_scale)/2.0) + ptA;
+    Geom::Path hp_path(result_point);
+    hp_path.appendNew<Geom::LineSegment>(ptA);
+    bp_helper_path.push_back(hp_path);
+    return result_point;
+}
+} // namespace BeP
 } // namespace LivePathEffect
 } /* namespace Inkscape */
 
diff --git a/src/live_effects/lpe-bendpath.h b/src/live_effects/lpe-bendpath.h
index 5d58f3320..eeda86a5e 100644
--- a/src/live_effects/lpe-bendpath.h
+++ b/src/live_effects/lpe-bendpath.h
@@ -14,7 +14,6 @@
 #include "live_effects/effect.h"
 #include "live_effects/parameter/path.h"
 #include "live_effects/parameter/bool.h"
-#include "live_effects/parameter/point.h"
 
 #include <2geom/sbasis.h>
 #include <2geom/sbasis-geometric.h>
@@ -28,6 +27,9 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
+namespace BeP {
+class KnotHolderEntityWidthBendPath;
+}
 
 //for Bend path on group : we need information concerning the group Bounding box
 class LPEBendPath : public Effect, GroupBBoxEffect {
@@ -43,21 +45,19 @@ public:
 
     void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
 
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
+
     PathParam bend_path;
 
-private:
+    friend class BeP::KnotHolderEntityWidthBendPath;
+protected:
+    double original_height;
     ScalarParam prop_scale;
-    PointParam width;
+private:
     BoolParam scale_y_rel;
     BoolParam vertical_pattern;
-    double height;
-    double original_height;
-    double prop_scale_from_widget;
-    bool firstTime;
-    bool secondTime;
     Geom::Piecewise<Geom::D2<Geom::SBasis> > uskeleton;
     Geom::Piecewise<Geom::D2<Geom::SBasis> > n;
-    Geom::PathVector hp;
 
     void on_pattern_pasted();
 
diff --git a/src/live_effects/lpe-patternalongpath.cpp b/src/live_effects/lpe-patternalongpath.cpp
index 53730d4d4..72e1892ef 100644
--- a/src/live_effects/lpe-patternalongpath.cpp
+++ b/src/live_effects/lpe-patternalongpath.cpp
@@ -18,6 +18,9 @@
 #include <2geom/d2.h>
 #include <2geom/piecewise.h>
 
+#include "knot-holder-entity.h"
+#include "knotholder.h"
+
 #include <algorithm>
 using std::vector;
 
@@ -45,6 +48,16 @@ first) but I think we can first forget about them.
 
 namespace Inkscape {
 namespace LivePathEffect {
+Geom::PathVector pap_helper_path;
+
+namespace WPAP {
+    class KnotHolderEntityWidthPatternAlongPath : public LPEKnotHolderEntity {
+    public:
+        KnotHolderEntityWidthPatternAlongPath(LPEPatternAlongPath * effect) : LPEKnotHolderEntity(effect) {}
+        virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+        virtual Geom::Point knot_get() const;
+    };
+} // WPAP
 
 static const Util::EnumData<PAPCopyType> PAPCopyTypeData[PAPCT_END] = {
     {PAPCT_SINGLE,               N_("Single"),               "single"},
@@ -57,10 +70,10 @@ static const Util::EnumDataConverter<PAPCopyType> PAPCopyTypeConverter(PAPCopyTy
 LPEPatternAlongPath::LPEPatternAlongPath(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     pattern(_("Pattern source:"), _("Path to put along the skeleton path"), "pattern", &wr, this, "M0,0 L1,0"),
+    original_height(0),
+    prop_scale(_("_Width:"), _("Width of the pattern"), "prop_scale", &wr, this, 1.0),
     copytype(_("Pattern copies:"), _("How many pattern copies to place along the skeleton path"),
         "copytype", PAPCopyTypeConverter, &wr, this, PAPCT_SINGLE_STRETCHED),
-    prop_scale(_("_Width:"), _("Width of the pattern"), "prop_scale", &wr, this, 1.0),
-    width(_("Width distance"), _("Change the width of pattern path - <b>Ctrl+Alt+Click</b>: reset"), "width", &wr, this),
     scale_y_rel(_("Wid_th in units of length"),
         _("Scale the width of the pattern in units of its length"),
         "scale_y_rel", &wr, this, false),
@@ -76,10 +89,7 @@ LPEPatternAlongPath::LPEPatternAlongPath(LivePathEffectObject *lpeobject) :
     vertical_pattern(_("Pattern is _vertical"), _("Rotate pattern 90 deg before applying"),
         "vertical_pattern", &wr, this, false),
     fuse_tolerance(_("_Fuse nearby ends:"), _("Fuse ends closer than this number. 0 means don't fuse."),
-        "fuse_tolerance", &wr, this, 0),
-    height(0),
-    original_height(0),
-    prop_scale_from_widget(1)
+        "fuse_tolerance", &wr, this, 0)
 {
     registerParameter( dynamic_cast<Parameter *>(&pattern) );
     registerParameter( dynamic_cast<Parameter *>(&copytype) );
@@ -91,9 +101,11 @@ LPEPatternAlongPath::LPEPatternAlongPath(LivePathEffectObject *lpeobject) :
     registerParameter( dynamic_cast<Parameter *>(&prop_units) );
     registerParameter( dynamic_cast<Parameter *>(&vertical_pattern) );
     registerParameter( dynamic_cast<Parameter *>(&fuse_tolerance) );
-    registerParameter( dynamic_cast<Parameter *>(&width) );
     prop_scale.param_set_digits(3);
     prop_scale.param_set_increments(0.01, 0.10);
+
+    _provides_knotholder_entities = true;
+
 }
 
 LPEPatternAlongPath::~LPEPatternAlongPath()
@@ -104,49 +116,10 @@ LPEPatternAlongPath::~LPEPatternAlongPath()
 void
 LPEPatternAlongPath::doBeforeEffect (SPLPEItem const* lpeitem)
 {
-    hp.clear();
     // get the pattern bounding box
     Geom::OptRect bbox = pattern.get_pathvector().boundsFast();
     if (bbox) {
         original_height = (*bbox)[Geom::Y].max() - (*bbox)[Geom::Y].min();
-        SPShape const *sp_shape = dynamic_cast<SPShape const *>(lpeitem);
-        if (sp_shape) {
-            Geom::Path const *path_in = sp_shape->getCurveBeforeLPE()->first_path();
-            Geom::Point ptA = path_in->pointAt(Geom::PathTime(0, 0.0));
-            Geom::Point B = path_in->pointAt(Geom::PathTime(1, 0.0));
-            Geom::Curve const *first_curve = &path_in->curveAt(Geom::PathTime(0, 0.0));
-            Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*first_curve);
-            Geom::Ray ray(ptA, B);
-            if (cubic) {
-                ray.setPoints((*cubic)[1], ptA);
-            }
-            //This Hack is to fix a boring bug in the first call to the function, we have
-            //a wrong "ptA"
-            if(height == 0.0 && Geom::are_near(width, Geom::Point())){
-                height = 0.1;
-                std::cout << ptA << "ptA0.5\n";
-            } else if(height == 0.1 && Geom::are_near(width, Geom::Point())){
-                Geom::Point default_point = Geom::Point::polar(ray.angle() + Geom::deg_to_rad(90), (original_height/2.0)) + ptA;
-                prop_scale.param_set_value(1.0);
-                height = original_height;
-                width.param_setValue(default_point);
-                width.param_update_default(default_point);
-            } else {
-                double distance_knot =  Geom::distance(width , ptA);
-                width.param_setValue(Geom::Point::polar(ray.angle() + Geom::deg_to_rad(90), distance_knot) + ptA);
-                height = distance_knot * 2;
-                if(prop_scale_from_widget == prop_scale){
-                    prop_scale.param_set_value(height/original_height);
-                } else {
-                    height = original_height * prop_scale;
-                    width.param_setValue(Geom::Point::polar(ray.angle() + Geom::deg_to_rad(90), height/2.0) + ptA);
-                }
-            }
-            prop_scale_from_widget = prop_scale;
-            Geom::Path hp_path(width);
-            hp_path.appendNew<Geom::LineSegment>(ptA);
-            hp.push_back(hp_path);
-        }
     }
 }
 
@@ -294,9 +267,62 @@ LPEPatternAlongPath::transform_multiply(Geom::Affine const& postmul, bool set)
 void
 LPEPatternAlongPath::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
 {
-    hp_vec.push_back(hp);
+    hp_vec.push_back(pap_helper_path);
 }
 
+
+void 
+LPEPatternAlongPath::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+{
+    KnotHolderEntity *e = new WPAP::KnotHolderEntityWidthPatternAlongPath(this);
+    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Change the width"), SP_KNOT_SHAPE_CIRCLE);
+    knotholder->add(e);
+}
+
+namespace WPAP {
+
+void 
+KnotHolderEntityWidthPatternAlongPath::knot_set(Geom::Point const &p, Geom::Point const& /*origin*/, guint state)
+{
+    LPEPatternAlongPath *lpe = dynamic_cast<LPEPatternAlongPath *> (_effect);
+
+    Geom::Point const s = snap_knot_position(p, state);
+    SPShape const *sp_shape = dynamic_cast<SPShape const *>(SP_LPE_ITEM(item));
+    if (sp_shape) {
+        Geom::Path const *path_in = sp_shape->getCurveBeforeLPE()->first_path();
+        Geom::Point ptA = path_in->pointAt(Geom::PathTime(0, 0.0));
+        lpe->prop_scale.param_set_value(Geom::distance(s , ptA)/(lpe->original_height/2.0));
+    }
+    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
+}
+
+Geom::Point 
+KnotHolderEntityWidthPatternAlongPath::knot_get() const
+{
+    LPEPatternAlongPath *lpe = dynamic_cast<LPEPatternAlongPath *> (_effect);
+
+    SPShape const *sp_shape = dynamic_cast<SPShape const *>(SP_LPE_ITEM(item));
+    if (sp_shape) {
+        pap_helper_path.clear();
+        Geom::Path const *path_in = sp_shape->getCurveBeforeLPE()->first_path();
+        Geom::Point ptA = path_in->pointAt(Geom::PathTime(0, 0.0));
+        Geom::Point B = path_in->pointAt(Geom::PathTime(1, 0.0));
+        Geom::Curve const *first_curve = &path_in->curveAt(Geom::PathTime(0, 0.0));
+        Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*first_curve);
+        Geom::Ray ray(ptA, B);
+        if (cubic) {
+            ray.setPoints((*cubic)[1], ptA);
+        }
+        Geom::Angle first_curve_angle = ray.transformed(Geom::Rotate(Geom::deg_to_rad(90))).angle();
+        Geom::Point result_point = Geom::Point::polar(first_curve_angle, (lpe->original_height * lpe->prop_scale)/2.0) + ptA;
+        Geom::Path hp_path(result_point);
+        hp_path.appendNew<Geom::LineSegment>(ptA);
+        pap_helper_path.push_back(hp_path);
+        return result_point;
+    }
+    return Geom::Point();
+}
+} // namespace WPAP
 } // namespace LivePathEffect
 } /* namespace Inkscape */
 
diff --git a/src/live_effects/lpe-patternalongpath.h b/src/live_effects/lpe-patternalongpath.h
index df0ae9777..3b9a17ab0 100644
--- a/src/live_effects/lpe-patternalongpath.h
+++ b/src/live_effects/lpe-patternalongpath.h
@@ -18,6 +18,10 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
+namespace WPAP {
+class KnotHolderEntityWidthPatternAlongPath;
+}
+
 enum PAPCopyType {
     PAPCT_SINGLE = 0,
     PAPCT_SINGLE_STRETCHED,
@@ -39,12 +43,17 @@ public:
 
     void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
 
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
 
     PathParam  pattern;
+
+    friend class WPAP::KnotHolderEntityWidthPatternAlongPath;
+protected:
+    double original_height;
+    ScalarParam prop_scale;
+
 private:
     EnumParam<PAPCopyType> copytype;
-    ScalarParam  prop_scale;
-    PointParam width;
     BoolParam scale_y_rel;
     ScalarParam  spacing;
     ScalarParam  normal_offset;
@@ -52,10 +61,6 @@ private:
     BoolParam    prop_units;
     BoolParam    vertical_pattern;
     ScalarParam  fuse_tolerance;
-    double height;
-    double original_height;
-    double prop_scale_from_widget;
-    Geom::PathVector hp;
     void on_pattern_pasted();
 
     LPEPatternAlongPath(const LPEPatternAlongPath&);