X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fnodepath.cpp;h=e03484d7a383033b8af80f7499e5b8040ad11f62;hb=72aa7310f3a87958233d5cb4bf1386ff999be0ac;hp=59a6bcce36f75dd354945c502eea594287d8a1eb;hpb=648df6b455791766d98e132d021c42687d578b2c;p=inkscape.git

diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 59a6bcce3..e03484d7a 100644
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
@@ -15,11 +15,13 @@
 #endif
 
 #include <gdk/gdkkeysyms.h>
+#include "display/canvas-bpath.h"
 #include "display/curve.h"
 #include "display/sp-ctrlline.h"
 #include "display/sodipodi-ctrl.h"
 #include <glibmm/i18n.h>
 #include "libnr/n-art-bpath.h"
+#include "libnr/nr-path.h"
 #include "helper/units.h"
 #include "knot.h"
 #include "inkscape.h"
@@ -31,6 +33,7 @@
 #include "message-stack.h"
 #include "message-context.h"
 #include "node-context.h"
+#include "shape-editor.h"
 #include "selection-chemistry.h"
 #include "selection.h"
 #include "xml/repr.h"
@@ -44,6 +47,11 @@
 #include "display/bezier-utils.h"
 #include <vector>
 #include <algorithm>
+#include <cstring>
+#include <string>
+#include "live_effects/lpeobject.h"
+#include "live_effects/parameter/parameter.h"
+#include "util/mathfns.h"
 
 class NR::Matrix;
 
@@ -98,6 +106,8 @@ static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean inc
 
 static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean selected);
 
+static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type);
+
 /* Adjust handle placement, if the node or the other handle is moved */
 static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust);
 static void sp_node_adjust_handles(Inkscape::NodePath::Node *node);
@@ -132,71 +142,108 @@ static Inkscape::NodePath::NodeSide *sp_node_get_side(Inkscape::NodePath::Node *
 static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me);
 static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me);
 
+static SPCurve* sp_nodepath_object_get_curve(SPObject *object, const gchar *key);
+static void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve);
+
 // active_node indicates mouseover node
-static Inkscape::NodePath::Node *active_node = NULL;
+Inkscape::NodePath::Node * Inkscape::NodePath::Path::active_node = NULL;
 
 /**
  * \brief Creates new nodepath from item
  */
-Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item, bool show_handles)
+Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, bool show_handles, const char * repr_key_in, SPItem *item)
 {
-    Inkscape::XML::Node *repr = SP_OBJECT(item)->repr;
+    Inkscape::XML::Node *repr = object->repr;
 
     /** \todo
      * FIXME: remove this. We don't want to edit paths inside flowtext.
      * Instead we will build our flowtext with cloned paths, so that the
      * real paths are outside the flowtext and thus editable as usual.
      */
-    if (SP_IS_FLOWTEXT(item)) {
-        for (SPObject *child = sp_object_first_child(SP_OBJECT(item)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
+    if (SP_IS_FLOWTEXT(object)) {
+        for (SPObject *child = sp_object_first_child(object) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
             if SP_IS_FLOWREGION(child) {
                 SPObject *grandchild = sp_object_first_child(SP_OBJECT(child));
                 if (grandchild && SP_IS_PATH(grandchild)) {
-                    item = SP_ITEM(grandchild);
+                    object = SP_ITEM(grandchild);
                     break;
                 }
             }
         }
     }
 
-    if (!SP_IS_PATH(item))
-        return NULL;
-    SPPath *path = SP_PATH(item);
-    SPCurve *curve = sp_shape_get_curve(SP_SHAPE(path));
+    SPCurve *curve = sp_nodepath_object_get_curve(object, repr_key_in);
+
     if (curve == NULL)
         return NULL;
 
     NArtBpath *bpath = sp_curve_first_bpath(curve);
     gint length = curve->end;
-    if (length == 0)
+    if (length == 0) {
+        sp_curve_unref(curve);
         return NULL; // prevent crash for one-node paths
-
-    gchar const *nodetypes = repr->attribute("sodipodi:nodetypes");
-    gchar *typestr = parse_nodetypes(nodetypes, length);
+    }
 
     //Create new nodepath
     Inkscape::NodePath::Path *np = g_new(Inkscape::NodePath::Path, 1);
-    if (!np)
+    if (!np) {
+        sp_curve_unref(curve);
         return NULL;
+    }
 
     // Set defaults
     np->desktop     = desktop;
-    np->path        = path;
+    np->object      = object;
     np->subpaths    = NULL;
     np->selected    = NULL;
-    np->nodeContext = NULL; //Let the context that makes this set it
+    np->shape_editor = NULL; //Let the shapeeditor that makes this set it
     np->livarot_path = NULL;
     np->local_change = 0;
     np->show_handles = show_handles;
+    np->helper_path = NULL;
+    np->helperpath_rgba = 0xff0000ff;
+    np->helperpath_width = 1.0;
+    np->curve = sp_curve_copy(curve);
+    np->show_helperpath = false;
+    np->straight_path = false;
+    if (IS_LIVEPATHEFFECT(object) && item) {
+        np->item = item;
+    } else {
+        np->item = SP_ITEM(object);
+    }
 
     // we need to update item's transform from the repr here,
     // because they may be out of sync when we respond
     // to a change in repr by regenerating nodepath     --bb
-    sp_object_read_attr(SP_OBJECT(item), "transform");
+    sp_object_read_attr(SP_OBJECT(np->item), "transform");
 
-    np->i2d  = sp_item_i2d_affine(SP_ITEM(path));
+    np->i2d  = sp_item_i2d_affine(np->item);
     np->d2i  = np->i2d.inverse();
+
     np->repr = repr;
+    if (repr_key_in) { // apparantly the object is an LPEObject
+        np->repr_key = g_strdup(repr_key_in);
+        np->repr_nodetypes_key = g_strconcat(np->repr_key, "-nodetypes", NULL);
+        Inkscape::LivePathEffect::Parameter *lpeparam = LIVEPATHEFFECT(object)->lpe->getParameter(repr_key_in);
+        if (lpeparam) {
+            lpeparam->param_setup_nodepath(np);
+        }
+    } else {
+        np->repr_nodetypes_key = g_strdup("sodipodi:nodetypes");
+        if ( SP_SHAPE(np->object)->path_effect_href ) {
+            np->repr_key = g_strdup("inkscape:original-d");
+
+            LivePathEffectObject *lpeobj = sp_shape_get_livepatheffectobject(SP_SHAPE(np->object));
+            if (lpeobj && lpeobj->lpe) {
+                lpeobj->lpe->setup_nodepath(np);
+            }
+        } else {
+            np->repr_key = g_strdup("d");
+        }
+    }
+
+    gchar const *nodetypes = np->repr->attribute(np->repr_nodetypes_key);
+    gchar *typestr = parse_nodetypes(nodetypes, length);
 
     // create the subpath(s) from the bpath
     NArtBpath *b = bpath;
@@ -213,11 +260,22 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item, bool
     // create the livarot representation from the same item
     sp_nodepath_ensure_livarot_path(np);
 
+    // Draw helper curve
+    if (np->show_helperpath) {
+        SPCurve *helper_curve = sp_curve_copy(np->curve);
+        sp_curve_transform(helper_curve, np->i2d );
+        np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(desktop), helper_curve);
+        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+        sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(np->helper_path), 0, SP_WIND_RULE_NONZERO);
+        sp_canvas_item_show(np->helper_path);
+        sp_curve_unref(helper_curve);
+    }
+
     return np;
 }
 
 /**
- * Destroys nodepath's subpaths, then itself, also tell context about it.
+ * Destroys nodepath's subpaths, then itself, also tell parent ShapeEditor about it.
  */
 void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
 
@@ -228,9 +286,9 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
         sp_nodepath_subpath_destroy((Inkscape::NodePath::SubPath *) np->subpaths->data);
     }
 
