X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fnodepath.cpp;h=b712539ab767f78f872a3fb550c54095ae7f1f9f;hb=876aa46cb01ee981a0a6dcc39af6fdace7be56bc;hp=fa80f3baad0b579078c32c1168e854c95751230b;hpb=0fc5ce7045233dae7e15fdc86774370f1b1d73cb;p=inkscape.git

diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index fa80f3baa..b712539ab 100644
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
@@ -19,6 +19,7 @@
 #include "display/curve.h"
 #include "display/sp-ctrlline.h"
 #include "display/sodipodi-ctrl.h"
+#include "display/sp-canvas-util.h"
 #include <glibmm/i18n.h>
 #include "libnr/n-art-bpath.h"
 #include "libnr/nr-path.h"
@@ -47,7 +48,14 @@
 #include "display/bezier-utils.h"
 #include <vector>
 #include <algorithm>
+#include <cstring>
+#include <string>
 #include "live_effects/lpeobject.h"
+#include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
+#include "util/mathfns.h"
+#include "display/snap-indicator.h"
+#include "snapped-point.h"
 
 class NR::Matrix;
 
@@ -87,7 +95,7 @@ static GMemChunk *nodechunk = NULL;
 
 /* Creation from object */
 
-static NArtBpath *subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath *b, gchar const *t);
+static NArtBpath const * subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath const *b, gchar const *t);
 static gchar *parse_nodetypes(gchar const *types, gint length);
 
 /* Object updating */
@@ -144,6 +152,20 @@ static void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve)
 // active_node indicates mouseover node
 Inkscape::NodePath::Node * Inkscape::NodePath::Path::active_node = NULL;
 
+static void sp_nodepath_draw_helper_curve(Inkscape::NodePath::Path *np, SPDesktop *desktop) {
+    // Draw helper curve
+    if (np->show_helperpath) {
+        SPCurve *helper_curve = np->curve->copy();
+        helper_curve->transform(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_move_to_z(np->helper_path, 0);
+        sp_canvas_item_show(np->helper_path);
+        helper_curve->unref();
+    }
+}
+
 /**
  * \brief Creates new nodepath from item
  */
@@ -173,17 +195,17 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
     if (curve == NULL)
         return NULL;
 
-    NArtBpath *bpath = sp_curve_first_bpath(curve);
-    gint length = curve->end;
+    NArtBpath const *bpath = curve->get_bpath();
+    gint length = curve->get_length();
     if (length == 0) {
-        sp_curve_unref(curve);
+        curve->unref();
         return NULL; // prevent crash for one-node paths
     }
 
     //Create new nodepath
     Inkscape::NodePath::Path *np = g_new(Inkscape::NodePath::Path, 1);
     if (!np) {
-        sp_curve_unref(curve);
+        curve->unref();
         return NULL;
     }
 
@@ -197,8 +219,16 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
     np->local_change = 0;
     np->show_handles = show_handles;
     np->helper_path = NULL;
-    np->curve = sp_curve_copy(curve);
-    np->show_helperpath = false;
+    np->helperpath_rgba = prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff);
+    np->helperpath_width = 1.0;
+    np->curve = curve->copy();
+    np->show_helperpath = (prefs_get_int_attribute ("tools.nodes", "show_helperpath",  0) == 1);
+    if (SP_IS_LPE_ITEM(object)) {
+        Inkscape::LivePathEffect::Effect *lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(object));
+        if (lpe && lpe->isVisible() && lpe->showOrigPath()) {
+            np->show_helperpath = true;
+        }            
+    }
     np->straight_path = false;
     if (IS_LIVEPATHEFFECT(object) && item) {
         np->item = item;
@@ -211,19 +241,26 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
     // to a change in repr by regenerating nodepath     --bb
     sp_object_read_attr(SP_OBJECT(np->item), "transform");
 
-    np->i2d  = sp_item_i2d_affine(np->item);
+    np->i2d  = from_2geom(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);
-        np->show_helperpath = true;
+        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 ) {
+        if ( sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(np->object)) ) {
             np->repr_key = g_strdup("inkscape:original-d");
-            np->show_helperpath = true;
+
+            Inkscape::LivePathEffect::Effect* lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(np->object));
+            if (lpe) {
+                lpe->setup_nodepath(np);
+            }
         } else {
             np->repr_key = g_strdup("d");
         }
@@ -233,7 +270,7 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
     gchar *typestr = parse_nodetypes(nodetypes, length);
 
     // create the subpath(s) from the bpath
-    NArtBpath *b = bpath;
+    NArtBpath const *b = bpath;
     while (b->code != NR_END) {
         b = subpath_from_bpath(np, b, typestr + (b - bpath));
     }
@@ -242,21 +279,12 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
     np->subpaths = g_list_reverse(np->subpaths);
 
     g_free(typestr);
-    sp_curve_unref(curve);
+    curve->unref();
 
     // 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), 0xff0000ff, 1.0, 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);
-    }
+    sp_nodepath_draw_helper_curve(np, desktop);
 
     return np;
 }
@@ -283,14 +311,14 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
         delete np->livarot_path;
         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->unref();
         np->curve = NULL;
     }
 
