X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fnodepath.cpp;h=a5fd2fab8af6f5530d6b9ec343b30f38f1a79a93;hb=91db03f244c420daa37e0b5b8a8359ddc2dd626b;hp=3a76e785061009bd06573ab69d87bc17251e51b0;hpb=a36de19bf5d3b83237de388e8a58a2f4f252b859;p=inkscape.git

diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 3a76e7850..a5fd2fab8 100644
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
@@ -37,9 +37,12 @@
 #include "prefs-utils.h"
 #include "sp-metrics.h"
 #include "sp-path.h"
-#include <libnr/nr-matrix-ops.h>
+#include "libnr/nr-matrix-ops.h"
 #include "splivarot.h"
 #include "svg/svg.h"
+#include "display/bezier-utils.h"
+#include <vector>
+#include <algorithm>
 
 class NR::Matrix;
 
@@ -47,7 +50,7 @@ class NR::Matrix;
 /// evil evil evil. FIXME: conflict of two different Path classes!
 /// There is a conflict in the namespace between two classes named Path.
 /// #include "sp-flowtext.h"
-/// #include "sp-flowregion.h" 
+/// #include "sp-flowregion.h"
 
 #define SP_TYPE_FLOWREGION            (sp_flowregion_get_type ())
 #define SP_IS_FLOWREGION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_FLOWREGION))
@@ -88,28 +91,29 @@ static void stamp_repr(Inkscape::NodePath::Path *np);
 static SPCurve *create_curve(Inkscape::NodePath::Path *np);
 static gchar *create_typestr(Inkscape::NodePath::Path *np);
 
-static void sp_node_ensure_ctrls(Inkscape::NodePath::Node *node);
+static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_move_signals = true);
 
 static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean incremental, gboolean override);
 
 static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean selected);
 
-/* Control knot placement, if node or other knot is moved */
-
-static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjust);
-static void sp_node_adjust_knots(Inkscape::NodePath::Node *node);
-
-/* Knot event handlers */
+/* 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);
 
+/* Node event callbacks */
 static void node_clicked(SPKnot *knot, guint state, gpointer data);
 static void node_grabbed(SPKnot *knot, guint state, gpointer data);
 static void node_ungrabbed(SPKnot *knot, guint state, gpointer data);
 static gboolean node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data);
-static void node_ctrl_clicked(SPKnot *knot, guint state, gpointer data);
-static void node_ctrl_grabbed(SPKnot *knot, guint state, gpointer data);
-static void node_ctrl_ungrabbed(SPKnot *knot, guint state, gpointer data);
-static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpointer data);
-static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data);
+
+/* Handle event callbacks */
+static void node_handle_clicked(SPKnot *knot, guint state, gpointer data);
+static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data);
+static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data);
+static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpointer data);
+static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data);
+static gboolean node_handle_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n);
 
 /* Constructors and destructors */
 
@@ -131,7 +135,7 @@ static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Ink
 static Inkscape::NodePath::Node *active_node = NULL;
 
 /**
- * \brief Creates new nodepath from item 
+ * \brief Creates new nodepath from item
  */
 Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item)
 {
@@ -180,9 +184,11 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item)
     np->subpaths    = NULL;
     np->selected    = NULL;
     np->nodeContext = NULL; //Let the context that makes this set it
+    np->livarot_path = NULL;
+    np->local_change = 0;
 
     // we need to update item's transform from the repr here,
-    // because they may be out of sync when we respond 
+    // 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");
 
@@ -190,17 +196,23 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item)
     np->d2i  = np->i2d.inverse();
     np->repr = repr;
 
-    /* Now the bitchy part (lauris) */
-
+    // create the subpath(s) from the bpath
     NArtBpath *b = bpath;
-
     while (b->code != NR_END) {
         b = subpath_from_bpath(np, b, typestr + (b - bpath));
     }
 
+    // reverse the list, because sp_nodepath_subpath_new() used g_list_prepend instead of append (for speed)
+    np->subpaths = g_list_reverse(np->subpaths);
+
     g_free(typestr);
     sp_curve_unref(curve);
 
+    // create the livarot representation from the same item
+    np->livarot_path = Path_for_item(item, true, true);
+    if (np->livarot_path)
+        np->livarot_path->ConvertWithBackData(0.01);
+
     return np;
 }
 
@@ -222,6 +234,11 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
 
     g_assert(!np->selected);
 
+    if (np->livarot_path) {
+        delete np->livarot_path;
+        np->livarot_path = NULL;
+    }
+
     np->desktop = NULL;
 
     g_free(np);
@@ -257,7 +274,7 @@ static gint sp_nodepath_get_node_count(Inkscape::NodePath::Path *np)
 
 /**
  * Clean up a nodepath after editing.
- * 
+ *
  * Currently we are deleting trivial subpaths.
  */
 static void sp_nodepath_cleanup(Inkscape::NodePath::Path *nodepath)
@@ -281,61 +298,6 @@ static void sp_nodepath_cleanup(Inkscape::NodePath::Path *nodepath)
     g_list_free(badSubPaths);
 }
 
-
-
-/**
- * \brief Returns true if the argument nodepath and the d attribute in 
- * its repr do not match. 
- *
- * This may happen if repr was changed in, e.g., XML editor or by undo. 
- * 
- * \todo
- * UGLY HACK, think how we can eliminate it.
- */
-gboolean nodepath_repr_d_changed(Inkscape::NodePath::Path *np, char const *newd)
-{
-    g_assert(np);
-
-    SPCurve *curve = create_curve(np);
-
-    gchar *svgpath = sp_svg_write_path(curve->bpath);
-
-    char const *attr_d = ( newd
-                           ? newd
-                           : SP_OBJECT(np->path)->repr->attribute("d") );
-
-    gboolean ret;
-    if (attr_d && svgpath)
-        ret = strcmp(attr_d, svgpath);
-    else 
-        ret = TRUE;
-
-    g_free(svgpath);
-    sp_curve_unref(curve);
-
-    return ret;
-}
-
-/**
- * \brief Returns true if the argument nodepath and the sodipodi:nodetypes 
- * attribute in its repr do not match. 
- *
- * This may happen if repr was changed in, e.g., the XML editor or by undo.
- */
-gboolean nodepath_repr_typestr_changed(Inkscape::NodePath::Path *np, char const *newtypestr)
-{
-    g_assert(np);
-    gchar *typestr = create_typestr(np);
-    char const *attr_typestr = ( newtypestr
-                                 ? newtypestr
-                                 : SP_OBJECT(np->path)->repr->attribute("sodipodi:nodetypes") );
-    gboolean const ret = (attr_typestr && strcmp(attr_typestr, typestr));
-
-    g_free(typestr);
-
-    return ret;
-}
-
 /**
  * Create new nodepath from b, make it subpath of np.
  * \param t The node type.
@@ -424,7 +386,8 @@ static gchar *parse_nodetypes(gchar const *types, gint length)
 }
 
 /**
- * Make curve out of path and associate it with it.
+ * Make curve out of nodepath, write it into that nodepath's SPShape item so that display is
+ * updated but repr is not (for speed). Used during curve and node drag.
  */
 static void update_object(Inkscape::NodePath::Path *np)
 {
@@ -448,10 +411,17 @@ static void update_repr_internal(Inkscape::NodePath::Path *np)
 
     SPCurve *curve = create_curve(np);
     gchar *typestr = create_typestr(np);
-    gchar *svgpath = sp_svg_write_path(curve->bpath);
+    gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(curve));
 
-    repr->setAttribute("d", svgpath);
-    repr->setAttribute("sodipodi:nodetypes", typestr);
+    if (repr->attribute("d") == NULL || strcmp(svgpath, repr->attribute("d"))) { // d changed
+        np->local_change++;
+        repr->setAttribute("d", svgpath);
+    }
+
+    if (repr->attribute("sodipodi:nodetypes") == NULL || strcmp(typestr, repr->attribute("sodipodi:nodetypes"))) { // nodetypes changed
+        np->local_change++;
+        repr->setAttribute("sodipodi:nodetypes", typestr);
+    }
 
     g_free(svgpath);
     g_free(typestr);
@@ -461,19 +431,41 @@ static void update_repr_internal(Inkscape::NodePath::Path *np)
 /**
  * Update XML path node with data from path object, commit changes forever.
  */
-static void update_repr(Inkscape::NodePath::Path *np)
+void sp_nodepath_update_repr(Inkscape::NodePath::Path *np)
 {
     update_repr_internal(np);
-    sp_document_done(SP_DT_DOCUMENT(np->desktop));
+    sp_document_done(sp_desktop_document(np->desktop));
+
+    if (np->livarot_path) {
+        delete np->livarot_path;
+        np->livarot_path = NULL;
+    }
+
+    if (np->path && SP_IS_ITEM(np->path)) {
+        np->livarot_path = Path_for_item (np->path, true, true);
+        if (np->livarot_path)
+            np->livarot_path->ConvertWithBackData(0.01);
+    }
 }
 
 /**
  * Update XML path node with data from path object, commit changes with undo.
  */