-    //Inform the context that made me, if any, that I am gone.
-    if (np->nodeContext)
-        np->nodeContext->nodepath = NULL;
+    //Inform the ShapeEditor that made me, if any, that I am gone.
+    if (np->shape_editor)
+        np->shape_editor->nodepath_destroyed();
 
     g_assert(!np->selected);
 
@@ -239,6 +297,25 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
         np->livarot_path = NULL;
     }
 
+    if (np->helper_path) {
+        GtkObject *temp = np->helper_path;
+        np->helper_path = NULL;
+        gtk_object_destroy(temp);
+    }
+    if (np->curve) {
+        sp_curve_unref(np->curve);
+        np->curve = NULL;
+    }
+
+    if (np->repr_key) {
+        g_free(np->repr_key);
+        np->repr_key = NULL;
+    }
+    if (np->repr_nodetypes_key) {
+        g_free(np->repr_nodetypes_key);
+        np->repr_nodetypes_key = NULL;
+    }
+
     np->desktop = NULL;
 
     g_free(np);
@@ -247,10 +324,15 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
 
 void sp_nodepath_ensure_livarot_path(Inkscape::NodePath::Path *np)
 {
-    if (np && np->livarot_path == NULL && np->path && SP_IS_ITEM(np->path)) {
-        np->livarot_path = Path_for_item (np->path, true, true);
+    if (np && np->livarot_path == NULL) {
+        SPCurve *curve = create_curve(np);
+        NArtBpath *bpath = SP_CURVE_BPATH(curve);
+        np->livarot_path = bpath_to_Path(bpath);
+
         if (np->livarot_path)
             np->livarot_path->ConvertWithBackData(0.01);
+
+        sp_curve_unref(curve);
     }
 }
 
@@ -325,7 +407,7 @@ static gint sp_nodepath_selection_get_subpath_count(Inkscape::NodePath::Path *np
     }
     return count;
 }
- 
+
 /**
  * Clean up a nodepath after editing.
  *
@@ -447,11 +529,17 @@ static void update_object(Inkscape::NodePath::Path *np)
 {
     g_assert(np);
 
-    SPCurve *curve = create_curve(np);
+    sp_curve_unref(np->curve);
+    np->curve = create_curve(np);
 
-    sp_shape_set_curve(SP_SHAPE(np->path), curve, TRUE);
+    sp_nodepath_set_curve(np, np->curve);
 
-    sp_curve_unref(curve);
+    if (np->show_helperpath) {
+        SPCurve * helper_curve = sp_curve_copy(np->curve);
+        sp_curve_transform(helper_curve, np->i2d );
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
+        sp_curve_unref(helper_curve);
+    }
 }
 
 /**
@@ -461,26 +549,35 @@ static void update_repr_internal(Inkscape::NodePath::Path *np)
 {
     g_assert(np);
 
-    Inkscape::XML::Node *repr = SP_OBJECT(np->path)->repr;
+    Inkscape::XML::Node *repr = np->object->repr;
+
+    sp_curve_unref(np->curve);
+    np->curve = create_curve(np);
 
-    SPCurve *curve = create_curve(np);
     gchar *typestr = create_typestr(np);
-    gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(curve));
+    gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(np->curve));
 
-    if (repr->attribute("d") == NULL || strcmp(svgpath, repr->attribute("d"))) { // d changed
+    // determine if path has an effect applied and write to correct "d" attribute.
+    if (repr->attribute(np->repr_key) == NULL || strcmp(svgpath, repr->attribute(np->repr_key))) { // d changed
         np->local_change++;
-        repr->setAttribute("d", svgpath);
+        repr->setAttribute(np->repr_key, svgpath);
     }
 
-    if (repr->attribute("sodipodi:nodetypes") == NULL || strcmp(typestr, repr->attribute("sodipodi:nodetypes"))) { // nodetypes changed
+    if (repr->attribute(np->repr_nodetypes_key) == NULL || strcmp(typestr, repr->attribute(np->repr_nodetypes_key))) { // nodetypes changed
         np->local_change++;
-        repr->setAttribute("sodipodi:nodetypes", typestr);
+        repr->setAttribute(np->repr_nodetypes_key, typestr);
     }
 
     g_free(svgpath);
     g_free(typestr);
-    sp_curve_unref(curve);
-}
+
+    if (np->show_helperpath) {
+        SPCurve * helper_curve = sp_curve_copy(np->curve);
+        sp_curve_transform(helper_curve, np->i2d );
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
+        sp_curve_unref(helper_curve);
+    }
+ }
 
 /**
  * Update XML path node with data from path object, commit changes forever.
@@ -497,8 +594,8 @@ void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotati
 
     update_repr_internal(np);
     sp_canvas_end_forced_full_redraws(np->desktop->canvas);
-    
-    sp_document_done(sp_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE, 
+
+    sp_document_done(sp_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE,
                      annotation);
 }
 
@@ -513,7 +610,7 @@ static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar co
     }
 
     update_repr_internal(np);
-    sp_document_maybe_done(sp_desktop_document(np->desktop), key, SP_VERB_CONTEXT_NODE, 
+    sp_document_maybe_done(sp_desktop_document(np->desktop), key, SP_VERB_CONTEXT_NODE,
                            annotation);
 }
 
@@ -524,8 +621,8 @@ static void stamp_repr(Inkscape::NodePath::Path *np)
 {
     g_assert(np);
 
-    Inkscape::XML::Node *old_repr = SP_OBJECT(np->path)->repr;
-    Inkscape::XML::Node *new_repr = old_repr->duplicate();
+    Inkscape::XML::Node *old_repr = np->object->repr;
+    Inkscape::XML::Node *new_repr = old_repr->duplicate(old_repr->document());
 
     // remember the position of the item
     gint pos = old_repr->position();
@@ -537,8 +634,8 @@ static void stamp_repr(Inkscape::NodePath::Path *np)
 
     gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(curve));
 
-    new_repr->setAttribute("d", svgpath);
-    new_repr->setAttribute("sodipodi:nodetypes", typestr);
+    new_repr->setAttribute(np->repr_key, svgpath);
+    new_repr->setAttribute(np->repr_nodetypes_key, typestr);
 
     // add the new repr to the parent
     parent->appendChild(new_repr);
@@ -662,7 +759,7 @@ static gchar *create_typestr(Inkscape::NodePath::Path *np)
 }
 
 /**
- * Returns current path in context.
+ * Returns current path in context. // later eliminate this function at all!
  */
 static Inkscape::NodePath::Path *sp_nodepath_current()
 {
@@ -676,7 +773,7 @@ static Inkscape::NodePath::Path *sp_nodepath_current()
         return NULL;
     }
 