@@ -313,13 +341,13 @@ void sp_nodepath_ensure_livarot_path(Inkscape::NodePath::Path *np)
 {
     if (np && np->livarot_path == NULL) {
         SPCurve *curve = create_curve(np);
-        NArtBpath *bpath = SP_CURVE_BPATH(curve);
-        np->livarot_path = bpath_to_Path(bpath);
+        np->livarot_path = new Path;
+        np->livarot_path->LoadPathVector(curve->get_pathvector());
 
         if (np->livarot_path)
             np->livarot_path->ConvertWithBackData(0.01);
 
-        sp_curve_unref(curve);
+        curve->unref();
     }
 }
 
@@ -394,7 +422,7 @@ static gint sp_nodepath_selection_get_subpath_count(Inkscape::NodePath::Path *np
     }
     return count;
 }
- 
+
 /**
  * Clean up a nodepath after editing.
  *
@@ -426,7 +454,7 @@ static void sp_nodepath_cleanup(Inkscape::NodePath::Path *nodepath)
  * \param t The node type.
  * \todo Fixme: t should be a proper type, rather than gchar
  */
-static NArtBpath *subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath *b, gchar const *t)
+static NArtBpath const * subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath const *b, gchar const *t)
 {
     NR::Point ppos, pos, npos;
 
@@ -516,16 +544,16 @@ static void update_object(Inkscape::NodePath::Path *np)
 {
     g_assert(np);
 
-    sp_curve_unref(np->curve);
+    np->curve->unref();
     np->curve = create_curve(np);
 
     sp_nodepath_set_curve(np, np->curve);
 
     if (np->show_helperpath) {
-        SPCurve * helper_curve = sp_curve_copy(np->curve);
-        sp_curve_transform(helper_curve, np->i2d );
+        SPCurve * helper_curve = np->curve->copy();
+        helper_curve->transform(np->i2d );
         sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
-        sp_curve_unref(helper_curve);
+        helper_curve->unref();
     }
 }
 
@@ -538,11 +566,11 @@ static void update_repr_internal(Inkscape::NodePath::Path *np)
 
     Inkscape::XML::Node *repr = np->object->repr;
 
-    sp_curve_unref(np->curve);
+    np->curve->unref();
     np->curve = create_curve(np);
-    
+
     gchar *typestr = create_typestr(np);
-    gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(np->curve));
+    gchar *svgpath = sp_svg_write_path(np->curve->get_pathvector());
 
     // 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
@@ -559,10 +587,10 @@ static void update_repr_internal(Inkscape::NodePath::Path *np)
     g_free(typestr);
 
     if (np->show_helperpath) {
-        SPCurve * helper_curve = sp_curve_copy(np->curve);
-        sp_curve_transform(helper_curve, np->i2d );
+        SPCurve * helper_curve = np->curve->copy();
+        helper_curve->transform(np->i2d );
         sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
-        sp_curve_unref(helper_curve);
+        helper_curve->unref();
     }
  }
 
@@ -581,8 +609,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);
 }
 
@@ -597,7 +625,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);
 }
 
@@ -619,7 +647,7 @@ static void stamp_repr(Inkscape::NodePath::Path *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(curve->get_pathvector());
 
     new_repr->setAttribute(np->repr_key, svgpath);
     new_repr->setAttribute(np->repr_nodetypes_key, typestr);
@@ -635,7 +663,7 @@ static void stamp_repr(Inkscape::NodePath::Path *np)
     Inkscape::GC::release(new_repr);
     g_free(svgpath);
     g_free(typestr);
-    sp_curve_unref(curve);
+    curve->unref();
 }
 
 /**
@@ -643,22 +671,20 @@ static void stamp_repr(Inkscape::NodePath::Path *np)
  */
 static SPCurve *create_curve(Inkscape::NodePath::Path *np)
 {
-    SPCurve *curve = sp_curve_new();
+    SPCurve *curve = new SPCurve();
 
     for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) {
        Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *) spl->data;
-        sp_curve_moveto(curve,
-                        sp->first->pos * np->d2i);
+        curve->moveto(sp->first->pos * np->d2i);
        Inkscape::NodePath::Node *n = sp->first->n.other;
         while (n) {
             NR::Point const end_pt = n->pos * np->d2i;
             switch (n->code) {
                 case NR_LINETO:
-                    sp_curve_lineto(curve, end_pt);
+                    curve->lineto(end_pt);
                     break;
                 case NR_CURVETO:
-                    sp_curve_curveto(curve,
-                                     n->p.other->n.pos * np->d2i,
+                    curve->curveto(n->p.other->n.pos * np->d2i,
                                      n->p.pos * np->d2i,
                                      end_pt);
                     break;
@@ -673,7 +699,7 @@ static SPCurve *create_curve(Inkscape::NodePath::Path *np)
             }
         }
         if (sp->closed) {
-            sp_curve_closepath(curve);
+            curve->closepath();
         }
     }
 
@@ -820,7 +846,7 @@ 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,
-                                               (NRPathcode)end->code == NR_LINETO? 
+                                               (NRPathcode)end->code == NR_LINETO?
                                                   Inkscape::NodePath::NODE_CUSP : Inkscape::NodePath::NODE_SMOOTH,
                                                (NRPathcode)end->code,
                                                &start->pos, &start->pos, &start->n.pos);
@@ -953,9 +979,6 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
     g_assert(node);
     g_assert(node->subpath);
 