-static void update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key)
+static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key)
 {
     update_repr_internal(np);
-    sp_document_maybe_done(SP_DT_DOCUMENT(np->desktop), key);
+    sp_document_maybe_done(sp_desktop_document(np->desktop), key);
+
+    if (np->livarot_path) {
+        delete np->livarot_path;
+        np->livarot_path = NULL;
+    }
+
+    if (np->path && SP_IS_ITEM(np->path)) {
+        np->livarot_path = Path_for_item (np->path, true, true);
+        if (np->livarot_path)
+            np->livarot_path->ConvertWithBackData(0.01);
+    }
 }
 
 /**
@@ -494,7 +486,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(curve->bpath);
+    gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(curve));
 
     new_repr->setAttribute("d", svgpath);
     new_repr->setAttribute("sodipodi:nodetypes", typestr);
@@ -504,7 +496,7 @@ static void stamp_repr(Inkscape::NodePath::Path *np)
     // move to the saved position
     new_repr->setPosition(pos > 0 ? pos : 0);
 
-    sp_document_done(SP_DT_DOCUMENT(np->desktop));
+    sp_document_done(sp_desktop_document(np->desktop));
 
     Inkscape::GC::release(new_repr);
     g_free(svgpath);
@@ -640,7 +632,7 @@ static Inkscape::NodePath::Path *sp_nodepath_current()
 
 
 /**
- \brief Fills node and control positions for three nodes, splitting line
+ \brief Fills node and handle positions for three nodes, splitting line
   marked by end at distance t.
  */
 static void sp_nodepath_line_midpoint(Inkscape::NodePath::Node *new_path,Inkscape::NodePath::Node *end, gdouble t)
@@ -681,7 +673,7 @@ static void sp_nodepath_line_midpoint(Inkscape::NodePath::Node *new_path,Inkscap
 }
 
 /**
- * Adds new node on direct line between two nodes, activates handles of all 
+ * Adds new node on direct line between two nodes, activates handles of all
  * three nodes.
  */
 static Inkscape::NodePath::Node *sp_nodepath_line_add_node(Inkscape::NodePath::Node *end, gdouble t)
@@ -699,9 +691,9 @@ static Inkscape::NodePath::Node *sp_nodepath_line_add_node(Inkscape::NodePath::N
                                                &start->pos, &start->pos, &start->n.pos);
     sp_nodepath_line_midpoint(newnode, end, t);
 
-    sp_node_ensure_ctrls(start);
-    sp_node_ensure_ctrls(newnode);
-    sp_node_ensure_ctrls(end);
+    sp_node_update_handles(start);
+    sp_node_update_handles(newnode);
+    sp_node_update_handles(end);
 
     return newnode;
 }
@@ -769,12 +761,12 @@ static Inkscape::NodePath::Node *sp_nodepath_node_duplicate(Inkscape::NodePath::
         return newnode; // otherwise select the newly created node
 }
 
-static void sp_node_control_mirror_n_to_p(Inkscape::NodePath::Node *node)
+static void sp_node_handle_mirror_n_to_p(Inkscape::NodePath::Node *node)
 {
     node->p.pos = (node->pos + (node->pos - node->n.pos));
 }
 
-static void sp_node_control_mirror_p_to_n(Inkscape::NodePath::Node *node)
+static void sp_node_handle_mirror_p_to_n(Inkscape::NodePath::Node *node)
 {
     node->n.pos = (node->pos + (node->pos - node->p.pos));
 }
@@ -800,24 +792,24 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode
         if (end->n.other) {
             if (end->n.other->code == NR_LINETO) end->type =Inkscape::NodePath::NODE_CUSP;
         }
-        sp_node_adjust_knot(start, -1);
-        sp_node_adjust_knot(end, 1);
+        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;
         end->p.pos = end->pos - delta / 3;
-        sp_node_adjust_knot(start, 1);
-        sp_node_adjust_knot(end, -1);
+        sp_node_adjust_handle(start, 1);
+        sp_node_adjust_handle(end, -1);
     }
 
-    sp_node_ensure_ctrls(start);
-    sp_node_ensure_ctrls(end);
+    sp_node_update_handles(start);
+    sp_node_update_handles(end);
 }
 
 /**
  * Change node type, and its handles accordingly.
  */
-static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeType type)
+static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
 {
     g_assert(node);
     g_assert(node->subpath);
@@ -834,12 +826,25 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
     node->type = type;
 
     if (node->type == Inkscape::NodePath::NODE_CUSP) {
-        g_object_set(G_OBJECT(node->knot), "shape", SP_KNOT_SHAPE_DIAMOND, "size", 9, NULL);
+        node->knot->setShape (SP_KNOT_SHAPE_DIAMOND);
+        node->knot->setSize (node->selected? 11 : 9);
+        sp_knot_update_ctrl(node->knot);
+    } else {
+        node->knot->setShape (SP_KNOT_SHAPE_SQUARE);
+        node->knot->setSize (node->selected? 9 : 7);
+        sp_knot_update_ctrl(node->knot);
+    }
+
+    // if one of handles is mouseovered, preserve its position
+    if (node->p.knot && SP_KNOT_IS_MOUSEOVER(node->p.knot)) {
+        sp_node_adjust_handle(node, 1);
+    } else if (node->n.knot && SP_KNOT_IS_MOUSEOVER(node->n.knot)) {
+        sp_node_adjust_handle(node, -1);
     } else {
-        g_object_set(G_OBJECT(node->knot), "shape", SP_KNOT_SHAPE_SQUARE, "size", 7, NULL);
+        sp_node_adjust_handles(node);
     }
 
-    sp_node_adjust_knots(node);
+    sp_node_update_handles(node);
 
     sp_nodepath_update_statusbar(node->subpath->nodepath);
 
@@ -847,7 +852,7 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
 }
 
 /**
- * Same as sp_nodepath_set_node_type(), but also converts, if necessary, 
+ * Same as sp_nodepath_set_node_type(), but also converts, if necessary,
  * adjacent segments from lines to curves.
 */
 void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
@@ -859,10 +864,10 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
             NR::Point delta;
             if (node->n.other != NULL)
                 delta = node->n.other->pos - node->p.other->pos;
-            else 
+            else
                 delta = node->pos - node->p.other->pos;
             node->p.pos = node->pos - delta / 4;
-            sp_node_ensure_ctrls(node);
+            sp_node_update_handles(node);
         }
 
         if ((node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos)) {
@@ -871,10 +876,10 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
             NR::Point delta;
             if (node->p.other != NULL)
                 delta = node->p.other->pos - node->n.other->pos;
-            else 
+            else
                 delta = node->pos - node->n.other->pos;
             node->n.pos = node->pos - delta / 4;
-            sp_node_ensure_ctrls(node);
+            sp_node_update_handles(node);
         }
     }
 
@@ -894,18 +899,20 @@ void sp_node_moveto(Inkscape::NodePath::Node *node, NR::Point p)
 
     if (node->p.other) {
         if (node->code == NR_LINETO) {
-            sp_node_adjust_knot(node, 1);
-            sp_node_adjust_knot(node->p.other, -1);
+            sp_node_adjust_handle(node, 1);
+            sp_node_adjust_handle(node->p.other, -1);
         }
     }
     if (node->n.other) {
         if (node->n.other->code == NR_LINETO) {
-            sp_node_adjust_knot(node, -1);
-            sp_node_adjust_knot(node->n.other, 1);
+            sp_node_adjust_handle(node, -1);
+            sp_node_adjust_handle(node->n.other, 1);
         }
     }
 