-    return SP_NODE_CONTEXT(event_context)->nodepath;
+    return SP_NODE_CONTEXT(event_context)->shape_editor->get_nodepath();
 }
 
 
@@ -697,7 +794,7 @@ static void sp_nodepath_line_midpoint(Inkscape::NodePath::Node *new_path,Inkscap
     if (end->code == NR_LINETO) {
         new_path->type =Inkscape::NodePath::NODE_CUSP;
         new_path->code = NR_LINETO;
-        new_path->pos  = (t * start->pos + (1 - t) * end->pos);
+        new_path->pos = new_path->n.pos = new_path->p.pos = (t * start->pos + (1 - t) * end->pos);
     } else {
         new_path->type =Inkscape::NodePath::NODE_SMOOTH;
         new_path->code = NR_CURVETO;
@@ -736,13 +833,16 @@ static Inkscape::NodePath::Node *sp_nodepath_line_add_node(Inkscape::NodePath::N
     g_assert( start->n.other == end );
    Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(end->subpath,
                                                end,
-                                              Inkscape::NodePath::NODE_SMOOTH,
+                                               (NRPathcode)end->code == NR_LINETO?
+                                                  Inkscape::NodePath::NODE_CUSP : Inkscape::NodePath::NODE_SMOOTH,
                                                (NRPathcode)end->code,
                                                &start->pos, &start->pos, &start->n.pos);
     sp_nodepath_line_midpoint(newnode, end, t);
 
+    sp_node_adjust_handles(start);
     sp_node_update_handles(start);
     sp_node_update_handles(newnode);
+    sp_node_adjust_handles(end);
     sp_node_update_handles(end);
 
     return newnode;
@@ -838,12 +938,14 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode
     end->code = code;
 
     if (code == NR_LINETO) {
-        if (start->code == NR_LINETO) start->type =Inkscape::NodePath::NODE_CUSP;
+        if (start->code == NR_LINETO) {
+            sp_nodepath_set_node_type (start, Inkscape::NodePath::NODE_CUSP);
+        }
         if (end->n.other) {
-            if (end->n.other->code == NR_LINETO) end->type =Inkscape::NodePath::NODE_CUSP;
+            if (end->n.other->code == NR_LINETO) {
+                sp_nodepath_set_node_type (end, Inkscape::NodePath::NODE_CUSP);
+            }
         }
-        sp_node_adjust_handle(start, -1);
-        sp_node_adjust_handle(end, 1);
     } else {
         NR::Point delta = end->pos - start->pos;
         start->n.pos = start->pos + delta / 3;
@@ -907,28 +1009,40 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
 */
 void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
 {
+    bool p_line = (node->p.other != NULL) && (node->code == NR_LINETO || node->pos == node->p.pos);
+    bool n_line = (node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos);
+
     if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) {
-        if ((node->p.other != NULL) && (node->code == NR_LINETO || node->pos == node->p.pos)) {
-            // convert adjacent segment BEFORE to curve
-            node->code = NR_CURVETO;
-            NR::Point delta;
-            if (node->n.other != NULL)
-                delta = node->n.other->pos - node->p.other->pos;
-            else
-                delta = node->pos - node->p.other->pos;
-            node->p.pos = node->pos - delta / 4;
-            sp_node_update_handles(node);
-        }
+        if (p_line && n_line) {
+            // only if both adjacent segments are lines,
+            // convert both to curves:
 
-        if ((node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos)) {
-            // convert adjacent segment AFTER to curve
+            node->code = NR_CURVETO;
             node->n.other->code = NR_CURVETO;
+
+            NR::Point leg_prev = node->pos - node->p.other->pos;
+            NR::Point leg_next = node->pos - node->n.other->pos;
+
+            double norm_leg_prev = L2(leg_prev);
+            double norm_leg_next = L2(leg_next);
+
+            // delta has length 1 and is orthogonal to bisecting line
             NR::Point delta;
-            if (node->p.other != NULL)
-                delta = node->p.other->pos - node->n.other->pos;
-            else
-                delta = node->pos - node->n.other->pos;
-            node->n.pos = node->pos - delta / 4;
+            if (norm_leg_next > 0.0) {
+                delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev;
+                (&delta)->normalize();
+            }
+
+            if (type == Inkscape::NodePath::NODE_SYMM) {
+                double norm_leg_avg = (norm_leg_prev + norm_leg_next) / 2;
+                node->p.pos = node->pos + 0.3 * norm_leg_avg * delta;
+                node->n.pos = node->pos - 0.3 * norm_leg_avg * delta;
+            } else {
+                // length of handle is proportional to distance to adjacent node
+                node->p.pos = node->pos + 0.3 * norm_leg_prev * delta;
+                node->n.pos = node->pos - 0.3 * norm_leg_next * delta;
+            }
+
             sp_node_update_handles(node);
         }
     }
@@ -947,22 +1061,33 @@ void sp_node_moveto(Inkscape::NodePath::Node *node, NR::Point p)
     node->p.pos += delta;
     node->n.pos += delta;
 
+    Inkscape::NodePath::Node *node_p = NULL;
+    Inkscape::NodePath::Node *node_n = NULL;
+
     if (node->p.other) {
         if (node->code == NR_LINETO) {
             sp_node_adjust_handle(node, 1);
             sp_node_adjust_handle(node->p.other, -1);
+            node_p = node->p.other;
         }
     }
     if (node->n.other) {
         if (node->n.other->code == NR_LINETO) {
             sp_node_adjust_handle(node, -1);
             sp_node_adjust_handle(node->n.other, 1);
+            node_n = node->n.other;
         }
     }
 
     // this function is only called from batch movers that will update display at the end
     // themselves, so here we just move all the knots without emitting move signals, for speed
     sp_node_update_handles(node, false);
+    if (node_n) {
+        sp_node_update_handles(node_n, false);
+    }
+    if (node_p) {
+        sp_node_update_handles(node_p, false);
+    }
 }
 
 /**
@@ -977,10 +1102,10 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
 
     if (snap) {
         SnapManager const &m = nodepath->desktop->namedview->snap_manager;
-        
+
         for (GList *l = nodepath->selected; l != NULL; l = l->next) {
             Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
-            Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAP_POINT, n->pos + delta, NULL);
+            Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, SP_PATH(n->subpath->nodepath->item));
             if (s.getDistance() < best) {
                 best = s.getDistance();
                 best_pt = s.getPoint() - n->pos;
@@ -1045,7 +1170,7 @@ sp_nodepath_move_node_and_handles (Inkscape::NodePath::Node *n, NR::Point delta,
  * Displace selected nodes and their handles by fractions of delta (from their origins), depending
  * on how far they are from the dragged node n.
  */
-static void 
+static void
 sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, NR::Point delta)
 {
     g_assert (n);
@@ -1131,7 +1256,7 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
                 } else {
                     n_range += bezier_length (n_node->p.other->origin, n_node->p.other->n.origin, n_node->p.origin, n_node->origin);
                     if (n_node->selected) {
-                        sp_nodepath_move_node_and_handles (n_node, 
+                        sp_nodepath_move_node_and_handles (n_node,
                                                            sculpt_profile (n_range / n_sel_range, alpha, profile) * delta,
                                                            sculpt_profile ((n_range + NR::L2(n_node->n.origin - n_node->origin)) / n_sel_range, alpha, profile) * delta,
                                                            sculpt_profile ((n_range - NR::L2(n_node->p.origin - n_node->origin)) / n_sel_range, alpha, profile) * delta);
@@ -1148,7 +1273,7 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
                 } else {
                     p_range += bezier_length (p_node->n.other->origin, p_node->n.other->p.origin, p_node->n.origin, p_node->origin);
                     if (p_node->selected) {
-                        sp_nodepath_move_node_and_handles (p_node, 
+                        sp_nodepath_move_node_and_handles (p_node,
                                                            sculpt_profile (p_range / p_sel_range, alpha, profile) * delta,
                                                            sculpt_profile ((p_range - NR::L2(p_node->n.origin - p_node->origin)) / p_sel_range, alpha, profile) * delta,
                                                            sculpt_profile ((p_range + NR::L2(p_node->p.origin - p_node->origin)) / p_sel_range, alpha, profile) * delta);
@@ -1164,7 +1289,7 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
     } else {
         // Multiple subpaths have selected nodes:
         // use spatial mode, where the distance from n to node being dragged is measured directly as NR::L2.
-        // TODO: correct these distances taking into account their angle relative to the bisector, so as to 
+        // TODO: correct these distances taking into account their angle relative to the bisector, so as to
         // fix the pear-like shape when sculpting e.g. a ring
 
         // First pass: calculate range
@@ -1209,9 +1334,8 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
  * handle possible snapping, and commit the change with possible undo.
  */
 void
-sp_node_selected_move(gdouble dx, gdouble dy)
+sp_node_selected_move(Inkscape::NodePath::Path *nodepath, gdouble dx, gdouble dy)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) return;
 
     sp_nodepath_selected_nodes_move(nodepath, dx, dy, false);
@@ -1229,7 +1353,7 @@ sp_node_selected_move(gdouble dx, gdouble dy)
  * Move node selection off screen and commit the change.
  */
 void
-sp_node_selected_move_screen(gdouble dx, gdouble dy)
+sp_node_selected_move_screen(Inkscape::NodePath::Path *nodepath, gdouble dx, gdouble dy)
 {
     // borrowed from sp_selection_move_screen in selection-chemistry.c
     // we find out the current zoom factor and divide deltas by it
@@ -1239,7 +1363,6 @@ sp_node_selected_move_screen(gdouble dx, gdouble dy)
     gdouble zdx = dx / zoom;
     gdouble zdy = dy / zoom;
 
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) return;
 
     sp_nodepath_selected_nodes_move(nodepath, zdx, zdy, false);
@@ -1253,6 +1376,51 @@ sp_node_selected_move_screen(gdouble dx, gdouble dy)
     }
 }
 
+/**
+ * Move selected nodes to the absolute position given
+ */
+void sp_node_selected_move_absolute(Inkscape::NodePath::Path *nodepath, NR::Coord val, NR::Dim2 axis)
+{
+    for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+        Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+        NR::Point npos(axis == NR::X ? val : n->pos[NR::X], axis == NR::Y ? val : n->pos[NR::Y]);
+        sp_node_moveto(n, npos);
+    }
+
+    sp_nodepath_update_repr(nodepath, _("Move nodes"));
+}
+
+/**
+ * If the coordinates of all selected nodes coincide, return the common coordinate; otherwise return NR::Nothing
+ */
+NR::Maybe<NR::Coord> sp_node_selected_common_coord (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
+{
+    NR::Maybe<NR::Coord> no_coord = NR::Nothing();
+    g_return_val_if_fail(nodepath->selected, no_coord);
+
+    // determine coordinate of first selected node
+    GList *nsel = nodepath->selected;
+    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nsel->data;
+    NR::Coord coord = n->pos[axis];
+    bool coincide = true;
+
+    // compare it to the coordinates of all the other selected nodes
+    for (GList *l = nsel->next; l != NULL; l = l->next) {
+        n = (Inkscape::NodePath::Node *) l->data;
+        if (n->pos[axis] != coord) {
+            coincide = false;
+        }
+    }
+    if (coincide) {
+        return coord;
+    } else {
+        NR::Rect bbox = sp_node_selected_bbox(nodepath);
+        // currently we return the coordinate of the bounding box midpoint because I don't know how
+        // to erase the spin button entry field :), but maybe this can be useful behaviour anyway
+        return bbox.midpoint()[axis];
+    }
+}
+
 /** If they don't yet exist, creates knot and line for the given side of the node */
 static void sp_node_ensure_knot_exists (SPDesktop *desktop, Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *side)
 {
@@ -1297,7 +1465,7 @@ static void sp_node_update_handle(Inkscape::NodePath::Node *node, gint which, gb
             sp_node_ensure_knot_exists(node->subpath->nodepath->desktop, node, side);
             // Just created, so we shouldn't fire the node_moved callback - instead set the knot position directly
             side->knot->pos = side->pos;
-            if (side->knot->item) 
+            if (side->knot->item)
                 SP_CTRL(side->knot->item)->moveto(side->pos);
             sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos);
             sp_knot_show(side->knot);
@@ -1344,7 +1512,7 @@ static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_mov
     if (node->knot->pos != node->pos) { // visible knot is in a different position, need to update
         if (fire_move_signals)
             sp_knot_set_position(node->knot, &node->pos, 0);
-        else 
+        else
             sp_knot_moveto(node->knot, &node->pos);
     }
 
@@ -1388,9 +1556,8 @@ static void sp_nodepath_update_handles(Inkscape::NodePath::Path *nodepath)
 }
 
 void
-sp_nodepath_show_handles(bool show)
+sp_nodepath_show_handles(Inkscape::NodePath::Path *nodepath, bool show)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (nodepath == NULL) return;
 
     nodepath->show_handles = show;
@@ -1498,9 +1665,8 @@ void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, NR::Dim
  * Call sp_nodepath_line_add_node() for all selected segments.
  */
 void
-sp_node_selected_add_node(void)
+sp_node_selected_add_node(Inkscape::NodePath::Path *nodepath)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) {
         return;
     }
@@ -1548,14 +1714,18 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po
     }
 
     sp_nodepath_ensure_livarot_path(nodepath);
-    Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+    NR::Maybe<Path::cut_position> maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+    if (!maybe_position) {
+        return;
+    }
+    Path::cut_position position = *maybe_position;
 
     //find segment to segment
     Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
 
     //fixme: this can return NULL, so check before proceeding.
     g_return_if_fail(e != NULL);
-    
+
     gboolean force = FALSE;
     if (!(e->selected && (!e->p.other || e->p.other->selected))) {
         force = TRUE;
@@ -1580,7 +1750,11 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
     }
 
     sp_nodepath_ensure_livarot_path(nodepath);
-    Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+    NR::Maybe<Path::cut_position> maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+    if (!maybe_position) {
+        return;
+    }
+    Path::cut_position position = *maybe_position;
 
     //find segment to split
     Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
@@ -1608,12 +1782,14 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
  * cf. app/vectors/gimpbezierstroke.c, gimp_bezier_stroke_point_move_relative()
  */
 void
-sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
+sp_nodepath_curve_drag(int node, double t, NR::Point delta)
 {
+    Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(node);
+
     //fixme: e and e->p can be NULL, so check for those before proceeding
     g_return_if_fail(e != NULL);
     g_return_if_fail(&e->p != NULL);
-    
+
     /* feel good is an arbitrary parameter that distributes the delta between handles
      * if t of the drag point is less than 1/6 distance form the endpoint only
      * the corresponding hadle is adjusted. This matches the behavior in GIMP
@@ -1653,9 +1829,8 @@ sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
 /**
  * Call sp_nodepath_break() for all selected segments.
  */
-void sp_node_selected_break()
+void sp_node_selected_break(Inkscape::NodePath::Path *nodepath)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) return;
 
     GList *temp = NULL;
@@ -1681,9 +1856,8 @@ void sp_node_selected_break()
 /**
  * Duplicate the selected node(s).
  */
-void sp_node_selected_duplicate()
+void sp_node_selected_duplicate(Inkscape::NodePath::Path *nodepath)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) {
         return;
     }
@@ -1711,9 +1885,8 @@ void sp_node_selected_duplicate()
 /**
  *  Join two nodes by merging them into one.
  */
-void sp_node_selected_join()
+void sp_node_selected_join(Inkscape::NodePath::Path *nodepath)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
 
     if (g_list_length(nodepath->selected) != 2) {
@@ -1725,8 +1898,11 @@ void sp_node_selected_join()
    Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
 
     g_assert(a != b);
-    g_assert(a->p.other || a->n.other);
-    g_assert(b->p.other || b->n.other);
+    if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) {
+        // someone tried to join an orphan node (i.e. a single-node subpath).
+        // this is not worth an error message, just fail silently.
+        return;
+    }
 
     if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
         nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
@@ -1810,9 +1986,8 @@ void sp_node_selected_join()
 /**
  *  Join two nodes by adding a segment between them.
  */
-void sp_node_selected_join_segment()
+void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
 
     if (g_list_length(nodepath->selected) != 2) {
@@ -1824,8 +1999,11 @@ void sp_node_selected_join_segment()
    Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
 
     g_assert(a != b);
-    g_assert(a->p.other || a->n.other);
-    g_assert(b->p.other || b->n.other);
+    if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) {
+        // someone tried to join an orphan node (i.e. a single-node subpath).
+        // this is not worth an error message, just fail silently.
+        return;
+    }
 
     if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
         nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
@@ -1912,7 +2090,7 @@ void sp_node_selected_join_segment()
 void sp_node_delete_preserve(GList *nodes_to_delete)
 {
     GSList *nodepaths = NULL;
-    
+
     while (nodes_to_delete) {
         Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node*) g_list_first(nodes_to_delete)->data;
         Inkscape::NodePath::SubPath *sp = node->subpath;
@@ -1921,7 +2099,7 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
         Inkscape::NodePath::Node *sample_end = NULL;
         Inkscape::NodePath::Node *delete_cursor = node;
         bool just_delete = false;
-        
+
         //find the start of this contiguous selection
         //move left to the first node that is not selected
         //or the start of the non-closed path
@@ -1936,7 +2114,7 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
         } else {
             sample_cursor = delete_cursor->p.other;
         }
-        
+
         //calculate points for each segment
         int rate = 5;
         float period = 1.0 / rate;
@@ -1949,7 +2127,7 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
                     just_delete = true;
                     break;
                 }
-                
+
                 //sample points on the contiguous selected segment
                 NR::Point *bez;
                 bez = new NR::Point [4];
@@ -1977,7 +2155,7 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
             NR::Point *adata;
             adata = new NR::Point [data.size()];
             copy(data.begin(), data.end(), adata);
-            
+
             NR::Point *bez;
             bez = new NR::Point [4];
             //would decreasing error create a better fitting approximation?
@@ -1990,18 +2168,18 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
             //the resulting nodes behave as expected.
             sp_nodepath_convert_node_type(sample_cursor, Inkscape::NodePath::NODE_CUSP);
             sp_nodepath_convert_node_type(sample_end, Inkscape::NodePath::NODE_CUSP);
-            
+
             //adjust endpoints
             sample_cursor->n.pos = bez[1];
             sample_end->p.pos = bez[2];
         }