-    if (type == static_cast<Inkscape::NodePath::NodeType>(static_cast< guint >(node->type) ) )
-        return node;
-
     if ((node->p.other != NULL) && (node->n.other != NULL)) {
         if ((node->code == NR_LINETO) && (node->n.other->code == NR_LINETO)) {
             type =Inkscape::NodePath::NODE_CUSP;
@@ -990,36 +1013,157 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
     return node;
 }
 
+bool
+sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *side)
+{
+        Inkscape::NodePath::Node *othernode = side->other;
+        if (!othernode)
+            return false;
+        NRPathcode const code = sp_node_path_code_from_side(node, side);
+        if (code == NR_LINETO)
+            return true;
+        Inkscape::NodePath::NodeSide *other_to_me = NULL;
+        if (&node->p == side) {
+            other_to_me = &othernode->n;
+        } else if (&node->n == side) {
+            other_to_me = &othernode->p;
+        } 
+        if (!other_to_me)
+            return false;
+        bool is_line = 
+             (NR::L2(othernode->pos - other_to_me->pos) < 1e-6 &&
+              NR::L2(node->pos - side->pos) < 1e-6);
+        return is_line;
+}
+
 /**
- * Same as sp_nodepath_set_node_type(), but also converts, if necessary,
- * adjacent segments from lines to curves.
+ * Same as sp_nodepath_set_node_type(), but also converts, if necessary, adjacent segments from
+ * lines to curves.  If adjacent to one line segment, pulls out or rotates opposite handle to align
+ * with that segment, procucing half-smooth node. If already half-smooth, pull out the second handle too. 
+ * If already cusp and set to cusp, retracts handles.
 */
 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 (p_line && n_line) {
-            // only if both adjacent segments are lines, 
-            // convert both to curves:
-
-            // BEFORE:
-            {
-            node->code = NR_CURVETO;
-            NR::Point delta = node->n.other->pos - node->p.other->pos;
-            node->p.pos = node->pos - delta / 4;
-            }
 
-            // AFTER:
-            {
-            node->n.other->code = NR_CURVETO;
-            NR::Point delta = node->p.other->pos - node->n.other->pos;
-            node->n.pos = node->pos - delta / 4;
+/* 
+  Here's the algorithm of converting node to smooth (Shift+S or toolbar button), in pseudocode:
+ 
+        if (two_handles) {
+            // do nothing, adjust_handles called via set_node_type will line them up
+        } else if (one_handle) {
+            if (opposite_to_handle_is_line) {
+                if (lined_up) {
+                    // already half-smooth; pull opposite handle too making it fully smooth
+                } else {
+                    // do nothing, adjust_handles will line the handle  up, producing a half-smooth node
+                }
+            } else {
+                // pull opposite handle in line with the existing one
+            }
+        } else if (no_handles) {
+            if (both_segments_are_lines OR both_segments_are_curves) {
+                //pull both handles
+            } else {
+                // pull the handle opposite to line segment, making node half-smooth
             }
+        }
+*/
+        bool p_has_handle = (NR::L2(node->pos  - node->p.pos) > 1e-6);
+        bool n_has_handle = (NR::L2(node->pos  - node->n.pos) > 1e-6);
+        bool p_is_line = sp_node_side_is_line(node, &node->p);
+        bool n_is_line = sp_node_side_is_line(node, &node->n);
+
+        if (p_has_handle && n_has_handle) {
+            // do nothing, adjust_handles will line them up
+        } else if (p_has_handle || n_has_handle) {
+            if (p_has_handle && n_is_line) {
+                Radial line (node->n.other->pos - node->pos);
+                Radial handle (node->pos - node->p.pos);
+                if (fabs(line.a - handle.a) < 1e-3) { // lined up
+                    // already half-smooth; pull opposite handle too making it fully smooth
+                    node->n.pos = node->pos + (node->n.other->pos - node->pos) / 3;
+                } else {
+                    // do nothing, adjust_handles will line the handle  up, producing a half-smooth node
+                }
+            } else if (n_has_handle && p_is_line) {
+                Radial line (node->p.other->pos - node->pos);
+                Radial handle (node->pos - node->n.pos);
+                if (fabs(line.a - handle.a) < 1e-3) { // lined up
+                    // already half-smooth; pull opposite handle too making it fully smooth
+                    node->p.pos = node->pos + (node->p.other->pos - node->pos) / 3;
+                } else {
+                    // do nothing, adjust_handles will line the handle  up, producing a half-smooth node
+                }
+            } else if (p_has_handle && node->n.other) {
+                // pull n handle
+                node->n.other->code = NR_CURVETO;
+                double len =  (type == Inkscape::NodePath::NODE_SYMM)?
+                    NR::L2(node->p.pos - node->pos) :
+                    NR::L2(node->n.other->pos - node->pos) / 3;
+                node->n.pos = node->pos - (len / NR::L2(node->p.pos - node->pos)) * (node->p.pos - node->pos);
+            } else if (n_has_handle && node->p.other) {
+                // pull p handle
+                node->code = NR_CURVETO;
+                double len =  (type == Inkscape::NodePath::NODE_SYMM)?
+                    NR::L2(node->n.pos - node->pos) :
+                    NR::L2(node->p.other->pos - node->pos) / 3;
+                node->p.pos = node->pos - (len / NR::L2(node->n.pos - node->pos)) * (node->n.pos - node->pos);
+            }
+        } else if (!p_has_handle && !n_has_handle) {
+            if ((p_is_line && n_is_line) || (!p_is_line && node->p.other && !n_is_line && node->n.other)) {
+                // no handles, but both segments are either lnes or curves:
+                //pull both handles
+
+                // convert both to curves:
+                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;
 
-            sp_node_update_handles(node);
+                double norm_leg_prev = L2(leg_prev);
+                double norm_leg_next = L2(leg_next);
+
+                NR::Point delta;
+                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;
+                }
+
+            } else {
+                // pull the handle opposite to line segment, making it half-smooth
+                if (p_is_line && node->n.other) {
+                    if (type != Inkscape::NodePath::NODE_SYMM) {
+                        // pull n handle
+                        node->n.other->code = NR_CURVETO;
+                        double len =  NR::L2(node->n.other->pos - node->pos) / 3;
+                        node->n.pos = node->pos + (len / NR::L2(node->p.other->pos - node->pos)) * (node->p.other->pos - node->pos);
+                    }
+                } else if (n_is_line && node->p.other) {
+                    if (type != Inkscape::NodePath::NODE_SYMM) {
+                        // pull p handle
+                        node->code = NR_CURVETO;
+                        double len =  NR::L2(node->p.other->pos - node->pos) / 3;
+                        node->p.pos = node->pos + (len / NR::L2(node->n.other->pos - node->pos)) * (node->n.other->pos - node->pos);
+                    }
+                }
+            }
         }
+    } else if (type == Inkscape::NodePath::NODE_CUSP && node->type == Inkscape::NodePath::NODE_CUSP) {
+        // cusping a cusp: retract nodes
+        node->p.pos = node->pos;
+        node->n.pos = node->pos;
     }
 
     sp_nodepath_set_node_type (node, type);