-    sp_node_ensure_ctrls(node);
+    // 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);
 }
 
 /**
@@ -914,22 +921,19 @@ void sp_node_moveto(Inkscape::NodePath::Node *node, NR::Point p)
 static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, NR::Coord dx, NR::Coord dy,
                                             bool const snap = true)
 {
-    NR::Coord best[2] = { NR_HUGE, NR_HUGE };
+    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;
+        
         for (GList *l = nodepath->selected; l != NULL; l = l->next) {
-           Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
-            NR::Point p = n->pos + delta;
-            for (int dim = 0; dim < 2; dim++) {
-                NR::Coord dist = namedview_dim_snap(nodepath->desktop->namedview,
-                                                    Inkscape::Snapper::SNAP_POINT, p,
-                                                    NR::Dim2(dim), nodepath->path);
-                if (dist < best[dim]) {
-                    best[dim] = dist;
-                    best_pt[dim] = p[dim] - n->pos[dim];
-                }
+            Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+            Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAP_POINT, n->pos + delta, NULL);
+            if (s.getDistance() < best) {
+                best = s.getDistance();
+                best_pt = s.getPoint() - n->pos;
             }
         }
     }
@@ -939,6 +943,7 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
         sp_node_moveto(n, n->pos + best_pt);
     }
 
+    // do not update repr here so that node dragging is acceptably fast
     update_object(nodepath);
 }
 
@@ -955,11 +960,11 @@ sp_node_selected_move(gdouble dx, gdouble dy)
     sp_nodepath_selected_nodes_move(nodepath, dx, dy, false);
 
     if (dx == 0) {
-        update_repr_keyed(nodepath, "node:move:vertical");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
     } else if (dy == 0) {
-        update_repr_keyed(nodepath, "node:move:horizontal");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
     } else {
-        update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath);
     }
 }
 
@@ -983,46 +988,95 @@ sp_node_selected_move_screen(gdouble dx, gdouble dy)
     sp_nodepath_selected_nodes_move(nodepath, zdx, zdy, false);
 
     if (dx == 0) {
-        update_repr_keyed(nodepath, "node:move:vertical");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
     } else if (dy == 0) {
-        update_repr_keyed(nodepath, "node:move:horizontal");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
     } else {
-        update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath);
+    }
+}
+
+/** 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)
+{
+    if (!side->knot) {
+        side->knot = sp_knot_new(desktop, _("<b>Node handle</b>: drag to shape the curve; with <b>Ctrl</b> to snap angle; with <b>Alt</b> to lock length; with <b>Shift</b> to rotate both handles"));
+
+        side->knot->setShape (SP_KNOT_SHAPE_CIRCLE);
+        side->knot->setSize (7);
+        side->knot->setAnchor (GTK_ANCHOR_CENTER);
+        side->knot->setFill(KNOT_FILL, KNOT_FILL_HI, KNOT_FILL_HI);
+        side->knot->setStroke(KNOT_STROKE, KNOT_STROKE_HI, KNOT_STROKE_HI);
+        sp_knot_update_ctrl(side->knot);
+
+        g_signal_connect(G_OBJECT(side->knot), "clicked", G_CALLBACK(node_handle_clicked), node);
+        g_signal_connect(G_OBJECT(side->knot), "grabbed", G_CALLBACK(node_handle_grabbed), node);
+        g_signal_connect(G_OBJECT(side->knot), "ungrabbed", G_CALLBACK(node_handle_ungrabbed), node);
+        g_signal_connect(G_OBJECT(side->knot), "request", G_CALLBACK(node_handle_request), node);
+        g_signal_connect(G_OBJECT(side->knot), "moved", G_CALLBACK(node_handle_moved), node);
+        g_signal_connect(G_OBJECT(side->knot), "event", G_CALLBACK(node_handle_event), node);
+    }
+
+    if (!side->line) {
+        side->line = sp_canvas_item_new(sp_desktop_controls(desktop),
+                                        SP_TYPE_CTRLLINE, NULL);
     }
 }
 
 /**
- * Ensure knot on side of node is visible/invisible.
+ * Ensure the given handle of the node is visible/invisible, update its screen position
  */
-static void sp_node_ensure_knot(Inkscape::NodePath::Node *node, gint which, gboolean show_knot)
+static void sp_node_update_handle(Inkscape::NodePath::Node *node, gint which, gboolean show_handle, bool fire_move_signals)
 {
     g_assert(node != NULL);
 
    Inkscape::NodePath::NodeSide *side = sp_node_get_side(node, which);
     NRPathcode code = sp_node_path_code_from_side(node, side);
 
-    show_knot = show_knot && (code == NR_CURVETO) && (NR::L2(side->pos - node->pos) > 1e-6);
+    show_handle = show_handle && (code == NR_CURVETO) && (NR::L2(side->pos - node->pos) > 1e-6);
 
-    if (show_knot) {
-        if (!SP_KNOT_IS_VISIBLE(side->knot)) {
+    if (show_handle) {
+        if (!side->knot) { // No handle knot at all
+            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) 
+                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);
+        } else {
+            if (side->knot->pos != side->pos) { // only if it's really moved
+                if (fire_move_signals) {
+                    sp_knot_set_position(side->knot, &side->pos, 0); // this will set coords of the line as well
+                } else {
+                    sp_knot_moveto(side->knot, &side->pos);
+                    sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos);
+                }
+            }
+            if (!SP_KNOT_IS_VISIBLE(side->knot)) {
+                sp_knot_show(side->knot);
+            }
         }
-
-        sp_knot_set_position(side->knot, &side->pos, 0);
         sp_canvas_item_show(side->line);
-
     } else {
-        if (SP_KNOT_IS_VISIBLE(side->knot)) {
-            sp_knot_hide(side->knot);
+        if (side->knot) {
+            if (SP_KNOT_IS_VISIBLE(side->knot)) {
+                sp_knot_hide(side->knot);
+            }
+        }
+        if (side->line) {
+            sp_canvas_item_hide(side->line);
         }
-        sp_canvas_item_hide(side->line);
     }
 }
 
 /**
- * Ensure handles on node and neighbours of node are visible if selected.
+ * Ensure the node itself is visible, its handles and those of the neighbours of the node are
+ * visible if selected, update their screen positions. If fire_move_signals, move the node and its
+ * handles so that the corresponding signals are fired, callbacks are activated, and curve is
+ * updated; otherwise, just move the knots silently (used in batch moves).
  */
-static void sp_node_ensure_ctrls(Inkscape::NodePath::Node *node)
+static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_move_signals)
 {
     g_assert(node != NULL);
 
@@ -1030,41 +1084,46 @@ static void sp_node_ensure_ctrls(Inkscape::NodePath::Node *node)
         sp_knot_show(node->knot);
     }
 
-    sp_knot_set_position(node->knot, &node->pos, 0);
+    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 
+            sp_knot_moveto(node->knot, &node->pos);
+    }
 
-    gboolean show_knots = node->selected;
+    gboolean show_handles = node->selected;
     if (node->p.other != NULL) {
-        if (node->p.other->selected) show_knots = TRUE;
+        if (node->p.other->selected) show_handles = TRUE;
     }
     if (node->n.other != NULL) {
-        if (node->n.other->selected) show_knots = TRUE;
+        if (node->n.other->selected) show_handles = TRUE;
     }
 
-    sp_node_ensure_knot(node, -1, show_knots);
-    sp_node_ensure_knot(node, 1, show_knots);
+    sp_node_update_handle(node, -1, show_handles, fire_move_signals);
+    sp_node_update_handle(node, 1, show_handles, fire_move_signals);
 }
 
 /**
- * Call sp_node_ensure_ctrls() for all nodes on subpath.
+ * Call sp_node_update_handles() for all nodes on subpath.
  */
-static void sp_nodepath_subpath_ensure_ctrls(Inkscape::NodePath::SubPath *subpath)
+static void sp_nodepath_subpath_update_handles(Inkscape::NodePath::SubPath *subpath)
 {
     g_assert(subpath != NULL);
 
     for (GList *l = subpath->nodes; l != NULL; l = l->next) {
-        sp_node_ensure_ctrls((Inkscape::NodePath::Node *) l->data);
+        sp_node_update_handles((Inkscape::NodePath::Node *) l->data);
     }
 }
 
 /**
- * Call sp_nodepath_subpath_ensure_ctrls() for all subpaths of nodepath.
+ * Call sp_nodepath_subpath_update_handles() for all subpaths of nodepath.
  */
-static void sp_nodepath_ensure_ctrls(Inkscape::NodePath::Path *nodepath)
+static void sp_nodepath_update_handles(Inkscape::NodePath::Path *nodepath)
 {
     g_assert(nodepath != NULL);
 
     for (GList *l = nodepath->subpaths; l != NULL; l = l->next) {
-        sp_nodepath_subpath_ensure_ctrls((Inkscape::NodePath::SubPath *) l->data);
+        sp_nodepath_subpath_update_handles((Inkscape::NodePath::SubPath *) l->data);
     }
 }
 
@@ -1098,11 +1157,8 @@ void sp_nodepath_selected_align(Inkscape::NodePath::Path *nodepath, NR::Dim2 axi
             sp_node_moveto(pNode, dest);
         }
     }
-    if (axis == NR::X) {
-        update_repr_keyed(nodepath, "node:move:vertical");
-    } else {
-        update_repr_keyed(nodepath, "node:move:horizontal");
-    }
+
+    sp_nodepath_update_repr(nodepath);
 }
 
 /// Helper struct.
@@ -1164,11 +1220,7 @@ void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, NR::Dim
         pos += step;
     }
 
-    if (axis == NR::X) {
-        update_repr_keyed(nodepath, "node:move:horizontal");
-    } else {
-        update_repr_keyed(nodepath, "node:move:vertical");
-    }
+    sp_nodepath_update_repr(nodepath);
 }
 
 