-       
+
         //destroy this contiguous selection
         while (delete_cursor && g_list_find(nodes_to_delete, delete_cursor)) {
             Inkscape::NodePath::Node *temp = delete_cursor;
             if (delete_cursor->n.other == delete_cursor) {
                 // delete_cursor->n points to itself, which means this is the last node on a closed subpath
-                delete_cursor = NULL; 
+                delete_cursor = NULL;
             } else {
                 delete_cursor = delete_cursor->n.other;
             }
@@ -2044,9 +2222,8 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
 /**
  * Delete one or more selected nodes.
  */
-void sp_node_selected_delete()
+void sp_node_selected_delete(Inkscape::NodePath::Path *nodepath)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) return;
     if (!nodepath->selected) return;
 
@@ -2067,7 +2244,7 @@ void sp_node_selected_delete()
         sp_nodepath_get_node_count(nodepath) < 2) {
         SPDocument *document = sp_desktop_document (nodepath->desktop);
         sp_selection_delete();
-        sp_document_done (document, SP_VERB_CONTEXT_NODE, 
+        sp_document_done (document, SP_VERB_CONTEXT_NODE,
                           _("Delete nodes"));
         return;
     }
@@ -2082,12 +2259,11 @@ void sp_node_selected_delete()
  * This is the code for 'split'.
  */
 void
-sp_node_selected_delete_segment(void)
+sp_node_selected_delete_segment(Inkscape::NodePath::Path *nodepath)
 {
    Inkscape::NodePath::Node *start, *end;     //Start , end nodes.  not inclusive
    Inkscape::NodePath::Node *curr, *next;     //Iterators
 
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
 
     if (g_list_length(nodepath->selected) != 2) {
@@ -2211,7 +2387,10 @@ sp_node_selected_delete_segment(void)
         //Copy everything after 'end' to a new subpath
        Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(nodepath);
         for (curr=end ; curr ; curr=curr->n.other) {
-            sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)curr->type, (NRPathcode)curr->code,
+            NRPathcode code = (NRPathcode) curr->code;
+            if (curr == end)
+                code = NR_MOVETO;
+            sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)curr->type, code,
                                  &curr->p.pos, &curr->pos, &curr->n.pos);
         }
 