@@ -1069,23 +1213,56 @@ void sp_node_moveto(Inkscape::NodePath::Node *node, NR::Point p)
  * Call sp_node_moveto() for node selection and handle possible snapping.
  */
 static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, NR::Coord dx, NR::Coord dy,
-                                            bool const snap = true)
+                                            bool const snap, bool constrained = false, 
+                                            Inkscape::Snapper::ConstraintLine const &constraint = NR::Point())
 {
     NR::Coord best = NR_HUGE;
     NR::Point delta(dx, dy);
     NR::Point best_pt = delta;
-
-    if (snap) {
-        SnapManager const &m = nodepath->desktop->namedview->snap_manager;
+    Inkscape::SnappedPoint best_abs;
+    
+    if (snap) {    
+        /* When dragging a (selected) node, it should only snap to other nodes (i.e. unselected nodes), and
+         * not to itself. The snapper however can not tell which nodes are selected and which are not, so we 
+         * must provide that information. */
+          
+        // Build a list of the unselected nodes to which the snapper should snap 
+        std::vector<NR::Point> unselected_nodes;
+        for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
+            Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
+            for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
+                Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
+                if (!node->selected) {
+                    unselected_nodes.push_back(node->pos);
+                }    
+            }
+        }        
+        
+        SnapManager &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::SNAPPOINT_NODE, n->pos + delta, SP_PATH(n->subpath->nodepath->item));
-            if (s.getDistance() < best) {
+            m.setup(NULL, SP_PATH(n->subpath->nodepath->item), &unselected_nodes);
+            Inkscape::SnappedPoint s;
+            if (constrained) {
+                Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint;
+                dedicated_constraint.setPoint(n->pos);
+                s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, dedicated_constraint);
+            } else {
+                s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta);
+            }            
+            if (s.getSnapped() && (s.getDistance() < best)) {
                 best = s.getDistance();
+                best_abs = s;
                 best_pt = s.getPoint() - n->pos;
             }
         }
+                        
+        if (best_abs.getSnapped()) {
+            nodepath->desktop->snapindicator->set_new_snappoint(best_abs);
+        } else {
+            nodepath->desktop->snapindicator->remove_snappoint();    
+        }
     }
 
     for (GList *l = nodepath->selected; l != NULL; l = l->next) {
@@ -1145,7 +1322,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);
@@ -1231,7 +1408,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);
@@ -1248,7 +1425,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);
@@ -1264,7 +1441,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
@@ -1351,6 +1528,51 @@ sp_node_selected_move_screen(Inkscape::NodePath::Path *nodepath, gdouble dx, gdo
     }
 }
 
+/**
+ * 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)
 {
@@ -1395,7 +1617,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);
@@ -1442,7 +1664,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);
     }
 
@@ -1655,7 +1877,7 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po
 
     //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;
@@ -1719,7 +1941,7 @@ sp_nodepath_curve_drag(int node, double t, NR::Point delta)
     //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
@@ -1813,40 +2035,20 @@ void sp_node_selected_duplicate(Inkscape::NodePath::Path *nodepath)
 }
 
 /**
- *  Join two nodes by merging them into one.
+ *  Internal function to join two nodes by merging them into one.
  */
-void sp_node_selected_join(Inkscape::NodePath::Path *nodepath)
+static void do_node_selected_join(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *a, Inkscape::NodePath::Node *b)
 {
-    if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
-
-    if (g_list_length(nodepath->selected) != 2) {
-        nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
-        return;
-    }
-
-   Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data;
-   Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
-
-    g_assert(a != b);
-    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."));
-        return;
-    }
-
     /* a and b are endpoints */
 