@@ -1201,9 +1253,9 @@ sp_node_selected_add_node(void)
     }
 
     /** \todo fixme: adjust ? */
-    sp_nodepath_ensure_ctrls(nodepath);
+    sp_nodepath_update_handles(nodepath);
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1212,14 +1264,13 @@ sp_node_selected_add_node(void)
  * Select segment nearest to point
  */
 void
-sp_nodepath_select_segment_near_point(SPItem * item, NR::Point p, bool toggle)
+sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p, bool toggle)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) {
         return;
     }
 
-    Path::cut_position position = get_nearest_position_on_Path(item, p);
+    Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
 
     //find segment to segment
     Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
@@ -1227,12 +1278,12 @@ sp_nodepath_select_segment_near_point(SPItem * item, NR::Point p, bool toggle)
     gboolean force = FALSE;
     if (!(e->selected && (!e->p.other || e->p.other->selected))) {
         force = TRUE;
-    } 
+    }
     sp_nodepath_node_select(e, (gboolean) toggle, force);
     if (e->p.other)
         sp_nodepath_node_select(e->p.other, TRUE, force);
 
-    sp_nodepath_ensure_ctrls(nodepath);
+    sp_nodepath_update_handles(nodepath);
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1241,18 +1292,17 @@ sp_nodepath_select_segment_near_point(SPItem * item, NR::Point p, bool toggle)
  * Add a node nearest to point
  */
 void
-sp_nodepath_add_node_near_point(SPItem * item, NR::Point p)
+sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
 {
-    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) {
         return;
     }
 
-    Path::cut_position position = get_nearest_position_on_Path(item, p);
+    Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
 
     //find segment to split
     Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
-   
+
     //don't know why but t seems to flip for lines
     if (sp_node_path_code_from_side(e, sp_node_get_side(e, -1)) == NR_LINETO) {
         position.t = 1.0 - position.t;
@@ -1261,9 +1311,9 @@ sp_nodepath_add_node_near_point(SPItem * item, NR::Point p)
     sp_nodepath_node_select(n, FALSE, TRUE);
 
     /* fixme: adjust ? */
-    sp_nodepath_ensure_ctrls(nodepath);
+    sp_nodepath_update_handles(nodepath);
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1276,7 +1326,7 @@ sp_nodepath_add_node_near_point(SPItem * item, 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, char * key) 
+sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
 {
     /* 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
@@ -1291,7 +1341,7 @@ sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta,
         feel_good = (1 - pow((6 * (1-t) - 1) / 2.0, 3)) / 2 + 0.5;
     else
         feel_good = 1;
-    
+
     //if we're dragging a line convert it to a curve
     if (sp_node_path_code_from_side(e, sp_node_get_side(e, -1))==NR_LINETO) {
         sp_nodepath_set_line_type(e, NR_CURVETO);
@@ -1302,13 +1352,13 @@ sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta,
     e->p.other->n.pos += offsetcoord0;
     e->p.pos += offsetcoord1;
 
-    // adjust controls of adjacent segments where necessary
-    sp_node_adjust_knot(e,1);
-    sp_node_adjust_knot(e->p.other,-1);
+    // adjust handles of adjacent nodes where necessary
+    sp_node_adjust_handle(e,1);
+    sp_node_adjust_handle(e->p.other,-1);
 
-    sp_nodepath_ensure_ctrls(e->subpath->nodepath);
+    sp_nodepath_update_handles(e->subpath->nodepath);
 
-    update_repr_keyed(e->subpath->nodepath, key);
+    update_object(e->subpath->nodepath);
 
     sp_nodepath_update_statusbar(e->subpath->nodepath);
 }
@@ -1337,9 +1387,9 @@ void sp_node_selected_break()
         sp_nodepath_node_select((Inkscape::NodePath::Node *) l->data, TRUE, TRUE);
     }
 
-    sp_nodepath_ensure_ctrls(nodepath);
+    sp_nodepath_update_handles(nodepath);
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 }
 
 /**
@@ -1367,9 +1417,9 @@ void sp_node_selected_duplicate()
         sp_nodepath_node_select((Inkscape::NodePath::Node *) l->data, TRUE, TRUE);
     }
 
-    sp_nodepath_ensure_ctrls(nodepath);
+    sp_nodepath_update_handles(nodepath);
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 }
 
 /**
@@ -1399,16 +1449,22 @@ void sp_node_selected_join()
 
     /* a and b are endpoints */
 
-    NR::Point c = (a->pos + b->pos) / 2;
+    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 {
+        c = (a->pos + b->pos) / 2;
+    }
 
     if (a->subpath == b->subpath) {
        Inkscape::NodePath::SubPath *sp = a->subpath;
         sp_nodepath_subpath_close(sp);
+        sp_node_moveto (sp->first, c);
 
-        sp_nodepath_ensure_ctrls(sp->nodepath);
-
-        update_repr(nodepath);
-
+        sp_nodepath_update_handles(sp->nodepath);
+        sp_nodepath_update_repr(nodepath);
         return;
     }
 
@@ -1458,9 +1514,9 @@ void sp_node_selected_join()
 
     sp_nodepath_subpath_destroy(sb);
 
-    sp_nodepath_ensure_ctrls(sa->nodepath);
+    sp_nodepath_update_handles(sa->nodepath);
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1499,15 +1555,15 @@ void sp_node_selected_join_segment()
         sp->first->p.other = sp->last;
         sp->last->n.other  = sp->first;
 
-        sp_node_control_mirror_p_to_n(sp->last);
-        sp_node_control_mirror_n_to_p(sp->first);
+        sp_node_handle_mirror_p_to_n(sp->last);
+        sp_node_handle_mirror_n_to_p(sp->first);
 
         sp->first->code = sp->last->code;
         sp->first       = sp->last;
 
-        sp_nodepath_ensure_ctrls(sp->nodepath);
+        sp_nodepath_update_handles(sp->nodepath);
 
-        update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath);
 
         return;
     }
@@ -1538,17 +1594,17 @@ void sp_node_selected_join_segment()
 
     if (b == sb->first) {
         n = sb->first;
-        sp_node_control_mirror_p_to_n(sa->last);
+        sp_node_handle_mirror_p_to_n(sa->last);
         sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &n->p.pos, &n->pos, &n->n.pos);
-        sp_node_control_mirror_n_to_p(sa->last);
+        sp_node_handle_mirror_n_to_p(sa->last);
         for (n = n->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) {
         n = sb->last;
-        sp_node_control_mirror_p_to_n(sa->last);
+        sp_node_handle_mirror_p_to_n(sa->last);
         sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &n->pos, &n->p.pos);
-        sp_node_control_mirror_n_to_p(sa->last);
+        sp_node_handle_mirror_n_to_p(sa->last);
         for (n = n->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);
         }
@@ -1559,9 +1615,129 @@ void sp_node_selected_join_segment()
 
     sp_nodepath_subpath_destroy(sb);
 
