Experimental merge of Ponyscape features into trunk (will not compile)

(bzr r13090.1.1)

7 files changed, 937 insertions, 7 deletions

diff --git a/src/live_effects/parameter/Makefile_insert b/src/live_effects/parameter/Makefile_insert
index efdda686a..37cc3dc62 100644
--- a/src/live_effects/parameter/Makefile_insert
+++ b/src/live_effects/parameter/Makefile_insert
@@ -18,10 +18,14 @@ ink_common_sources += \
 	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/text.cpp	\
 	live_effects/parameter/text.h	\
+	live_effects/parameter/transformedpoint.cpp	\
+	live_effects/parameter/transformedpoint.h	\
 	live_effects/parameter/unit.cpp	\
 	live_effects/parameter/unit.h	\
 	live_effects/parameter/vector.cpp	\
diff --git a/src/live_effects/parameter/originalpatharray.cpp b/src/live_effects/parameter/originalpatharray.cpp
new file mode 100644
index 000000000..29e4c409c
--- /dev/null
+++ b/src/live_effects/parameter/originalpatharray.cpp
@@ -0,0 +1,486 @@
+/*
+ * Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/parameter/originalpatharray.h"
+
+#include <gtkmm/widget.h>
+#include <gtkmm/icontheme.h>
+#include <gtkmm/imagemenuitem.h>
+#include <gtkmm/separatormenuitem.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 <glibmm/i18n.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);
+    
+    _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 :
diff --git a/src/live_effects/parameter/originalpatharray.h b/src/live_effects/parameter/originalpatharray.h
new file mode 100644
index 000000000..865a3f8e5
--- /dev/null
+++ b/src/live_effects/parameter/originalpatharray.h
@@ -0,0 +1,123 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_ORIGINALPATHARRAY_H
+#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_ORIGINALPATHARRAY_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ *
+* Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ *
+ * 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 :
diff --git a/src/live_effects/parameter/powerstrokepointarray.cpp b/src/live_effects/parameter/powerstrokepointarray.cpp
index fecdfeda8..ac0000b1a 100644
--- a/src/live_effects/parameter/powerstrokepointarray.cpp
+++ b/src/live_effects/parameter/powerstrokepointarray.cpp
@@ -6,6 +6,7 @@
 
 #include <glibmm/i18n.h>
 
+#include "ui/dialog/lpe-powerstroke-properties.h"
 #include "live_effects/parameter/powerstrokepointarray.h"
 
 #include "live_effects/effect.h"
@@ -102,6 +103,23 @@ PowerStrokePointArrayParam::recalculate_controlpoints_for_new_pwd2(Geom::Piecewi
     }
 }
 
+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 @@ PowerStrokePointArrayParam::set_oncanvas_looks(SPKnotShapeType shape, SPKnotMode
     knot_mode  = mode;
     knot_color = color;
 }
-
+/*
 class PowerStrokePointArrayParamKnotHolderEntity : public KnotHolderEntity {
 public:
     PowerStrokePointArrayParamKnotHolderEntity(PowerStrokePointArrayParam *p, unsigned int index);
@@ -127,7 +145,7 @@ public:
     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 @@ public:
 private:
     PowerStrokePointArrayParam *_pparam;
     unsigned int _index;
-};
+};*/
 
 PowerStrokePointArrayParamKnotHolderEntity::PowerStrokePointArrayParamKnotHolderEntity(PowerStrokePointArrayParam *p, unsigned int index) 
   : _pparam(p), 
@@ -181,6 +199,12 @@ PowerStrokePointArrayParamKnotHolderEntity::knot_get() const
     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);
+}
+
 void
 PowerStrokePointArrayParamKnotHolderEntity::knot_click(guint state)
 {
@@ -223,10 +247,15 @@ PowerStrokePointArrayParamKnotHolderEntity::knot_click(guint state)
             // 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);
     } 
 }
 
@@ -235,7 +264,7 @@ void PowerStrokePointArrayParam::addKnotHolderEntities(KnotHolder *knotholder, S
     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);
     }
diff --git a/src/live_effects/parameter/powerstrokepointarray.h b/src/live_effects/parameter/powerstrokepointarray.h
index e1fa440f2..911bbc82d 100644
--- a/src/live_effects/parameter/powerstrokepointarray.h
+++ b/src/live_effects/parameter/powerstrokepointarray.h
@@ -20,8 +20,6 @@ namespace Inkscape {
 
 namespace LivePathEffect {
 
-class PowerStrokePointArrayParamKnotHolderEntity;
-
 class PowerStrokePointArrayParam : public ArrayParam<Geom::Point> {
 public:
     PowerStrokePointArrayParam( const Glib::ustring& label,
@@ -37,6 +35,8 @@ public:
 
     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 @@ private:
     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
 
diff --git a/src/live_effects/parameter/transformedpoint.cpp b/src/live_effects/parameter/transformedpoint.cpp
new file mode 100644
index 000000000..f5b01e267
--- /dev/null
+++ b/src/live_effects/parameter/transformedpoint.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) Theodore Janeczko 2012 <flutterguy317@gmail.com>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glibmm/i18n.h>
+
+#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"
+
+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 :
diff --git a/src/live_effects/parameter/transformedpoint.h b/src/live_effects/parameter/transformedpoint.h
new file mode 100644
index 000000000..37af8b98f
--- /dev/null
+++ b/src/live_effects/parameter/transformedpoint.h
@@ -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 <flutterguy317@gmail.com>
+ *
+ * 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