+    // if one of the two nodes is mouseovered, fix its position
     NR::Point c;
     if (a->knot && SP_KNOT_IS_MOUSEOVER(a->knot)) {
         c = a->pos;
     } else if (b->knot && SP_KNOT_IS_MOUSEOVER(b->knot)) {
         c = b->pos;
     } else {
+        // otherwise, move joined node to the midpoint
         c = (a->pos + b->pos) / 2;
     }
 
@@ -1861,26 +2063,33 @@ void sp_node_selected_join(Inkscape::NodePath::Path *nodepath)
     }
 
     /* a and b are separate subpaths */
-   Inkscape::NodePath::SubPath *sa = a->subpath;
-   Inkscape::NodePath::SubPath *sb = b->subpath;
+    Inkscape::NodePath::SubPath *sa = a->subpath;
+    Inkscape::NodePath::SubPath *sb = b->subpath;
     NR::Point p;
-   Inkscape::NodePath::Node *n;
+    Inkscape::NodePath::Node *n;
     NRPathcode code;
     if (a == sa->first) {
+        // we will now reverse sa, so that a is its last node, not first, and drop that node
         p = sa->first->n.pos;
         code = (NRPathcode)sa->first->n.other->code;
+        // create new subpath
        Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(sa->nodepath);
+       // create a first moveto node on it
         n = sa->last;
         sp_nodepath_node_new(t, NULL,Inkscape::NodePath::NODE_CUSP, NR_MOVETO, &n->n.pos, &n->pos, &n->p.pos);
         n = n->p.other;
+        if (n == sa->first) n = NULL;
         while (n) {
+            // copy the rest of the nodes from sa to t, going backwards
             sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos);
             n = n->p.other;
             if (n == sa->first) n = NULL;
         }
+        // replace sa with t
         sp_nodepath_subpath_destroy(sa);
         sa = t;
     } else if (a == sa->last) {
+        // a is already last, just drop it
         p = sa->last->p.pos;
         code = (NRPathcode)sa->last->code;
         sp_nodepath_node_destroy(sa->last);
@@ -1890,11 +2099,13 @@ void sp_node_selected_join(Inkscape::NodePath::Path *nodepath)
     }
 
     if (b == sb->first) {
+        // copy all nodes from b to a, forward 
         sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->first->n.pos);
         for (n = sb->first->n.other; n != NULL; n = n->n.other) {
             sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->code, &n->p.pos, &n->pos, &n->n.pos);
         }
     } else if (b == sb->last) {
+        // copy all nodes from b to a, backward 
         sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->last->p.pos);
         for (n = sb->last->p.other; n != NULL; n = n->p.other) {
             sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos);
@@ -1914,32 +2125,10 @@ void sp_node_selected_join(Inkscape::NodePath::Path *nodepath)
 }
 
 /**
- *  Join two nodes by adding a segment between them.
+ *  Internal function to join two nodes by adding a segment between them.
  */
-void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath)
+static void do_node_selected_join_segment(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *a, Inkscape::NodePath::Node *b)
 {
-    if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
-
-    if (g_list_length(nodepath->selected) != 2) {
-        nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
-        return;
-    }
-
-   Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data;
-   Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
-
-    g_assert(a != b);
-    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."));
-        return;
-    }
-
     if (a->subpath == b->subpath) {
        Inkscape::NodePath::SubPath *sp = a->subpath;
 
@@ -1963,10 +2152,10 @@ void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath)
     }
 
     /* a and b are separate subpaths */
-   Inkscape::NodePath::SubPath *sa = a->subpath;
-   Inkscape::NodePath::SubPath *sb = b->subpath;
+    Inkscape::NodePath::SubPath *sa = a->subpath;
+    Inkscape::NodePath::SubPath *sb = b->subpath;
 
-   Inkscape::NodePath::Node *n;
+    Inkscape::NodePath::Node *n;
     NR::Point p;
     NRPathcode code;
     if (a == sa->first) {
@@ -2014,13 +2203,68 @@ void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath)
     sp_nodepath_update_repr(nodepath, _("Join nodes by segment"));
 }
 
+enum NodeJoinType { NODE_JOIN_ENDPOINTS, NODE_JOIN_SEGMENT };
+
+/**
+ * Internal function to handle joining two nodes.
+ */
+static void node_do_selected_join(Inkscape::NodePath::Path *nodepath, NodeJoinType mode)
+{
+    if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
+
+    if (g_list_length(nodepath->selected) != 2) {
+        nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
+        return;
+    }
+
+    Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data;
+    Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
+
+    g_assert(a != b);
+    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."));
+        return;
+    }
+
+    switch(mode) {
+        case NODE_JOIN_ENDPOINTS:
+            do_node_selected_join(nodepath, a, b);
+            break;
+        case NODE_JOIN_SEGMENT:
+            do_node_selected_join_segment(nodepath, a, b);
+            break;
+    }
+}
+
+/**
+ *  Join two nodes by merging them into one.
+ */
+void sp_node_selected_join(Inkscape::NodePath::Path *nodepath)
+{
+    node_do_selected_join(nodepath, NODE_JOIN_ENDPOINTS);
+}
+
+/**
+ *  Join two nodes by adding a segment between them.
+ */
+void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath)
+{
+    node_do_selected_join(nodepath, NODE_JOIN_SEGMENT);
+}
+
 /**
  * Delete one or more selected nodes and preserve the shape of the path as much as possible.
  */
 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;