-    sp_nodepath_ensure_ctrls(sa->nodepath);
+    sp_nodepath_update_handles(sa->nodepath);
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
+}
+
+/**
+ * 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)
+{
+    
+    while (nodes_to_delete) {
+        Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node*) g_list_first(nodes_to_delete)->data;
+        Inkscape::NodePath::SubPath *sp = node->subpath;
+        Inkscape::NodePath::Path *nodepath = sp->nodepath;
+        Inkscape::NodePath::Node *sample_cursor = NULL;
+        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
+        for (Inkscape::NodePath::Node *curr=node->p.other; curr && curr!=node && g_list_find(nodes_to_delete, curr); curr=curr->p.other) {
+            delete_cursor = curr;
+        }
+
+        //just delete at the beginning of an open path
+        if (!delete_cursor->p.other) {
+            sample_cursor = delete_cursor;
+            just_delete = true;
+        } else {
+            sample_cursor = delete_cursor->p.other;
+        }
+        
+        //calculate points for each segment
+        int rate = 5;
+        float period = 1.0 / rate;
+        std::vector<NR::Point> data;
+        if (!just_delete) {
+            data.push_back(sample_cursor->pos);
+            for (Inkscape::NodePath::Node *curr=sample_cursor; curr; curr=curr->n.other) {
+                //just delete at the end of an open path
+                if (!sp->closed && curr->n.other == sp->last) {
+                    just_delete = true;
+                    break;
+                }
+                
+                //sample points on the contiguous selected segment
+                NR::Point *bez;
+                bez = new NR::Point [4];
+                bez[0] = curr->pos;
+                bez[1] = curr->n.pos;
+                bez[2] = curr->n.other->p.pos;
+                bez[3] = curr->n.other->pos;
+                for (int i=1; i<rate; i++) {
+                    gdouble t = i * period;
+                    NR::Point p = bezier_pt(3, bez, t);
+                    data.push_back(p);
+                }
+                data.push_back(curr->n.other->pos);
+
+                sample_end = curr->n.other;
+                //break if we've come full circle or hit the end of the selection
+                if (!g_list_find(nodes_to_delete, curr->n.other) || curr->n.other==sample_cursor) {
+                    break;
+                }
+            }
+        }
+
+        if (!just_delete) {
+            //calculate the best fitting single segment and adjust the endpoints
+            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?
+            gdouble error = 1.0;
+            gint ret;
+            ret = sp_bezier_fit_cubic (bez, adata, data.size(), error);
+
+            //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; 
+            } else {
+                delete_cursor = delete_cursor->n.other;
+            }
+            nodes_to_delete = g_list_remove(nodes_to_delete, temp);
+            sp_nodepath_node_destroy(temp);
+        }
+
+        //clean up the nodepath (such as for trivial subpaths)
+        sp_nodepath_cleanup(nodepath);
+
+        sp_nodepath_update_handles(nodepath);
+
+        // if the entire nodepath is removed, delete the selected object.
+        if (nodepath->subpaths == NULL ||
+            sp_nodepath_get_node_count(nodepath) < 2) {
+            SPDocument *document = sp_desktop_document (nodepath->desktop);
+            sp_nodepath_destroy(nodepath);
+            g_list_free(nodes_to_delete);
+            nodes_to_delete = NULL;
+            //is the next line necessary?
+            sp_selection_delete();
+            sp_document_done (document);
+            return;
+        }
+
+        sp_nodepath_update_repr(nodepath);
+
+        sp_nodepath_update_statusbar(nodepath);
+    }
 }
 
 /**
@@ -1583,19 +1759,19 @@ void sp_node_selected_delete()
     //clean up the nodepath (such as for trivial subpaths)
     sp_nodepath_cleanup(nodepath);
 
-    sp_nodepath_ensure_ctrls(nodepath);
+    sp_nodepath_update_handles(nodepath);
 
     // if the entire nodepath is removed, delete the selected object.
     if (nodepath->subpaths == NULL ||
         sp_nodepath_get_node_count(nodepath) < 2) {
-        SPDocument *document = SP_DT_DOCUMENT (nodepath->desktop);
+        SPDocument *document = sp_desktop_document (nodepath->desktop);
         sp_nodepath_destroy(nodepath);
         sp_selection_delete();
         sp_document_done (document);
         return;
     }
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1752,9 +1928,9 @@ sp_node_selected_delete_segment(void)
     //clean up the nodepath (such as for trivial subpaths)
     sp_nodepath_cleanup(nodepath);
 
-    sp_nodepath_ensure_ctrls(nodepath);
+    sp_nodepath_update_handles(nodepath);
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 
     // if the entire nodepath is removed, delete the selected object.
     if (nodepath->subpaths == NULL ||
@@ -1784,7 +1960,7 @@ sp_node_selected_set_line_type(NRPathcode code)
         }
     }
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 }
 
 /**
@@ -1800,7 +1976,7 @@ sp_node_selected_set_type(Inkscape::NodePath::NodeType type)
         sp_nodepath_convert_node_type((Inkscape::NodePath::Node *) l->data, type);
     }
 
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 }
 
 /**
@@ -1811,26 +1987,20 @@ static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean select
     node->selected = selected;
 
     if (selected) {
-        g_object_set(G_OBJECT(node->knot),
-                     "fill", NODE_FILL_SEL,
-                     "fill_mouseover", NODE_FILL_SEL_HI,
-                     "stroke", NODE_STROKE_SEL,
-                     "stroke_mouseover", NODE_STROKE_SEL_HI,
-                     "size", (node->type == Inkscape::NodePath::NODE_CUSP) ? 11 : 9,
-                     NULL);
+        node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP) ? 11 : 9);
+        node->knot->setFill(NODE_FILL_SEL, NODE_FILL_SEL_HI, NODE_FILL_SEL_HI);
+        node->knot->setStroke(NODE_STROKE_SEL, NODE_STROKE_SEL_HI, NODE_STROKE_SEL_HI);
+        sp_knot_update_ctrl(node->knot);
     } else {
-        g_object_set(G_OBJECT(node->knot),
-                     "fill", NODE_FILL,
-                     "fill_mouseover", NODE_FILL_HI,
-                     "stroke", NODE_STROKE,
-                     "stroke_mouseover", NODE_STROKE_HI,
-                     "size", (node->type == Inkscape::NodePath::NODE_CUSP) ? 9 : 7,
-                     NULL);
+        node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP) ? 9 : 7);
+        node->knot->setFill(NODE_FILL, NODE_FILL_HI, NODE_FILL_HI);
+        node->knot->setStroke(NODE_STROKE, NODE_STROKE_HI, NODE_STROKE_HI);
+        sp_knot_update_ctrl(node->knot);
     }
 
-    sp_node_ensure_ctrls(node);
-    if (node->n.other) sp_node_ensure_ctrls(node->n.other);
-    if (node->p.other) sp_node_ensure_ctrls(node->p.other);
+    sp_node_update_handles(node);
+    if (node->n.other) sp_node_update_handles(node->n.other);
+    if (node->p.other) sp_node_update_handles(node->p.other);
 }
 
 /**
@@ -1846,7 +2016,7 @@ static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean inc
     if (incremental) {
         if (override) {
             if (!g_list_find(nodepath->selected, node)) {
-                nodepath->selected = g_list_append(nodepath->selected, node);
+                nodepath->selected = g_list_prepend(nodepath->selected, node);
             }
             sp_node_set_selected(node, TRUE);
         } else { // toggle
@@ -1855,13 +2025,13 @@ static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean inc
                 nodepath->selected = g_list_remove(nodepath->selected, node);
             } else {
                 g_assert(!g_list_find(nodepath->selected, node));
-                nodepath->selected = g_list_append(nodepath->selected, node);
+                nodepath->selected = g_list_prepend(nodepath->selected, node);
             }
             sp_node_set_selected(node, !node->selected);
         }
     } else {
         sp_nodepath_deselect(nodepath);
-        nodepath->selected = g_list_append(nodepath->selected, node);
+        nodepath->selected = g_list_prepend(nodepath->selected, node);
         sp_node_set_selected(node, TRUE);
     }
 
@@ -1901,10 +2071,10 @@ sp_nodepath_select_all(Inkscape::NodePath::Path *nodepath, bool invert)
     }
 }
 
-/** 
- * If nothing selected, does the same as sp_nodepath_select_all(); 
- * otherwise selects/inverts all nodes in all subpaths that have selected nodes 
- * (i.e., similar to "select all in layer", with the "selected" subpaths 
+/**
+ * If nothing selected, does the same as sp_nodepath_select_all();
+ * otherwise selects/inverts all nodes in all subpaths that have selected nodes
+ * (i.e., similar to "select all in layer", with the "selected" subpaths
  * being treated as "layers" in the path).
  */
 void
@@ -1940,7 +2110,7 @@ sp_nodepath_select_all_from_subpath(Inkscape::NodePath::Path *nodepath, bool inv
 }
 
 /**
- * \brief Select the node after the last selected; if none is selected, 
+ * \brief Select the node after the last selected; if none is selected,
  * select the first within path.
  */
 void sp_nodepath_select_next(Inkscape::NodePath::Path *nodepath)
@@ -1997,7 +2167,7 @@ void sp_nodepath_select_next(Inkscape::NodePath::Path *nodepath)
 }
 
 /**
- * \brief Select the node before the first selected; if none is selected, 
+ * \brief Select the node before the first selected; if none is selected,
  * select the last within path
  */
 void sp_nodepath_select_prev(Inkscape::NodePath::Path *nodepath)
@@ -2120,9 +2290,9 @@ void restore_nodepath_selection(Inkscape::NodePath::Path *nodepath, GList *r)
 }
 
 /**
-\brief Adjusts control point according to node type and line code.
+\brief Adjusts handle according to node type and line code.
 */
-static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjust)
+static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust)
 {
     double len, otherlen, linelen;
 
@@ -2163,21 +2333,15 @@ static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjus
         len = NR::L2(me->pos - node->pos);
         delta = node->pos - othernode->pos;
         linelen = NR::L2(delta);
-        if (linelen < 1e-18) return;
-
+        if (linelen < 1e-18) 
+            return;
         me->pos = node->pos + (len / linelen)*delta;
-        sp_knot_set_position(me->knot, &me->pos, 0);
-
-        sp_node_ensure_ctrls(node);
         return;
     }
 
     if (node->type == Inkscape::NodePath::NODE_SYMM) {
 
         me->pos = 2 * node->pos - other->pos;
-        sp_knot_set_position(me->knot, &me->pos, 0);
-
-        sp_node_ensure_ctrls(node);
         return;
     }
 
@@ -2189,15 +2353,12 @@ static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjus
     if (otherlen < 1e-18) return;
 
     me->pos = node->pos - (len / otherlen) * delta;