@@ -2240,9 +2419,8 @@ sp_node_selected_delete_segment(void)
  * Call sp_nodepath_set_line() for all selected segments.
  */
 void
-sp_node_selected_set_line_type(NRPathcode code)
+sp_node_selected_set_line_type(Inkscape::NodePath::Path *nodepath, NRPathcode code)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (nodepath == NULL) return;
 
     for (GList *l = nodepath->selected; l != NULL; l = l->next) {
@@ -2260,11 +2438,12 @@ sp_node_selected_set_line_type(NRPathcode code)
  * Call sp_nodepath_convert_node_type() for all selected nodes.
  */
 void
-sp_node_selected_set_type(Inkscape::NodePath::NodeType type)
+sp_node_selected_set_type(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::NodeType type)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (nodepath == NULL) return;
 
+    if (nodepath->straight_path) return; // don't change type when it is a straight path!
+
     for (GList *l = nodepath->selected; l != NULL; l = l->next) {
         sp_nodepath_convert_node_type((Inkscape::NodePath::Node *) l->data, type);
     }
@@ -2693,7 +2872,7 @@ sp_nodepath_remember_origins(Inkscape::NodePath::Path *nodepath)
            n->n.origin = n->n.pos;
         }
     }
-} 
+}
 
 /**
 \brief  Saves selected nodes in a nodepath into a list containing integer positions of all selected nodes
@@ -2784,7 +2963,7 @@ static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adj
         len = NR::L2(me->pos - node->pos);
         delta = node->pos - othernode->pos;
         linelen = NR::L2(delta);
-        if (linelen < 1e-18) 
+        if (linelen < 1e-18)
             return;
         me->pos = node->pos + (len / linelen)*delta;
         return;
@@ -2854,15 +3033,42 @@ static void sp_node_adjust_handles(Inkscape::NodePath::Node *node)
 /**
  * Node event callback.
  */