@@ -2029,7 +2273,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
@@ -2044,7 +2288,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;
@@ -2057,7 +2301,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];
@@ -2085,7 +2329,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?
@@ -2096,20 +2340,22 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
             //if these nodes are smooth or symmetrical, the endpoints will be thrown out of sync.
             //make sure these nodes are changed to cusp nodes so that, once the endpoints are moved,
             //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);
-            
+            if (sample_cursor->type != Inkscape::NodePath::NODE_CUSP)
+                sp_nodepath_convert_node_type(sample_cursor, Inkscape::NodePath::NODE_CUSP);
+            if (sample_end->type != 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;
             }
@@ -2174,7 +2420,7 @@ void sp_node_selected_delete(Inkscape::NodePath::Path *nodepath)
         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;
     }
@@ -2372,6 +2618,8 @@ sp_node_selected_set_type(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath
 {
     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);
     }
@@ -2800,7 +3048,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
@@ -2844,73 +3092,59 @@ void restore_nodepath_selection(Inkscape::NodePath::Path *nodepath, GList *r)
             }
         }
     }
-
 }
 
+
 /**
 \brief Adjusts handle according to node type and line code.
 */
 static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust)
 {
-    double len, otherlen, linelen;
-
     g_assert(node);
 
    Inkscape::NodePath::NodeSide *me = sp_node_get_side(node, which_adjust);
    Inkscape::NodePath::NodeSide *other = sp_node_opposite_side(node, me);
 
-    /** \todo fixme: */
+   // nothing to do if we are an end node
     if (me->other == NULL) return;
     if (other->other == NULL) return;
 
-    /* I have line */
+    // nothing to do if we are a cusp node
+    if (node->type == Inkscape::NodePath::NODE_CUSP) return;
 
-    NRPathcode mecode, ocode;
+    // nothing to do if it's a line from the specified side of the node (i.e. no handle to adjust)
+    NRPathcode mecode;
     if (which_adjust == 1) {
         mecode = (NRPathcode)me->other->code;
-        ocode = (NRPathcode)node->code;
     } else {
         mecode = (NRPathcode)node->code;
-        ocode = (NRPathcode)other->other->code;
     }
-
     if (mecode == NR_LINETO) return;
 
-    /* I am curve */
-
-    if (other->other == NULL) return;
-
-    /* Other has line */
-
-    if (node->type == Inkscape::NodePath::NODE_CUSP) return;
-
-    NR::Point delta;
-    if (ocode == NR_LINETO) {
-        /* other is lineto, we are either smooth or symm */
+    if (sp_node_side_is_line(node, other)) {
+        // other is a line, and we are either smooth or symm
        Inkscape::NodePath::Node *othernode = other->other;
-        len = NR::L2(me->pos - node->pos);
-        delta = node->pos - othernode->pos;
-        linelen = NR::L2(delta);
-        if (linelen < 1e-18) 
+        double len = NR::L2(me->pos - node->pos);
+        NR::Point delta = node->pos - othernode->pos;
+        double linelen = NR::L2(delta);
+        if (linelen < 1e-18)
             return;
         me->pos = node->pos + (len / linelen)*delta;
         return;
     }
 
     if (node->type == Inkscape::NodePath::NODE_SYMM) {
-
+        // symmetrize 
         me->pos = 2 * node->pos - other->pos;
         return;
+    } else {
+        // smoothify
+        double len = NR::L2(me->pos - node->pos);
+        NR::Point delta = other->pos - node->pos;
+        double otherlen = NR::L2(delta);
+        if (otherlen < 1e-18) return;
+        me->pos = node->pos - (len / otherlen) * delta;
     }
-
-    /* We are smooth */
-
-    len = NR::L2(me->pos - node->pos);
-    delta = other->pos - node->pos;
-    otherlen = NR::L2(delta);
-    if (otherlen < 1e-18) return;
-
-    me->pos = node->pos - (len / otherlen) * delta;
 }
 
 /**
@@ -2925,17 +3159,14 @@ static void sp_node_adjust_handles(Inkscape::NodePath::Node *node)
     /* we are either smooth or symm */
 
     if (node->p.other == NULL) return;
-
     if (node->n.other == NULL) return;
 
-    if (node->code == NR_LINETO) {
-        if (node->n.other->code == NR_LINETO) return;
+    if (sp_node_side_is_line(node, &node->p)) {
         sp_node_adjust_handle(node, 1);
         return;
     }
 
-    if (node->n.other->code == NR_LINETO) {
-        if (node->code == NR_LINETO) return;
+    if (sp_node_side_is_line(node, &node->n)) {
         sp_node_adjust_handle(node, -1);
         return;
     }
@@ -2961,7 +3192,7 @@ 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) {
@@ -3078,7 +3309,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;
 
@@ -3110,7 +3341,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;
 
@@ -3127,7 +3358,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;
 
@@ -3172,7 +3403,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;
@@ -3181,11 +3412,15 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
     NR::Point c;
     NR::Point pr;
 
-   Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) 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) {
+    n->subpath->nodepath->desktop->snapindicator->remove_snappoint();
 
+    // If either (Shift and some handle retracted), or (we're already dragging out a handle)
+    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) {
@@ -3325,14 +3560,23 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
             // move the node to the closest point
             sp_nodepath_selected_nodes_move(n->subpath->nodepath,
                                             n->origin[NR::X] + c[NR::X] - n->pos[NR::X],
-                                            n->origin[NR::Y] + c[NR::Y] - n->pos[NR::Y]);
+                                            n->origin[NR::Y] + c[NR::Y] - n->pos[NR::Y], 
+                                            true);
 
         } else {  // constraining to hor/vert
 
             if (fabs((*p)[NR::X] - n->origin[NR::X]) > fabs((*p)[NR::Y] - n->origin[NR::Y])) { // snap to hor
-                sp_nodepath_selected_nodes_move(n->subpath->nodepath, (*p)[NR::X] - n->pos[NR::X], n->origin[NR::Y] - n->pos[NR::Y]);
+                sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+                                                (*p)[NR::X] - n->pos[NR::X], 
+                                                n->origin[NR::Y] - n->pos[NR::Y],
+                                                true, 
+                                                true, Inkscape::Snapper::ConstraintLine(component_vectors[NR::X]));
             } else { // snap to vert
-                sp_nodepath_selected_nodes_move(n->subpath->nodepath, n->origin[NR::X] - n->pos[NR::X], (*p)[NR::Y] - n->pos[NR::Y]);
+                sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+                                                n->origin[NR::X] - n->pos[NR::X],
+                                                (*p)[NR::Y] - n->pos[NR::Y],
+                                                true,
+                                                true, Inkscape::Snapper::ConstraintLine(component_vectors[NR::Y]));
             }
         }
     } else { // move freely
@@ -3423,7 +3667,7 @@ static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data)
 /**
  * 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;
 
@@ -3443,26 +3687,34 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpo
         g_assert_not_reached();
     }
 
-    NRPathcode const othercode = sp_node_path_code_from_side(n, opposite);
-
-    SnapManager const &m = n->subpath->nodepath->desktop->namedview->snap_manager;
-
-    if (opposite->other && (n->type != Inkscape::NodePath::NODE_CUSP) && (othercode == NR_LINETO)) {
-        /* We are smooth node adjacent with line */
-        NR::Point const delta = *p - n->pos;
-        NR::Coord const len = NR::L2(delta);
-        Inkscape::NodePath::Node *othernode = opposite->other;
-        NR::Point const ndelta = n->pos - othernode->pos;
-        NR::Coord const linelen = NR::L2(ndelta);
-        if (len > NR_EPSILON && linelen > NR_EPSILON) {
-            NR::Coord const scal = dot(delta, ndelta) / linelen;
-            (*p) = n->pos + (scal / linelen) * ndelta;
+    SPDesktop *desktop = n->subpath->nodepath->desktop;
+    SnapManager &m = desktop->namedview->snap_manager;
+    m.setup(desktop, n->subpath->nodepath->item);
+    Inkscape::SnappedPoint s ;
+
+    Inkscape::NodePath::Node *othernode = opposite->other;
+    if (othernode) {
+        if ((n->type != Inkscape::NodePath::NODE_CUSP) && sp_node_side_is_line(n, opposite)) {
+            /* We are smooth node adjacent with line */
+            NR::Point const delta = *p - n->pos;
+            NR::Coord const len = NR::L2(delta);
+            Inkscape::NodePath::Node *othernode = opposite->other;
+            NR::Point const ndelta = n->pos - othernode->pos;
+            NR::Coord const linelen = NR::L2(ndelta);
+            if (len > NR_EPSILON && linelen > NR_EPSILON) {
+                NR::Coord const scal = dot(delta, ndelta) / linelen;
+                (*p) = n->pos + (scal / linelen) * ndelta;
+            }
+            s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta));
+        } else {
+            s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p);
         }