-    sp_knot_set_position(me->knot, &me->pos, 0);
-
-    sp_node_ensure_ctrls(node);
 }
 
 /**
- \brief Adjusts control point according to node type and line code
+ \brief Adjusts both handles according to node type and line code
  */
-static void sp_node_adjust_knots(Inkscape::NodePath::Node *node)
+static void sp_node_adjust_handles(Inkscape::NodePath::Node *node)
 {
     g_assert(node);
 
@@ -2211,42 +2372,36 @@ static void sp_node_adjust_knots(Inkscape::NodePath::Node *node)
 
     if (node->code == NR_LINETO) {
         if (node->n.other->code == NR_LINETO) return;
-        sp_node_adjust_knot(node, 1);
-        sp_node_ensure_ctrls(node);
+        sp_node_adjust_handle(node, 1);
         return;
     }
 
     if (node->n.other->code == NR_LINETO) {
         if (node->code == NR_LINETO) return;
-        sp_node_adjust_knot(node, -1);
-        sp_node_ensure_ctrls(node);
+        sp_node_adjust_handle(node, -1);
         return;
     }
 
     /* both are curves */
-
     NR::Point const delta( node->n.pos - node->p.pos );
 
     if (node->type == Inkscape::NodePath::NODE_SYMM) {
         node->p.pos = node->pos - delta / 2;
         node->n.pos = node->pos + delta / 2;
-        sp_node_ensure_ctrls(node);
         return;
     }
 
     /* We are smooth */
-
     double plen = NR::L2(node->p.pos - node->pos);
     if (plen < 1e-18) return;
     double nlen = NR::L2(node->n.pos - node->pos);
     if (nlen < 1e-18) return;
     node->p.pos = node->pos - (plen / (plen + nlen)) * delta;
     node->n.pos = node->pos + (nlen / (plen + nlen)) * delta;
-    sp_node_ensure_ctrls(node);
 }
 
 /**
- * Knot events handler callback.
+ * Node event callback.
  */
 static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
 {
@@ -2295,7 +2450,7 @@ gboolean node_key(GdkEvent *event)
             case GDK_BackSpace:
                 np = active_node->subpath->nodepath;
                 sp_nodepath_node_destroy(active_node);
-                update_repr(np);
+                sp_nodepath_update_repr(np);
                 active_node = NULL;
                 ret = TRUE;
                 break;
@@ -2339,27 +2494,13 @@ static void node_clicked(SPKnot *knot, guint state, gpointer data)
             } else {
                 sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_CUSP);
             }
-            update_repr(nodepath);
+            sp_nodepath_update_repr(nodepath);
             sp_nodepath_update_statusbar(nodepath);
 
         } else { //ctrl+alt+click: delete node
-            sp_nodepath_node_destroy(n);
-            //clean up the nodepath (such as for trivial subpaths)
-            sp_nodepath_cleanup(nodepath);
-
-            // if the entire nodepath is removed, delete the selected object.
-            if (nodepath->subpaths == NULL ||
-                sp_nodepath_get_node_count(nodepath) < 2) {
-                SPDocument *document = SP_DT_DOCUMENT (nodepath->desktop);
-                sp_nodepath_destroy(nodepath);
-                sp_selection_delete();
-                sp_document_done (document);
-
-            } else {
-                sp_nodepath_ensure_ctrls(nodepath);
-                update_repr(nodepath);
-                sp_nodepath_update_statusbar(nodepath);
-            }
+            GList *node_to_delete = NULL;
+            node_to_delete = g_list_append(node_to_delete, n);
+            sp_node_delete_preserve(node_to_delete);
         }
 
     } else {
@@ -2390,7 +2531,7 @@ static void node_ungrabbed(SPKnot *knot, guint state, gpointer data)
 
    n->dragging_out = NULL;
 
-   update_repr(n->subpath->nodepath);
+   sp_nodepath_update_repr(n->subpath->nodepath);
 }
 
 /**
@@ -2439,7 +2580,7 @@ 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 (((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);
 
@@ -2488,11 +2629,15 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
            if (opposite->pos != n->pos) {
                mouse = n->pos - NR::L2(mouse - n->pos) * NR::unit_vector(opposite->pos - n->pos);
            }
+
+           // knots might not be created yet!
+           sp_node_ensure_knot_exists (n->subpath->nodepath->desktop, n, n->dragging_out);
+           sp_node_ensure_knot_exists (n->subpath->nodepath->desktop, n, opposite);
        }
 
        // pass this on to the handle-moved callback
-       node_ctrl_moved(n->dragging_out->knot, &mouse, state, (gpointer) n);
-       sp_node_ensure_ctrls(n);
+       node_handle_moved(n->dragging_out->knot, &mouse, state, (gpointer) n);
+       sp_node_update_handles(n);
        return TRUE;
    }
 
@@ -2531,7 +2676,7 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
             // sliding on handles, only if at least one of the handles is non-vertical
             // (otherwise it's the same as ctrl+drag anyway)
 
-            // calculate angles of the control handles
+            // calculate angles of the handles
             if (xn == 0) {
                 if (yn == 0) { // no handle, consider it the continuation of the other one
                     an = 0;
@@ -2603,7 +2748,7 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
 /**
  * Node handle clicked callback.
  */
-static void node_ctrl_clicked(SPKnot *knot, guint state, gpointer data)
+static void node_handle_clicked(SPKnot *knot, guint state, gpointer data)
 {
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -2613,9 +2758,9 @@ static void node_ctrl_clicked(SPKnot *knot, guint state, gpointer data)
         } else if (n->n.knot == knot) {
             n->n.pos = n->pos;
         }
-        sp_node_ensure_ctrls(n);
+        sp_node_update_handles(n);
         Inkscape::NodePath::Path *nodepath = n->subpath->nodepath;
-        update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath);
         sp_nodepath_update_statusbar(nodepath);
 
     } else { // just select or add to selection, depending in Shift
@@ -2626,7 +2771,7 @@ static void node_ctrl_clicked(SPKnot *knot, guint state, gpointer data)
 /**
  * Node handle grabbed callback.
  */
-static void node_ctrl_grabbed(SPKnot *knot, guint state, gpointer data)
+static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data)
 {
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -2634,7 +2779,7 @@ static void node_ctrl_grabbed(SPKnot *knot, guint state, gpointer data)
         sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE);
     }
 
-    // remember the origin of the control
+    // remember the origin point of the handle
     if (n->p.knot == knot) {
         n->p.origin = n->p.pos - n->pos;
     } else if (n->n.knot == knot) {
@@ -2648,7 +2793,7 @@ static void node_ctrl_grabbed(SPKnot *knot, guint state, gpointer data)
 /**
  * Node handle ungrabbed callback.
  */
-static void node_ctrl_ungrabbed(SPKnot *knot, guint state, gpointer data)
+static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data)
 {
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -2663,13 +2808,13 @@ static void node_ctrl_ungrabbed(SPKnot *knot, guint state, gpointer data)
         g_assert_not_reached();
     }
 
-    update_repr(n->subpath->nodepath);
+    sp_nodepath_update_repr(n->subpath->nodepath);
 }
 
 /**
  * Node handle "request" signal callback.
  */
-static gboolean node_ctrl_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;
 
@@ -2691,7 +2836,7 @@ static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpoin
 
     NRPathcode const othercode = sp_node_path_code_from_side(n, opposite);
 
-    SnapManager const m(n->subpath->nodepath->desktop->namedview);
+    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 */
@@ -2704,12 +2849,12 @@ static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpoin
             NR::Coord const scal = dot(delta, ndelta) / linelen;
             (*p) = n->pos + (scal / linelen) * ndelta;
         }
-        *p = m.constrainedSnap(Inkscape::Snapper::SNAP_POINT, *p, ndelta, NULL).getPoint();
+        *p = m.constrainedSnap(Inkscape::Snapper::SNAP_POINT, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), NULL).getPoint();
     } else {
         *p = m.freeSnap(Inkscape::Snapper::SNAP_POINT, *p, NULL).getPoint();
     }
 
-    sp_node_adjust_knot(n, -which);
+    sp_node_adjust_handle(n, -which);
 
     return FALSE;
 }
@@ -2717,7 +2862,7 @@ static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpoin
 /**
  * Node handle moved callback.
  */
-static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data)
+static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data)
 {
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
@@ -2735,7 +2880,7 @@ static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer da
         g_assert_not_reached();
     }
 
-    // calculate radial coordinates of the grabbed control, other control, and the mouse point
+    // calculate radial coordinates of the grabbed handle, its other handle, and the mouse point
     Radial rme(me->pos - n->pos);
     Radial rother(other->pos - n->pos);
     Radial rnew(*p - n->pos);
@@ -2747,7 +2892,7 @@ static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer da
         // 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.a == HUGE_VAL) {