-static gboolean node_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n)
+static gboolean node_event(SPKnot */*knot*/, GdkEvent *event, Inkscape::NodePath::Node *n)
 {
     gboolean ret = FALSE;
     switch (event->type) {
         case GDK_ENTER_NOTIFY:
-            active_node = n;
+            Inkscape::NodePath::Path::active_node = n;
             break;
         case GDK_LEAVE_NOTIFY:
-            active_node = NULL;
+            Inkscape::NodePath::Path::active_node = NULL;
+            break;
+        case GDK_SCROLL:
+            if ((event->scroll.state & GDK_CONTROL_MASK) && !(event->scroll.state & GDK_SHIFT_MASK)) { // linearly
+                switch (event->scroll.direction) {
+                    case GDK_SCROLL_UP:
+                        nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+                        break;
+                    case GDK_SCROLL_DOWN:
+                        nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+                        break;
+                    default:
+                        break;
+                }
+                ret = TRUE;
+            } else if (!(event->scroll.state & GDK_SHIFT_MASK)) { // spatially
+                switch (event->scroll.direction) {
+                    case GDK_SCROLL_UP:
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+                        break;
+                    case GDK_SCROLL_DOWN:
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+                        break;
+                    default:
+                        break;
+                }
+                ret = TRUE;
+            }
             break;
         case GDK_KEY_PRESS:
             switch (get_group0_keyval (&event->key)) {
@@ -2875,16 +3081,16 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::No
                     break;
                 case GDK_Page_Up:
                     if (event->key.state & GDK_CONTROL_MASK) {
-                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
-                    } else {
                         nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+                    } else {
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
                     }
                     break;
                 case GDK_Page_Down:
                     if (event->key.state & GDK_CONTROL_MASK) {
-                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
-                    } else {
                         nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+                    } else {
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
                     }
                     break;
                 default:
@@ -2906,33 +3112,33 @@ gboolean node_key(GdkEvent *event)
     Inkscape::NodePath::Path *np;
 
     // there is no way to verify nodes so set active_node to nil when deleting!!
-    if (active_node == NULL) return FALSE;
+    if (Inkscape::NodePath::Path::active_node == NULL) return FALSE;
 
     if ((event->type == GDK_KEY_PRESS) && !(event->key.state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK))) {
         gint ret = FALSE;
         switch (get_group0_keyval (&event->key)) {
             /// \todo FIXME: this does not seem to work, the keys are stolen by tool contexts!
             case GDK_BackSpace:
-                np = active_node->subpath->nodepath;
-                sp_nodepath_node_destroy(active_node);
+                np = Inkscape::NodePath::Path::active_node->subpath->nodepath;
+                sp_nodepath_node_destroy(Inkscape::NodePath::Path::active_node);
                 sp_nodepath_update_repr(np, _("Delete node"));
-                active_node = NULL;
+                Inkscape::NodePath::Path::active_node = NULL;
                 ret = TRUE;
                 break;
             case GDK_c:
-                sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_CUSP);
+                sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_CUSP);
                 ret = TRUE;
                 break;
             case GDK_s:
-                sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_SMOOTH);
+                sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SMOOTH);
                 ret = TRUE;
                 break;
             case GDK_y:
-                sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_SYMM);
+                sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SYMM);
                 ret = TRUE;
                 break;
             case GDK_b:
-                sp_nodepath_node_break(active_node);
+                sp_nodepath_node_break(Inkscape::NodePath::Path::active_node);
                 ret = TRUE;
                 break;
         }
@@ -2944,7 +3150,7 @@ gboolean node_key(GdkEvent *event)
 /**
  * Mouseclick on node callback.
  */