-        *p = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), n->subpath->nodepath->item).getPoint();
     } else {
-        *p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, n->subpath->nodepath->item).getPoint();
+        s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p);
     }
-
+    
+    s.getPoint(*p);
+    
     sp_node_adjust_handle(n, -which);
 
     return FALSE;
@@ -3498,21 +3750,42 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
         int const snaps = prefs_get_int_attribute("options.rotationsnapsperpi", "value", 12);
         /* 0 interpreted as "no snapping". */
 
-        // The closest PI/snaps angle, starting from zero.
-        double const a_snapped = floor(rnew.a/(M_PI/snaps) + 0.5) * (M_PI/snaps);
-        if (me->origin_radial.a == HUGE_VAL) {
-            // ortho doesn't exist: original handle was zero length.
-            rnew.a = a_snapped;
-        } else {
-            /* The closest PI/2 angle, starting from original angle (i.e. snapping to original,
-             * its opposite and perpendiculars). */
+        // 1. Snap to the closest PI/snaps angle, starting from zero.
+        double a_snapped = floor(rnew.a/(M_PI/snaps) + 0.5) * (M_PI/snaps);
+
+        // 2. Snap to the original angle, its opposite and perpendiculars
+        if (me->origin_radial.a != HUGE_VAL) { // otherwise ortho doesn't exist: original handle was zero length
+            /* The closest PI/2 angle, starting from original angle */
             double const a_ortho = me->origin_radial.a + floor((rnew.a - me->origin_radial.a)/(M_PI/2) + 0.5) * (M_PI/2);
 
             // Snap to the closest.
-            rnew.a = ( fabs(a_snapped - rnew.a) < fabs(a_ortho - rnew.a)
+            a_snapped = ( fabs(a_snapped - rnew.a) < fabs(a_ortho - rnew.a)
                        ? a_snapped
                        : a_ortho );
         }
+
+        // 3. Snap to the angle of the opposite line, if any
+        Inkscape::NodePath::Node *othernode = other->other;
+        if (othernode) {
+            NR::Point other_to_snap(0,0);
+            if (sp_node_side_is_line(n, other)) {
+                other_to_snap = othernode->pos - n->pos;
+            } else {
+                other_to_snap = other->pos - n->pos;
+            }
+            if (NR::L2(other_to_snap) > 1e-3) {
+                Radial rother_to_snap(other_to_snap);
+                /* The closest PI/2 angle, starting from the angle of the opposite line segment */
+                double const a_oppo = rother_to_snap.a + floor((rnew.a - rother_to_snap.a)/(M_PI/2) + 0.5) * (M_PI/2);
+
+                // Snap to the closest.
+                a_snapped = ( fabs(a_snapped - rnew.a) < fabs(a_oppo - rnew.a)
+                       ? a_snapped
+                       : a_oppo );
+            }
+        }
+
+        rnew.a = a_snapped;
     }
 
     if (state & GDK_MOD1_MASK) {
@@ -3556,7 +3829,7 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
 
     GString *length = SP_PX_TO_METRIC_STRING(rnew.r, desktop->namedview->getDefaultMetric());
 
-    mc->setF(Inkscape::NORMAL_MESSAGE,
+    mc->setF(Inkscape::IMMEDIATE_MESSAGE,
          _("<b>Node handle</b>: angle %0.2f&#176;, length %s; with <b>Ctrl</b> to snap angle; with <b>Alt</b> to lock length; with <b>Shift</b> to rotate both handles"), degrees, length->str);
 
     g_string_free(length, TRUE);
@@ -3908,13 +4181,7 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Ma
     } 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();
         }
@@ -3935,6 +4202,19 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Ma
     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.
@@ -4022,15 +4302,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.
@@ -4055,7 +4326,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
@@ -4376,6 +4647,8 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to Sha
     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()) {
@@ -4429,16 +4702,14 @@ SPCurve* sp_nodepath_object_get_curve(SPObject *object, const gchar *key) {
     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);
+        curve = curve_new->copy();
     } 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);