-            // ortho doesn't exist: original control was zero length.
+            // 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,
@@ -2811,7 +2956,7 @@ static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer da
 /**
  * Node handle event callback.
  */
-static gboolean node_ctrl_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
+static gboolean node_handle_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
 {
     gboolean ret = FALSE;
     switch (event->type) {
@@ -2932,7 +3077,9 @@ static void node_rotate_one (Inkscape::NodePath::Node *n, gdouble angle, int whi
         other->pos =  n->pos + NR::Point(rother);
     }
 
-    sp_node_ensure_ctrls(n);
+    // this function is only called from sp_nodepath_selected_nodes_rotate that will update display at the end,
+    // so here we just move all the knots without emitting move signals, for speed
+    sp_node_update_handles(n, false);
 }
 
 /**
@@ -2950,7 +3097,7 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
 
         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) { 
+        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
         }
@@ -2965,23 +3112,21 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
             rot = angle;
         }
 
-        NR::Matrix t = 
-            NR::Matrix (NR::translate(-box.midpoint())) * 
-            NR::Matrix (NR::rotate(rot)) * 
+        NR::Matrix t =
+            NR::Matrix (NR::translate(-box.midpoint())) *
+            NR::Matrix (NR::rotate(rot)) *
             NR::Matrix (NR::translate(box.midpoint()));
 
-        for (GList *l = nodepath->selected; l != NULL; l = l->next) { 
+        for (GList *l = nodepath->selected; l != NULL; l = l->next) {
             Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
             n->pos *= t;
             n->n.pos *= t;
             n->p.pos *= t;
-            sp_node_ensure_ctrls(n);
+            sp_node_update_handles(n, false);
         }
     }
 
-    update_object(nodepath);
-    /// \todo fixme: use _keyed
-    update_repr(nodepath);
+    sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n");
 }
 
 /**
@@ -3002,14 +3147,14 @@ static void node_scale_one (Inkscape::NodePath::Node *n, gdouble grow, int which
     } else if (!n->p.other) {
         me = &(n->n);
         other = &(n->p);
-        if (n->n.other)    
+        if (n->n.other)
             n->n.other->code = NR_CURVETO;
     } else {
         if (which > 0) { // right handle
             if (xn > xp) {
                 me = &(n->n);
                 other = &(n->p);
-                if (n->n.other)    
+                if (n->n.other)
                     n->n.other->code = NR_CURVETO;
             } else {
                 me = &(n->p);
@@ -3020,7 +3165,7 @@ static void node_scale_one (Inkscape::NodePath::Node *n, gdouble grow, int which
             if (xn <= xp) {
                 me = &(n->n);
                 other = &(n->p);
-                if (n->n.other)    
+                if (n->n.other)
                     n->n.other->code = NR_CURVETO;
             } else {
                 me = &(n->p);
@@ -3032,7 +3177,7 @@ static void node_scale_one (Inkscape::NodePath::Node *n, gdouble grow, int which
             other = &(n->p);
             both = true;
             n->code = NR_CURVETO;
-            if (n->n.other)    
+            if (n->n.other)
                 n->n.other->code = NR_CURVETO;
         }
     }
@@ -3064,7 +3209,9 @@ static void node_scale_one (Inkscape::NodePath::Node *n, gdouble grow, int which
         other->pos = n->pos + NR::Point(rother);
     }
 
-    sp_node_ensure_ctrls(n);
+    // this function is only called from sp_nodepath_selected_nodes_scale that will update display at the end,
+    // so here we just move all the knots without emitting move signals, for speed
+    sp_node_update_handles(n, false);
 }
 
 /**
@@ -3083,30 +3230,28 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
 
         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) { 
+        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
         }
 
         double scale = (box.maxExtent() + grow)/box.maxExtent();
 
-        NR::Matrix t = 
-            NR::Matrix (NR::translate(-box.midpoint())) * 
-            NR::Matrix (NR::scale(scale, scale)) * 
+        NR::Matrix t =
+            NR::Matrix (NR::translate(-box.midpoint())) *
+            NR::Matrix (NR::scale(scale, scale)) *
             NR::Matrix (NR::translate(box.midpoint()));
 
-        for (GList *l = nodepath->selected; l != NULL; l = l->next) { 
+        for (GList *l = nodepath->selected; l != NULL; l = l->next) {
             Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
             n->pos *= t;
             n->n.pos *= t;
             n->p.pos *= t;
-            sp_node_ensure_ctrls(n);
+            sp_node_update_handles(n, false);
         }
     }
 
-    update_object(nodepath);
-    /// \todo fixme: use _keyed
-    update_repr(nodepath);
+    sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n");
 }
 
 void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath, gdouble const grow, int const which)
@@ -3128,34 +3273,32 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
         double temp = n->p.pos[axis];
         n->p.pos[axis] = n->n.pos[axis];
         n->n.pos[axis] = temp;
-        sp_node_ensure_ctrls(n);
+        sp_node_update_handles(n, false);
     } 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) { 
+        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::Matrix t = 
-            NR::Matrix (NR::translate(-box.midpoint())) * 
-            NR::Matrix ((axis == NR::X)? NR::scale(-1, 1) : NR::scale(1, -1)) * 
+        NR::Matrix t =
+            NR::Matrix (NR::translate(-box.midpoint())) *
+            NR::Matrix ((axis == NR::X)? NR::scale(-1, 1) : NR::scale(1, -1)) *
             NR::Matrix (NR::translate(box.midpoint()));
 
-        for (GList *l = nodepath->selected; l != NULL; l = l->next) { 
+        for (GList *l = nodepath->selected; l != NULL; l = l->next) {
             Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
             n->pos *= t;
             n->n.pos *= t;
             n->p.pos *= t;
-            sp_node_ensure_ctrls(n);
+            sp_node_update_handles(n, false);
         }
     }
 
-    update_object(nodepath);
-    /// \todo fixme: use _keyed
-    update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath);
 }
 
 //-----------------------------------------------
@@ -3175,13 +3318,9 @@ static Inkscape::NodePath::SubPath *sp_nodepath_subpath_new(Inkscape::NodePath::
     s->first = NULL;
     s->last = NULL;
 
-    // do not use prepend here because:
-    // if you have a path like "subpath_1 subpath_2 ... subpath_k" in the svg, you end up with
-    // subpath_k -> ... ->subpath_1 in the nodepath structure. thus the i-th node of the svg is not
-    // the i-th node in the nodepath (only if there are multiple subpaths)
-    // note that the problem only arise when called from subpath_from_bpath(), since for all the other
-    // cases, the repr is updated after the call to sp_nodepath_subpath_new()
-    nodepath->subpaths = g_list_append /*g_list_prepend*/ (nodepath->subpaths, s);
+    // using prepend here saves up to 10% of time on paths with many subpaths, but requires that
+    // the caller reverses the list after it's ready (this is done in sp_nodepath_new)
+    nodepath->subpaths = g_list_prepend (nodepath->subpaths, s);
 
     return s;
 }
@@ -3218,7 +3357,7 @@ static void sp_nodepath_subpath_close(Inkscape::NodePath::SubPath *sp)
     //Link the head to the tail
     sp->first->p.other = sp->last;
     sp->last->n.other  = sp->first;
-    sp->last->n.pos    = sp->first->n.pos;
+    sp->last->n.pos    = sp->last->pos + (sp->first->n.pos - sp->first->pos);
     sp->first          = sp->last;
 
     //Remove the extra end node
@@ -3253,7 +3392,7 @@ static void sp_nodepath_subpath_open(Inkscape::NodePath::SubPath *sp,Inkscape::N
  * Returns area in triangle given by points; may be negative.
  */
 inline double
-triangle_area (NR::Point p1, NR::Point p2, NR::Point p3) 
+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]);
 }