-static void node_clicked(SPKnot *knot, guint state, gpointer data)
+static void node_clicked(SPKnot */*knot*/, guint state, gpointer data)
 {
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -2976,7 +3182,7 @@ static void node_clicked(SPKnot *knot, guint state, gpointer data)
 /**
  * Mouse grabbed node callback.
  */
-static void node_grabbed(SPKnot *knot, guint state, gpointer data)
+static void node_grabbed(SPKnot */*knot*/, guint state, gpointer data)
 {
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -2993,7 +3199,7 @@ static void node_grabbed(SPKnot *knot, guint state, gpointer data)
 /**
  * Mouse ungrabbed node callback.
  */
-static void node_ungrabbed(SPKnot *knot, guint state, gpointer data)
+static void node_ungrabbed(SPKnot */*knot*/, guint /*state*/, gpointer data)
 {
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -3038,7 +3244,7 @@ static double point_line_distance(NR::Point *p, double a)
  * \todo fixme: This goes to "moved" event? (lauris)
  */
 static gboolean
-node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
+node_request(SPKnot */*knot*/, NR::Point *p, guint state, gpointer data)
 {
     double yn, xn, yp, xp;
     double an, ap, na, pa;
@@ -3050,8 +3256,10 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
    // If either (Shift and some handle retracted), or (we're already dragging out a handle)
-   if (((state & GDK_SHIFT_MASK) && ((n->n.other && n->n.pos == n->pos) || (n->p.other && n->p.pos == n->pos))) || n->dragging_out) {
-
+    if ( (!n->subpath->nodepath->straight_path) &&
+         ( ((state & GDK_SHIFT_MASK) && ((n->n.other && n->n.pos == n->pos) || (n->p.other && n->p.pos == n->pos)))
+           || n->dragging_out ) )
+    {
        NR::Point mouse = (*p);
 
        if (!n->dragging_out) {
@@ -3284,13 +3492,12 @@ static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data)
     }
 
     sp_nodepath_update_repr(n->subpath->nodepath, _("Move node handle"));
-    sp_canvas_end_forced_full_redraws(n->subpath->nodepath->desktop->canvas);
 }
 
 /**
  * Node handle "request" signal callback.
  */
-static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
+static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint /*state*/, gpointer data)
 {
     Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -3325,9 +3532,9 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpo
             NR::Coord const scal = dot(delta, ndelta) / linelen;
             (*p) = n->pos + (scal / linelen) * ndelta;
         }
-        *p = m.constrainedSnap(Inkscape::Snapper::SNAP_POINT, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), NULL).getPoint();
+        *p = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), n->subpath->nodepath->item).getPoint();
     } else {
-        *p = m.freeSnap(Inkscape::Snapper::SNAP_POINT, *p, NULL).getPoint();
+        *p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, n->subpath->nodepath->item).getPoint();
     }
 
     sp_node_adjust_handle(n, -which);
@@ -3388,22 +3595,22 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
     }
 
     if (( n->type !=Inkscape::NodePath::NODE_CUSP || (state & GDK_SHIFT_MASK))
-        && rme.a != HUGE_VAL && rnew.a != HUGE_VAL && fabs(rme.a - rnew.a) > 0.001) {
+        && rme.a != HUGE_VAL && rnew.a != HUGE_VAL && (fabs(rme.a - rnew.a) > 0.001 || n->type ==Inkscape::NodePath::NODE_SYMM)) {
         // rotate the other handle correspondingly, if both old and new angles exist and are not the same
         rother.a += rnew.a - rme.a;
         other->pos = NR::Point(rother) + n->pos;
-        sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos);
-        sp_knot_set_position(other->knot, &other->pos, 0);
+        if (other->knot) {
+            sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos);
+            sp_knot_moveto(other->knot, &other->pos);
+        }
     }
 
     me->pos = NR::Point(rnew) + n->pos;
     sp_ctrlline_set_coords(SP_CTRLLINE(me->line), n->pos, me->pos);
 
-    // this is what sp_knot_set_position does, but without emitting the signal:
+    // move knot, but without emitting the signal:
     // we cannot emit a "moved" signal because we're now processing it
-    if (me->knot->item) SP_CTRL(me->knot->item)->moveto(me->pos);
-
-    knot->desktop->set_coordinate_status(me->pos);
+    sp_knot_moveto(me->knot, &(me->pos));
 
     update_object(n->subpath->nodepath);
 
@@ -3449,6 +3656,16 @@ static gboolean node_handle_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePa
                     break;
             }
             break;
+        case GDK_ENTER_NOTIFY:
+            // we use an experimentally determined threshold that seems to work fine
+            if (NR::L2(n->pos - knot->pos) < 0.75)
+                Inkscape::NodePath::Path::active_node = n;
+            break;
+        case GDK_LEAVE_NOTIFY:
+            // we use an experimentally determined threshold that seems to work fine
+            if (NR::L2(n->pos - knot->pos) < 0.75)
+                Inkscape::NodePath::Path::active_node = NULL;
+            break;
         default:
             break;
     }
@@ -3588,10 +3805,16 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
             rot = angle;
         }
 
+        NR::Point rot_center;
+        if (Inkscape::NodePath::Path::active_node == NULL)
+            rot_center = box.midpoint();
+        else
+            rot_center = Inkscape::NodePath::Path::active_node->pos;
+
         NR::Matrix t =
-            NR::Matrix (NR::translate(-box.midpoint())) *
+            NR::Matrix (NR::translate(-rot_center)) *
             NR::Matrix (NR::rotate(rot)) *