+            Geom::PathVector pv = sp_svg_read_pathv(svgd);
+            SPCurve *curve_new = new SPCurve(pv);
             if (curve_new) {
                 curve = curve_new; // don't do curve_copy because curve_new is already only created for us!
-            } else {
-                g_free(bpath);
             }
         }
     }
@@ -4451,7 +4722,7 @@ void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve) {
         return;
 
     if (SP_IS_PATH(np->object)) {
-        if (SP_SHAPE(np->object)->path_effect_href) {
+        if (sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(np->object))) {
             sp_path_set_original_curve(SP_PATH(np->object), curve, true, false);
         } else {
             sp_shape_set_curve(SP_SHAPE(np->object), curve, true);
@@ -4459,7 +4730,7 @@ void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve) {
     } 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));
+        gchar *svgpath = sp_svg_write_path( np->curve->get_pathvector() );
         LIVEPATHEFFECT(np->object)->lpe->setParameter(np->repr_key, svgpath);
         g_free(svgpath);
 
@@ -4467,16 +4738,63 @@ void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve) {
     }
 }
 
+SPCanvasItem *
+sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const SPItem *item, guint32 color = 0xff0000ff) {
+    SPCurve *flash_curve = curve->copy();
+    Geom::Matrix i2d = item ? sp_item_i2d_affine(item) : Geom::identity();
+    flash_curve->transform(i2d);
+    SPCanvasItem * canvasitem = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), flash_curve);
+    // would be nice if its color could be XORed or something, now it is invisible for red stroked objects...
+    // unless we also flash the nodes...
+    sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+    sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvasitem), 0, SP_WIND_RULE_NONZERO);
+    sp_canvas_item_show(canvasitem);
+    flash_curve->unref();
+    return canvasitem;
+}
+
+SPCanvasItem *
+sp_nodepath_generate_helperpath(SPDesktop *desktop, SPPath *path) {
+    return sp_nodepath_generate_helperpath(desktop, sp_path_get_curve_for_edit(path), SP_ITEM(path),
+                                           prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff));
+}
+
 void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) {
     np->show_helperpath = show;
+
+    if (show) {
+        SPCurve *helper_curve = np->curve->copy();
+        helper_curve->transform(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_move_to_z(np->helper_path, 0);
+            sp_canvas_item_show(np->helper_path);
+        } else {
+            sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
+        }
+        helper_curve->unref();
+    } else {
+        if (np->helper_path) {
+            GtkObject *temp = np->helper_path;
+            np->helper_path = NULL;
+            gtk_object_destroy(temp);
+        }
+    }
 }
 
+/* sp_nodepath_make_straight_path:
+ *   Prevents user from curving the path by dragging a segment or activating handles etc.
+ *   The resulting path is a linear interpolation between nodal points, with only straight segments.
+ * !!! this function does not work completely yet: it does not actively straighten the path, only prevents the path from being curved
+ */
 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"
+    // coding tip: search for this text : "Make selected segments lines"
 }