@@ -3305,7 +3444,7 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *
 
     Inkscape::NodePath::Node *prev;
     if (next) {
-        g_assert(g_list_find(sp->nodes, next));
+        //g_assert(g_list_find(sp->nodes, next));
         prev = next->p.other;
     } else {
         prev = sp->last;
@@ -3324,20 +3463,15 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *
     n->p.other = prev;
     n->n.other = next;
 
-    n->knot = sp_knot_new(sp->nodepath->desktop);
+    n->knot = sp_knot_new(sp->nodepath->desktop, _("<b>Node</b>: drag to edit the path; with <b>Ctrl</b> to snap to horizontal/vertical; with <b>Ctrl+Alt</b> to snap to handles' directions"));
     sp_knot_set_position(n->knot, pos, 0);
-    g_object_set(G_OBJECT(n->knot),
-                 "anchor", GTK_ANCHOR_CENTER,
-                 "fill", NODE_FILL,
-                 "fill_mouseover", NODE_FILL_HI,
-                 "stroke", NODE_STROKE,
-                 "stroke_mouseover", NODE_STROKE_HI,
-                 "tip", _("<b>Node</b>: drag to edit the path; with <b>Ctrl</b> to snap to horizontal/vertical; with <b>Ctrl+Alt</b> to snap to handles' directions"),
-                 NULL);
-    if (n->type == Inkscape::NodePath::NODE_CUSP)
-        g_object_set(G_OBJECT(n->knot), "shape", SP_KNOT_SHAPE_DIAMOND, "size", 9, NULL);
-    else
-        g_object_set(G_OBJECT(n->knot), "shape", SP_KNOT_SHAPE_SQUARE, "size", 7, NULL);
+
+    n->knot->setShape ((n->type == Inkscape::NodePath::NODE_CUSP)? SP_KNOT_SHAPE_DIAMOND : SP_KNOT_SHAPE_SQUARE);
+    n->knot->setSize ((n->type == Inkscape::NodePath::NODE_CUSP)? 9 : 7);
+    n->knot->setAnchor (GTK_ANCHOR_CENTER);
+    n->knot->setFill(NODE_FILL, NODE_FILL_HI, NODE_FILL_HI);
+    n->knot->setStroke(NODE_STROKE, NODE_STROKE_HI, NODE_STROKE_HI);
+    sp_knot_update_ctrl(n->knot);
 
     g_signal_connect(G_OBJECT(n->knot), "event", G_CALLBACK(node_event), n);
     g_signal_connect(G_OBJECT(n->knot), "clicked", G_CALLBACK(node_clicked), n);
@@ -3346,52 +3480,11 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *
     g_signal_connect(G_OBJECT(n->knot), "request", G_CALLBACK(node_request), n);
     sp_knot_show(n->knot);
 
-    n->p.knot = sp_knot_new(sp->nodepath->desktop);
-    sp_knot_set_position(n->p.knot, ppos, 0);
-    g_object_set(G_OBJECT(n->p.knot),
-                 "shape", SP_KNOT_SHAPE_CIRCLE,
-                 "size", 7,
-                 "anchor", GTK_ANCHOR_CENTER,
-                 "fill", KNOT_FILL,
-                 "fill_mouseover", KNOT_FILL_HI,
-                 "stroke", KNOT_STROKE,
-                 "stroke_mouseover", KNOT_STROKE_HI,
-                 "tip", _("<b>Node handle</b>: drag to shape the curve; with <b>Ctrl</b> to snap angle; with <b>Alt</b> to lock length; with <b>Shift</b> to rotate both handles"),
-                 NULL);
-    g_signal_connect(G_OBJECT(n->p.knot), "clicked", G_CALLBACK(node_ctrl_clicked), n);
-    g_signal_connect(G_OBJECT(n->p.knot), "grabbed", G_CALLBACK(node_ctrl_grabbed), n);
-    g_signal_connect(G_OBJECT(n->p.knot), "ungrabbed", G_CALLBACK(node_ctrl_ungrabbed), n);
-    g_signal_connect(G_OBJECT(n->p.knot), "request", G_CALLBACK(node_ctrl_request), n);
-    g_signal_connect(G_OBJECT(n->p.knot), "moved", G_CALLBACK(node_ctrl_moved), n);
-    g_signal_connect(G_OBJECT(n->p.knot), "event", G_CALLBACK(node_ctrl_event), n);
-
-    sp_knot_hide(n->p.knot);
-    n->p.line = sp_canvas_item_new(SP_DT_CONTROLS(n->subpath->nodepath->desktop),
-                                   SP_TYPE_CTRLLINE, NULL);
-    sp_canvas_item_hide(n->p.line);
-
-    n->n.knot = sp_knot_new(sp->nodepath->desktop);
-    sp_knot_set_position(n->n.knot, npos, 0);
-    g_object_set(G_OBJECT(n->n.knot),
-                 "shape", SP_KNOT_SHAPE_CIRCLE,
-                 "size", 7,
-                 "anchor", GTK_ANCHOR_CENTER,
-                 "fill", KNOT_FILL,
-                 "fill_mouseover", KNOT_FILL_HI,
-                 "stroke", KNOT_STROKE,
-                 "stroke_mouseover", KNOT_STROKE_HI,
-                 "tip", _("<b>Node handle</b>: drag to shape the curve; with <b>Ctrl</b> to snap angle; with <b>Alt</b> to lock length; with <b>Shift</b> to rotate the opposite handle in sync"),
-                 NULL);
-    g_signal_connect(G_OBJECT(n->n.knot), "clicked", G_CALLBACK(node_ctrl_clicked), n);
-    g_signal_connect(G_OBJECT(n->n.knot), "grabbed", G_CALLBACK(node_ctrl_grabbed), n);
-    g_signal_connect(G_OBJECT(n->n.knot), "ungrabbed", G_CALLBACK(node_ctrl_ungrabbed), n);
-    g_signal_connect(G_OBJECT(n->n.knot), "request", G_CALLBACK(node_ctrl_request), n);
-    g_signal_connect(G_OBJECT(n->n.knot), "moved", G_CALLBACK(node_ctrl_moved), n);
-    g_signal_connect(G_OBJECT(n->n.knot), "event", G_CALLBACK(node_ctrl_event), n);
-    sp_knot_hide(n->n.knot);
-    n->n.line = sp_canvas_item_new(SP_DT_CONTROLS(n->subpath->nodepath->desktop),
-                                   SP_TYPE_CTRLLINE, NULL);
-    sp_canvas_item_hide(n->n.line);
+    // We only create handle knots and lines on demand
+    n->p.knot = NULL;
+    n->p.line = NULL;
+    n->n.knot = NULL;
+    n->n.line = NULL;
 
     sp->nodes = g_list_prepend(sp->nodes, n);
 
@@ -3406,9 +3499,6 @@ static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node)
     g_assert(node);
     g_assert(node->subpath);
     g_assert(SP_IS_KNOT(node->knot));
-    g_assert(SP_IS_KNOT(node->p.knot));
-    g_assert(SP_IS_KNOT(node->n.knot));
-    g_assert(g_list_find(node->subpath->nodes, node));
 
    Inkscape::NodePath::SubPath *sp = node->subpath;
 
@@ -3420,11 +3510,15 @@ static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node)
     node->subpath->nodes = g_list_remove(node->subpath->nodes, node);
 
     g_object_unref(G_OBJECT(node->knot));
-    g_object_unref(G_OBJECT(node->p.knot));
-    g_object_unref(G_OBJECT(node->n.knot));
+    if (node->p.knot)
+        g_object_unref(G_OBJECT(node->p.knot));
+    if (node->n.knot)
+        g_object_unref(G_OBJECT(node->n.knot));
 
-    gtk_object_destroy(GTK_OBJECT(node->p.line));
-    gtk_object_destroy(GTK_OBJECT(node->n.line));
+    if (node->p.line)
+        gtk_object_destroy(GTK_OBJECT(node->p.line));
+    if (node->n.line)
+        gtk_object_destroy(GTK_OBJECT(node->n.line));
 
     if (sp->nodes) { // there are others nodes on the subpath
         if (sp->closed) {
@@ -3452,7 +3546,7 @@ static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node)
 }
 
 /**
- * Returns one of the node's two knots (node sides).
+ * Returns one of the node's two sides.
  * \param which Indicates which side.
  * \return Pointer to previous node side if which==-1, next if which==1.
  */
@@ -3475,9 +3569,9 @@ static Inkscape::NodePath::NodeSide *sp_node_get_side(Inkscape::NodePath::Node *
 }
 
 /**
- * Return knot on other side of node.
+ * Return the other side of the node, given one of its sides.
  */
-static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me)
+static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *me)
 {
     g_assert(node);
 
@@ -3490,7 +3584,7 @@ static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::N
 }
 
 /**
- * Return NRPathcode on this knot's side of the node.
+ * Return NRPathcode on the given side of the node.
  */
 static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me)
 {
@@ -3514,11 +3608,11 @@ 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
  */
-Inkscape::NodePath::Node * 
+Inkscape::NodePath::Node *
 sp_nodepath_get_node_by_index(int index)
 {
     Inkscape::NodePath::Node *e = NULL;
-    
+
     Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
     if (!nodepath) {
         return e;
@@ -3526,13 +3620,13 @@ sp_nodepath_get_node_by_index(int index)
 
     //find segment
     for (GList *l = nodepath->subpaths; l ; l=l->next) {
-        
+
         Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *)l->data;
         int n = g_list_length(sp->nodes);
         if (sp->closed) {
             n++;
-        } 
-        
+        }
+
         //if the piece belongs to this subpath grab it
         //otherwise move onto the next subpath
         if (index < n) {
@@ -3549,7 +3643,7 @@ sp_nodepath_get_node_by_index(int index)
             }
         }
     }
-    
+
     return e;
 }