-            NR::Matrix (NR::translate(box.midpoint()));
+            NR::Matrix (NR::translate(rot_center));
 
         for (GList *l = nodepath->selected; l != NULL; l = l->next) {
             Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
@@ -3713,10 +3936,16 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
 
         double scale = (box.maxExtent() + grow)/box.maxExtent();
 
+        NR::Point scale_center;
+        if (Inkscape::NodePath::Path::active_node == NULL)
+            scale_center = box.midpoint();
+        else
+            scale_center = Inkscape::NodePath::Path::active_node->pos;
+
         NR::Matrix t =
-            NR::Matrix (NR::translate(-box.midpoint())) *
+            NR::Matrix (NR::translate(-scale_center)) *
             NR::Matrix (NR::scale(scale, scale)) *
-            NR::Matrix (NR::translate(box.midpoint()));
+            NR::Matrix (NR::translate(scale_center));
 
         for (GList *l = nodepath->selected; l != NULL; l = l->next) {
             Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
@@ -3739,11 +3968,11 @@ void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath,
 /**
  * Flip selected nodes horizontally/vertically.
  */
-void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
+void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Maybe<NR::Point> center)
 {
     if (!nodepath || !nodepath->selected) return;
 
-    if (g_list_length(nodepath->selected) == 1) {
+    if (g_list_length(nodepath->selected) == 1 && !center) {
         // flip handles of the single selected node
         Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nodepath->selected->data;
         double temp = n->p.pos[axis];
@@ -3753,17 +3982,14 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
     } else {
         // scale nodes as an "object":
 
-        Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data;
-        NR::Rect box (n0->pos, n0->pos); // originally includes the first selected node
-        for (GList *l = nodepath->selected; l != NULL; l = l->next) {
-            Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
-            box.expandTo (n->pos); // contain all selected nodes
+        NR::Rect box = sp_node_selected_bbox (nodepath);
+        if (!center) {
+            center = box.midpoint();
         }
-
         NR::Matrix t =
-            NR::Matrix (NR::translate(-box.midpoint())) *
+            NR::Matrix (NR::translate(- *center)) *
             NR::Matrix ((axis == NR::X)? NR::scale(-1, 1) : NR::scale(1, -1)) *
-            NR::Matrix (NR::translate(box.midpoint()));
+            NR::Matrix (NR::translate(*center));
 
         for (GList *l = nodepath->selected; l != NULL; l = l->next) {
             Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
@@ -3777,6 +4003,19 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
     sp_nodepath_update_repr(nodepath, _("Flip nodes"));
 }
 
+NR::Rect sp_node_selected_bbox (Inkscape::NodePath::Path *nodepath)
+{
+    g_assert (nodepath->selected);
+
+    Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data;
+    NR::Rect box (n0->pos, n0->pos); // originally includes the first selected node
+    for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+        Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+        box.expandTo (n->pos); // contain all selected nodes
+    }
+    return box;
+}
+
 //-----------------------------------------------
 /**
  * Return new subpath under given nodepath.
@@ -3864,15 +4103,6 @@ static void sp_nodepath_subpath_open(Inkscape::NodePath::SubPath *sp,Inkscape::N
     new_path->p.other = NULL;
 }
 
-/**
- * Returns area in triangle given by points; may be negative.
- */
-inline double
-triangle_area (NR::Point p1, NR::Point p2, NR::Point p3)
-{
-    return (p1[NR::X]*p2[NR::Y] + p1[NR::Y]*p3[NR::X] + p2[NR::X]*p3[NR::Y] - p2[NR::Y]*p3[NR::X] - p1[NR::Y]*p2[NR::X] - p1[NR::X]*p3[NR::Y]);
-}
-
 /**
  * Return new node in subpath with given properties.
  * \param pos Position of node.
@@ -3897,7 +4127,7 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *
         // use the type from sodipodi:nodetypes
         n->type = type;
     } else {
-        if (fabs (triangle_area (*pos, *ppos, *npos)) < 1e-2) {
+        if (fabs (Inkscape::Util::triangle_area (*pos, *ppos, *npos)) < 1e-2) {
             // points are (almost) collinear
             if (NR::L2(*pos - *ppos) < 1e-6 || NR::L2(*pos - *npos) < 1e-6) {
                 // endnode, or a node with a retracted handle
@@ -4000,6 +4230,7 @@ static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node)
         g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_moved), node);
         g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_event), node);
         g_object_unref(G_OBJECT(node->p.knot));
+        node->p.knot = NULL;
     }
 
     if (node->n.knot) {
@@ -4010,6 +4241,7 @@ static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node)
         g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_moved), node);
         g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_event), node);
         g_object_unref(G_OBJECT(node->n.knot));
+        node->n.knot = NULL;
     }
 
     if (node->p.line)
@@ -4103,7 +4335,7 @@ static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Ink
 }
 
 /**
- * Call sp_nodepath_line_add_node() at t on the segment denoted by piece
+ * Return node with the given index
  */
 Inkscape::NodePath::Node *
 sp_nodepath_get_node_by_index(int index)
@@ -4194,7 +4426,7 @@ static gchar const *sp_node_type_description(Inkscape::NodePath::Node *node)
  * Handles content of statusbar as long as node tool is active.
  */
 void
-sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)
+sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to ShapeEditorsCollection
 {
     gchar const *when_selected = _("<b>Drag</b> nodes or node handles; <b>Alt+drag</b> nodes to sculpt; <b>arrow</b> keys to move nodes, <b>&lt; &gt;</b> to scale, <b>[ ]</b> to rotate");
     gchar const *when_selected_one = _("<b>Drag</b> the node or its handles; <b>arrow</b> keys to move the node");
@@ -4216,6 +4448,8 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)
     Inkscape::MessageContext *mc = SP_NODE_CONTEXT (ec)->_node_message_context;
     if (!mc) return;
 
+    inkscape_active_desktop()->emitToolSubselectionChanged(NULL);
+
     if (selected_nodes == 0) {
         Inkscape::Selection *sel = desktop->selection;
         if (!sel || sel->isEmpty()) {
@@ -4259,6 +4493,87 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)
     }
 }
 
+/*
+ * returns a *copy* of the curve of that object.
+ */
+SPCurve* sp_nodepath_object_get_curve(SPObject *object, const gchar *key) {
+    if (!object)
+        return NULL;
+
+    SPCurve *curve = NULL;
+    if (SP_IS_PATH(object)) {
+        SPCurve *curve_new = sp_path_get_curve_for_edit(SP_PATH(object));
+        curve = sp_curve_copy(curve_new);
+    } else if ( IS_LIVEPATHEFFECT(object) && key) {
+        const gchar *svgd = object->repr->attribute(key);
+        if (svgd) {
+            NArtBpath *bpath = sp_svg_read_path(svgd);
+            SPCurve *curve_new = sp_curve_new_from_bpath(bpath);
+            if (curve_new) {
+                curve = curve_new; // don't do curve_copy because curve_new is already only created for us!
+            } else {
+                g_free(bpath);
+            }
+        }
+    }
+
+    return curve;
+}
+
+void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve) {
+    if (!np || !np->object || !curve)
+        return;
+
+    if (SP_IS_PATH(np->object)) {
+        if (SP_SHAPE(np->object)->path_effect_href) {
+            sp_path_set_original_curve(SP_PATH(np->object), curve, true, false);
+        } else {
+            sp_shape_set_curve(SP_SHAPE(np->object), curve, true);
+        }
+    } else if ( IS_LIVEPATHEFFECT(np->object) ) {
+        // FIXME: this writing to string and then reading from string is bound to be slow.
+        // create a method to convert from curve directly to 2geom...
+        gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(np->curve));
+        LIVEPATHEFFECT(np->object)->lpe->setParameter(np->repr_key, svgpath);
+        g_free(svgpath);
+
+        np->object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+    }
+}
+
+void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) {
+    np->show_helperpath = show;
+
+    if (show) {
+        SPCurve *helper_curve = sp_curve_copy(np->curve);
+        sp_curve_transform(helper_curve, np->i2d );
+        if (!np->helper_path) {
+            np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(np->desktop), helper_curve);
+            sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+            sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(np->helper_path), 0, SP_WIND_RULE_NONZERO);
+            sp_canvas_item_show(np->helper_path);
+        } else {
+            sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
+        }
+        sp_curve_unref(helper_curve);
+    } else {
+        if (np->helper_path) {
+            GtkObject *temp = np->helper_path;
+            np->helper_path = NULL;
+            gtk_object_destroy(temp);
+        }
+    }
+}
+
+/* this function does not work yet */
+void sp_nodepath_make_straight_path(Inkscape::NodePath::Path *np) {
+    np->straight_path = true;
+    np->show_handles = false;
+    g_message("add code to make the path straight.");
+    // do sp_nodepath_convert_node_type on all nodes?
+    // search for this text !!!   "Make selected segments lines"
+}
+
 
 /*
   Local Variables: