X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fnodepath.cpp;h=78d76404df2b0aacbb732d59eac5558760b35edb;hb=6ec35538b3387ac72af1c9e921e531b75250f2d4;hp=4b955973774d27f44ed34e55a167441e9a011d12;hpb=6784119129700c7abaff8c3dfe75916cba09ce32;p=inkscape.git

diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 4b9559737..78d76404d 100644
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
@@ -31,6 +31,7 @@
 #include "message-stack.h"
 #include "message-context.h"
 #include "node-context.h"
+#include "shape-editor.h"
 #include "selection-chemistry.h"
 #include "selection.h"
 #include "xml/repr.h"
@@ -40,6 +41,7 @@
 #include "libnr/nr-matrix-ops.h"
 #include "splivarot.h"
 #include "svg/svg.h"
+#include "verbs.h"
 #include "display/bezier-utils.h"
 #include <vector>
 #include <algorithm>
@@ -137,7 +139,7 @@ static Inkscape::NodePath::Node *active_node = NULL;
 /**
  * \brief Creates new nodepath from item
  */
-Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item)
+Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item, bool show_handles)
 {
     Inkscape::XML::Node *repr = SP_OBJECT(item)->repr;
 
@@ -183,9 +185,10 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item)
     np->path        = path;
     np->subpaths    = NULL;
     np->selected    = NULL;
-    np->nodeContext = NULL; //Let the context that makes this set it
+    np->shape_editor = NULL; //Let the shapeeditor that makes this set it
     np->livarot_path = NULL;
     np->local_change = 0;
+    np->show_handles = show_handles;
 
     // we need to update item's transform from the repr here,
     // because they may be out of sync when we respond
@@ -209,15 +212,13 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item)
     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);
+    sp_nodepath_ensure_livarot_path(np);
 
     return np;
 }
 
 /**
- * Destroys nodepath's subpaths, then itself, also tell context about it.
+ * Destroys nodepath's subpaths, then itself, also tell parent ShapeEditor about it.
  */
 void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
 
@@ -228,9 +229,9 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
         sp_nodepath_subpath_destroy((Inkscape::NodePath::SubPath *) np->subpaths->data);
     }
 
-    //Inform the context that made me, if any, that I am gone.
-    if (np->nodeContext)
-        np->nodeContext->nodepath = NULL;
+    //Inform the ShapeEditor that made me, if any, that I am gone.
+    if (np->shape_editor)
+        np->shape_editor->nodepath_destroyed();
 
     g_assert(!np->selected);
 
@@ -245,6 +246,16 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
 }
 
 
+void sp_nodepath_ensure_livarot_path(Inkscape::NodePath::Path *np)
+{
+    if (np && np->livarot_path == NULL && np->path && SP_IS_ITEM(np->path)) {
+        np->livarot_path = Path_for_item (np->path, true, true);
+        if (np->livarot_path)
+            np->livarot_path->ConvertWithBackData(0.01);
+    }
+}
+
+
 /**
  *  Return the node count of a given NodeSubPath.
  */
@@ -475,41 +486,36 @@ static void update_repr_internal(Inkscape::NodePath::Path *np)
 /**
  * Update XML path node with data from path object, commit changes forever.
  */
-void sp_nodepath_update_repr(Inkscape::NodePath::Path *np)
+void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotation)
 {
-    update_repr_internal(np);
-    sp_document_done(sp_desktop_document(np->desktop));
+    //fixme: np can be NULL, so check before proceeding
+    g_return_if_fail(np != NULL);
 
     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_repr_internal(np);
+    sp_canvas_end_forced_full_redraws(np->desktop->canvas);
+    
+    sp_document_done(sp_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE, 
+                     annotation);
 }
 
 /**
  * Update XML path node with data from path object, commit changes with undo.
  */
-static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key)
+static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key, const gchar *annotation)
 {
-    update_repr_internal(np);
-    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);
-    }
+    update_repr_internal(np);
+    sp_document_maybe_done(sp_desktop_document(np->desktop), key, SP_VERB_CONTEXT_NODE, 
+                           annotation);
 }
 
 /**
@@ -540,7 +546,8 @@ static void stamp_repr(Inkscape::NodePath::Path *np)
     // move to the saved position
     new_repr->setPosition(pos > 0 ? pos : 0);
 
-    sp_document_done(sp_desktop_document(np->desktop));
+    sp_document_done(sp_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE,
+                     _("Stamp"));
 
     Inkscape::GC::release(new_repr);
     g_free(svgpath);
@@ -656,7 +663,7 @@ static gchar *create_typestr(Inkscape::NodePath::Path *np)
 }
 
 /**
- * Returns current path in context.
+ * Returns current path in context. // later eliminate this function at all!
  */
 static Inkscape::NodePath::Path *sp_nodepath_current()
 {
@@ -670,7 +677,7 @@ static Inkscape::NodePath::Path *sp_nodepath_current()
         return NULL;
     }
 
-    return SP_NODE_CONTEXT(event_context)->nodepath;
+    return SP_NODE_CONTEXT(event_context)->shape_editor->get_nodepath();
 }
 
 
@@ -983,7 +990,7 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
     }
 
     for (GList *l = nodepath->selected; l != NULL; l = l->next) {
-       Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+        Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
         sp_node_moveto(n, n->pos + best_pt);
     }
 
@@ -997,11 +1004,23 @@ curve; the parameter alpha determines how blunt (alpha > 1) or sharp (alpha < 1)
 near x = 0.
  */
 double
-sculpt_profile (double x, double alpha)
+sculpt_profile (double x, double alpha, guint profile)
 {
     if (x >= 1)
         return 0;
-    return (0.5 * cos (M_PI * (pow(x, alpha))) + 0.5);
+    if (x <= 0)
+        return 1;
+
+    switch (profile) {
+        case SCULPT_PROFILE_LINEAR:
+        return 1 - x;
+        case SCULPT_PROFILE_BELL:
+        return (0.5 * cos (M_PI * (pow(x, alpha))) + 0.5);
+        case SCULPT_PROFILE_ELLIPTIC:
+        return sqrt(1 - x*x);
+    }
+
+    return 1;
 }
 
 double
@@ -1044,6 +1063,8 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
     if (pressure > 0.5)
         alpha = 1/alpha;
 
+    guint profile = prefs_get_int_attribute("tools.nodes", "sculpting_profile", SCULPT_PROFILE_BELL);
+
     if (sp_nodepath_selection_get_subpath_count(nodepath) <= 1) {
         // Only one subpath has selected nodes:
         // use linear mode, where the distance from n to node being dragged is calculated along the path
@@ -1112,9 +1133,9 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
                     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, 
-                                                           sculpt_profile (n_range / n_sel_range, alpha) * delta,
-                                                           sculpt_profile ((n_range + NR::L2(n_node->n.origin - n_node->origin)) / n_sel_range, alpha) * delta,
-                                                           sculpt_profile ((n_range - NR::L2(n_node->p.origin - n_node->origin)) / n_sel_range, alpha) * delta);
+                                                           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);
                     }
                     if (n_node == p_node) {
                         n_going = false;
@@ -1129,9 +1150,9 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
                     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, 
-                                                           sculpt_profile (p_range / p_sel_range, alpha) * delta,
-                                                           sculpt_profile ((p_range - NR::L2(p_node->n.origin - p_node->origin)) / p_sel_range, alpha) * delta,
-                                                           sculpt_profile ((p_range + NR::L2(p_node->p.origin - p_node->origin)) / p_sel_range, alpha) * delta);
+                                                           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);
                     }
                     if (p_node == n_node) {
                         n_going = false;
@@ -1167,9 +1188,9 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
                 if (node->selected) {
                     if (direct_range > 1e-6) {
                         sp_nodepath_move_node_and_handles (node,
-                                                       sculpt_profile (NR::L2(node->origin - n->origin) / direct_range, alpha) * delta,
-                                                       sculpt_profile (NR::L2(node->n.origin - n->origin) / direct_range, alpha) * delta,
-                                                       sculpt_profile (NR::L2(node->p.origin - n->origin) / direct_range, alpha) * delta);
+                                                       sculpt_profile (NR::L2(node->origin - n->origin) / direct_range, alpha, profile) * delta,
+                                                       sculpt_profile (NR::L2(node->n.origin - n->origin) / direct_range, alpha, profile) * delta,
+                                                       sculpt_profile (NR::L2(node->p.origin - n->origin) / direct_range, alpha, profile) * delta);
                     } else {
                         sp_nodepath_move_node_and_handles (node, delta, delta, delta);
                     }
@@ -1197,11 +1218,11 @@ sp_node_selected_move(gdouble dx, gdouble dy)
     sp_nodepath_selected_nodes_move(nodepath, dx, dy, false);
 
     if (dx == 0) {
-        sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical", _("Move nodes vertically"));
     } else if (dy == 0) {
-        sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal", _("Move nodes horizontally"));
     } else {
-        sp_nodepath_update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath, _("Move nodes"));
     }
 }
 
@@ -1225,11 +1246,11 @@ sp_node_selected_move_screen(gdouble dx, gdouble dy)
     sp_nodepath_selected_nodes_move(nodepath, zdx, zdy, false);
 
     if (dx == 0) {
-        sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical", _("Move nodes vertically"));
     } else if (dy == 0) {
-        sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
+        sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal", _("Move nodes horizontally"));
     } else {
-        sp_nodepath_update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath, _("Move nodes"));
     }
 }
 
@@ -1336,6 +1357,9 @@ static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_mov
         if (node->n.other->selected) show_handles = TRUE;
     }
 
+    if (node->subpath->nodepath->show_handles == false)
+        show_handles = FALSE;
+
     sp_node_update_handle(node, -1, show_handles, fire_move_signals);
     sp_node_update_handle(node, 1, show_handles, fire_move_signals);
 }
@@ -1364,6 +1388,16 @@ static void sp_nodepath_update_handles(Inkscape::NodePath::Path *nodepath)
     }
 }
 
+void
+sp_nodepath_show_handles(bool show)
+{
+    Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
+    if (nodepath == NULL) return;
+
+    nodepath->show_handles = show;
+    sp_nodepath_update_handles(nodepath);
+}
+
 /**
  * Adds all selected nodes in nodepath to list.
  */
@@ -1395,7 +1429,7 @@ void sp_nodepath_selected_align(Inkscape::NodePath::Path *nodepath, NR::Dim2 axi
         }
     }
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Align nodes"));
 }
 
 /// Helper struct.
@@ -1457,7 +1491,7 @@ void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, NR::Dim
         pos += step;
     }
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Distribute nodes"));
 }
 
 
@@ -1474,6 +1508,8 @@ sp_node_selected_add_node(void)
 
     GList *nl = NULL;
 
+    int n_added = 0;
+
     for (GList *l = nodepath->selected; l != NULL; l = l->next) {
        Inkscape::NodePath::Node *t = (Inkscape::NodePath::Node *) l->data;
         g_assert(t->selected);
@@ -1485,14 +1521,19 @@ sp_node_selected_add_node(void)
     while (nl) {
        Inkscape::NodePath::Node *t = (Inkscape::NodePath::Node *) nl->data;
        Inkscape::NodePath::Node *n = sp_nodepath_line_add_node(t, 0.5);
-        sp_nodepath_node_select(n, TRUE, FALSE);
-        nl = g_list_remove(nl, t);
+       sp_nodepath_node_select(n, TRUE, FALSE);
+       n_added ++;
+       nl = g_list_remove(nl, t);
     }
 
     /** \todo fixme: adjust ? */
     sp_nodepath_update_handles(nodepath);
 
-    sp_nodepath_update_repr(nodepath);
+    if (n_added > 1) {
+        sp_nodepath_update_repr(nodepath, _("Add nodes"));
+    } else if (n_added > 0) {
+        sp_nodepath_update_repr(nodepath, _("Add node"));
+    }
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1507,11 +1548,15 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po
         return;
     }
 
+    sp_nodepath_ensure_livarot_path(nodepath);
     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);
 
+    //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;
@@ -1535,6 +1580,7 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
         return;
     }
 
+    sp_nodepath_ensure_livarot_path(nodepath);
     Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
 
     //find segment to split
@@ -1550,7 +1596,7 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
     /* fixme: adjust ? */
     sp_nodepath_update_handles(nodepath);
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Add node"));
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1563,8 +1609,14 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
  * cf. app/vectors/gimpbezierstroke.c, gimp_bezier_stroke_point_move_relative()
  */
 void
-sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
+sp_nodepath_curve_drag(int node, double t, NR::Point delta)
 {
+    Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(node);
+
+    //fixme: e and e->p can be NULL, so check for those before proceeding
+    g_return_if_fail(e != NULL);
+    g_return_if_fail(&e->p != NULL);
+    
     /* feel good is an arbitrary parameter that distributes the delta between handles
      * if t of the drag point is less than 1/6 distance form the endpoint only
      * the corresponding hadle is adjusted. This matches the behavior in GIMP
@@ -1626,7 +1678,7 @@ void sp_node_selected_break()
 
     sp_nodepath_update_handles(nodepath);
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Break path"));
 }
 
 /**
@@ -1656,7 +1708,7 @@ void sp_node_selected_duplicate()
 
     sp_nodepath_update_handles(nodepath);
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Duplicate node"));
 }
 
 /**
@@ -1676,8 +1728,11 @@ void sp_node_selected_join()
    Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
 
     g_assert(a != b);
-    g_assert(a->p.other || a->n.other);
-    g_assert(b->p.other || b->n.other);
+    if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) { 
+        // someone tried to join an orphan node (i.e. a single-node subpath).
+        // this is not worth an error message, just fail silently.
+        return;
+    }
 
     if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
         nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
@@ -1701,7 +1756,7 @@ void sp_node_selected_join()
         sp_node_moveto (sp->first, c);
 
         sp_nodepath_update_handles(sp->nodepath);
-        sp_nodepath_update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath, _("Close subpath"));
         return;
     }
 
@@ -1753,7 +1808,7 @@ void sp_node_selected_join()
 
     sp_nodepath_update_handles(sa->nodepath);
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Join nodes"));
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -1775,8 +1830,11 @@ void sp_node_selected_join_segment()
    Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
 
     g_assert(a != b);
-    g_assert(a->p.other || a->n.other);
-    g_assert(b->p.other || b->n.other);
+    if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) { 
+        // someone tried to join an orphan node (i.e. a single-node subpath).
+        // this is not worth an error message, just fail silently.
+        return;
+    }
 
     if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
         nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
@@ -1800,7 +1858,7 @@ void sp_node_selected_join_segment()
 
         sp_nodepath_update_handles(sp->nodepath);
 
-        sp_nodepath_update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath, _("Close subpath by segment"));
 
         return;
     }
@@ -1854,7 +1912,7 @@ void sp_node_selected_join_segment()
 
     sp_nodepath_update_handles(sa->nodepath);
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Join nodes by segment"));
 }
 
 /**
@@ -1896,7 +1954,7 @@ void sp_node_delete_preserve(GList *nodes_to_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) {
+                if (!sp->closed && curr == sp->last) {
                     just_delete = true;
                     break;
                 }
@@ -1936,6 +1994,12 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
             gint ret;
             ret = sp_bezier_fit_cubic (bez, adata, data.size(), error);
 
+            //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);
+            
             //adjust endpoints
             sample_cursor->n.pos = bez[1];
             sample_end->p.pos = bez[2];
@@ -1975,9 +2039,10 @@ void sp_node_delete_preserve(GList *nodes_to_delete)
             //delete this nodepath's object, not the entire selection! (though at this time, this
             //does not matter)
             sp_selection_delete();
-            sp_document_done (document);
+            sp_document_done (document, SP_VERB_CONTEXT_NODE,
+                              _("Delete nodes"));
         } else {
-            sp_nodepath_update_repr(nodepath);
+            sp_nodepath_update_repr(nodepath, _("Delete nodes preserving shape"));
             sp_nodepath_update_statusbar(nodepath);
         }
     }
@@ -2011,11 +2076,12 @@ void sp_node_selected_delete()
         sp_nodepath_get_node_count(nodepath) < 2) {
         SPDocument *document = sp_desktop_document (nodepath->desktop);
         sp_selection_delete();
-        sp_document_done (document);
+        sp_document_done (document, SP_VERB_CONTEXT_NODE, 
+                          _("Delete nodes"));
         return;
     }
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Delete nodes"));
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -2154,7 +2220,10 @@ sp_node_selected_delete_segment(void)
         //Copy everything after 'end' to a new subpath
        Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(nodepath);
         for (curr=end ; curr ; curr=curr->n.other) {
-            sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)curr->type, (NRPathcode)curr->code,
+            NRPathcode code = (NRPathcode) curr->code;
+            if (curr == end)
+                code = NR_MOVETO;
+            sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)curr->type, code,
                                  &curr->p.pos, &curr->pos, &curr->n.pos);
         }
 
@@ -2174,7 +2243,7 @@ sp_node_selected_delete_segment(void)
 
     sp_nodepath_update_handles(nodepath);
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Delete segment"));
 
     sp_nodepath_update_statusbar(nodepath);
 }
@@ -2196,7 +2265,7 @@ sp_node_selected_set_line_type(NRPathcode code)
         }
     }
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Change segment type"));
 }
 
 /**
@@ -2212,7 +2281,7 @@ sp_node_selected_set_type(Inkscape::NodePath::NodeType type)
         sp_nodepath_convert_node_type((Inkscape::NodePath::Node *) l->data, type);
     }
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Change node type"));
 }
 
 /**
@@ -2481,6 +2550,146 @@ void sp_nodepath_select_rect(Inkscape::NodePath::Path *nodepath, NR::Rect const
 }
 
 
+void
+nodepath_grow_selection_linearly (Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, int grow)
+{
+    g_assert (n);
+    g_assert (nodepath);
+    g_assert (n->subpath->nodepath == nodepath);
+
+    if (g_list_length (nodepath->selected) == 0) {
+        if (grow > 0) {
+            sp_nodepath_node_select(n, TRUE, TRUE);
+        }
+        return;
+    }
+
+    if (g_list_length (nodepath->selected) == 1) {
+        if (grow < 0) {
+            sp_nodepath_deselect (nodepath);
+            return;
+        }
+    }
+
+        double n_sel_range = 0, p_sel_range = 0;
+            Inkscape::NodePath::Node *farthest_n_node = n;
+            Inkscape::NodePath::Node *farthest_p_node = n;
+
+        // Calculate ranges
+        {
+            double n_range = 0, p_range = 0;
+            bool n_going = true, p_going = true;
+            Inkscape::NodePath::Node *n_node = n;
+            Inkscape::NodePath::Node *p_node = n;
+            do {
+                // Do one step in both directions from n, until reaching the end of subpath or bumping into each other
+                if (n_node && n_going)
+                    n_node = n_node->n.other;
+                if (n_node == NULL) {
+                    n_going = false;
+                } else {
+                    n_range += bezier_length (n_node->p.other->pos, n_node->p.other->n.pos, n_node->p.pos, n_node->pos);
+                    if (n_node->selected) {
+                        n_sel_range = n_range;
+                        farthest_n_node = n_node;
+                    }
+                    if (n_node == p_node) {
+                        n_going = false;
+                        p_going = false;
+                    }
+                }
+                if (p_node && p_going)
+                    p_node = p_node->p.other;
+                if (p_node == NULL) {
+                    p_going = false;
+                } else {
+                    p_range += bezier_length (p_node->n.other->pos, p_node->n.other->p.pos, p_node->n.pos, p_node->pos);
+                    if (p_node->selected) {
+                        p_sel_range = p_range;
+                        farthest_p_node = p_node;
+                    }
+                    if (p_node == n_node) {
+                        n_going = false;
+                        p_going = false;
+                    }
+                }
+            } while (n_going || p_going);
+        }
+
+    if (grow > 0) {
+        if (n_sel_range < p_sel_range && farthest_n_node && farthest_n_node->n.other && !(farthest_n_node->n.other->selected)) {
+                sp_nodepath_node_select(farthest_n_node->n.other, TRUE, TRUE);
+        } else if (farthest_p_node && farthest_p_node->p.other && !(farthest_p_node->p.other->selected)) {
+                sp_nodepath_node_select(farthest_p_node->p.other, TRUE, TRUE);
+        }
+    } else {
+        if (n_sel_range > p_sel_range && farthest_n_node && farthest_n_node->selected) {
+                sp_nodepath_node_select(farthest_n_node, TRUE, FALSE);
+        } else if (farthest_p_node && farthest_p_node->selected) {
+                sp_nodepath_node_select(farthest_p_node, TRUE, FALSE);
+        }
+    }
+}
+
+void
+nodepath_grow_selection_spatially (Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, int grow)
+{
+    g_assert (n);
+    g_assert (nodepath);
+    g_assert (n->subpath->nodepath == nodepath);
+
+    if (g_list_length (nodepath->selected) == 0) {
+        if (grow > 0) {
+            sp_nodepath_node_select(n, TRUE, TRUE);
+        }
+        return;
+    }
+
+    if (g_list_length (nodepath->selected) == 1) {
+        if (grow < 0) {
+            sp_nodepath_deselect (nodepath);
+            return;
+        }
+    }
+
+    Inkscape::NodePath::Node *farthest_selected = NULL;
+    double farthest_dist = 0;
+
+    Inkscape::NodePath::Node *closest_unselected = NULL;
+    double closest_dist = NR_HUGE;
+
+    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 == n)
+               continue;
+           if (node->selected) {
+               if (NR::L2(node->pos - n->pos) > farthest_dist) {
+                   farthest_dist = NR::L2(node->pos - n->pos);
+                   farthest_selected = node;
+               }
+           } else {
+               if (NR::L2(node->pos - n->pos) < closest_dist) {
+                   closest_dist = NR::L2(node->pos - n->pos);
+                   closest_unselected = node;
+               }
+           }
+        }
+    }
+
+    if (grow > 0) {
+        if (closest_unselected) {
+            sp_nodepath_node_select(closest_unselected, TRUE, TRUE);
+        }
+    } else {
+        if (farthest_selected) {
+            sp_nodepath_node_select(farthest_selected, TRUE, FALSE);
+        }
+    }
+}
+
+
 /**
 \brief  Saves all nodes' and handles' current positions in their origin members
 */
@@ -2657,7 +2866,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) {
@@ -2667,6 +2876,33 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Nod
         case GDK_LEAVE_NOTIFY:
             active_node = NULL;
             break;
+        case GDK_SCROLL:
+            if ((event->scroll.state & GDK_CONTROL_MASK) && !(event->scroll.state & GDK_SHIFT_MASK)) { // linearly
+                switch (event->scroll.direction) {
+                    case GDK_SCROLL_UP:
+                        nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+                        break;
+                    case GDK_SCROLL_DOWN:
+                        nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+                        break;
+                    default:
+                        break;
+                }
+                ret = TRUE;
+            } else if (!(event->scroll.state & GDK_SHIFT_MASK)) { // spatially
+                switch (event->scroll.direction) {
+                    case GDK_SCROLL_UP:
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+                        break;
+                    case GDK_SCROLL_DOWN:
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+                        break;
+                    default:
+                        break;
+                }
+                ret = TRUE;
+            }
+            break;
         case GDK_KEY_PRESS:
             switch (get_group0_keyval (&event->key)) {
                 case GDK_space:
@@ -2676,6 +2912,20 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Nod
                         ret = TRUE;
                     }
                     break;
+                case GDK_Page_Up:
+                    if (event->key.state & GDK_CONTROL_MASK) {
+                        nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+                    } else {
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+                    }
+                    break;
+                case GDK_Page_Down:
+                    if (event->key.state & GDK_CONTROL_MASK) {
+                        nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+                    } else {
+                        nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+                    }
+                    break;
                 default:
                     break;
             }
@@ -2704,7 +2954,7 @@ gboolean node_key(GdkEvent *event)
             case GDK_BackSpace:
                 np = active_node->subpath->nodepath;
                 sp_nodepath_node_destroy(active_node);
-                sp_nodepath_update_repr(np);
+                sp_nodepath_update_repr(np, _("Delete node"));
                 active_node = NULL;
                 ret = TRUE;
                 break;
@@ -2748,7 +2998,7 @@ static void node_clicked(SPKnot *knot, guint state, gpointer data)
             } else {
                 sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_CUSP);
             }
-            sp_nodepath_update_repr(nodepath);
+            sp_nodepath_update_repr(nodepath, _("Change node type"));
             sp_nodepath_update_statusbar(nodepath);
 
         } else { //ctrl+alt+click: delete node
@@ -2773,6 +3023,9 @@ static void node_grabbed(SPKnot *knot, guint state, gpointer data)
         sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE);
     }
 
+    n->is_dragging = true;
+    sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5);
+
     sp_nodepath_remember_origins (n->subpath->nodepath);
 }
 
@@ -2784,8 +3037,10 @@ static void node_ungrabbed(SPKnot *knot, guint state, gpointer data)
    Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
 
    n->dragging_out = NULL;
+   n->is_dragging = false;
+   sp_canvas_end_forced_full_redraws(n->subpath->nodepath->desktop->canvas);
 
-   sp_nodepath_update_repr(n->subpath->nodepath);
+   sp_nodepath_update_repr(n->subpath->nodepath, _("Move nodes"));
 }
 
 /**
@@ -2905,8 +3160,8 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
         if ((n->n.other && n->n.other->code == NR_LINETO) || fabs(yn) + fabs(xn) < 1e-6) {
             if (n->n.other) { // if there is the next point
                 if (L2(n->n.other->p.pos - n->n.other->pos) < 1e-6) // and the next point has no handle either
-                    yn = n->n.other->pos[NR::Y] - n->origin[NR::Y]; // use origin because otherwise the direction will change as you drag
-                    xn = n->n.other->pos[NR::X] - n->origin[NR::X];
+                    yn = n->n.other->origin[NR::Y] - n->origin[NR::Y]; // use origin because otherwise the direction will change as you drag
+                    xn = n->n.other->origin[NR::X] - n->origin[NR::X];
             }
         }
         if (xn < 0) { xn = -xn; yn = -yn; } // limit the angle to between 0 and pi
@@ -2919,8 +3174,8 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
         if (n->code == NR_LINETO || fabs(yp) + fabs(xp) < 1e-6) {
             if (n->p.other) {
                 if (L2(n->p.other->n.pos - n->p.other->pos) < 1e-6)
-                    yp = n->p.other->pos[NR::Y] - n->origin[NR::Y];
-                    xp = n->p.other->pos[NR::X] - n->origin[NR::X];
+                    yp = n->p.other->origin[NR::Y] - n->origin[NR::Y];
+                    xp = n->p.other->origin[NR::X] - n->origin[NR::X];
             }
         }
         if (xp < 0) { xp = -xp; yp = -yp; } // limit the angle to between 0 and pi
@@ -2986,14 +3241,16 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
             }
         }
     } else { // move freely
-        if (state & GDK_MOD1_MASK) { // sculpt
-            sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, (*p) - n->origin);
-        } else {
-            sp_nodepath_selected_nodes_move(n->subpath->nodepath,
-                                        (*p)[NR::X] - n->pos[NR::X],
-                                        (*p)[NR::Y] - n->pos[NR::Y],
-                                        (state & GDK_SHIFT_MASK) == 0);
-	}
+        if (n->is_dragging) {
+            if (state & GDK_MOD1_MASK) { // sculpt
+                sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, (*p) - n->origin);
+            } else {
+                sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+                                            (*p)[NR::X] - n->pos[NR::X],
+                                            (*p)[NR::Y] - n->pos[NR::Y],
+                                            (state & GDK_SHIFT_MASK) == 0);
+            }
+        }
     }
 
     n->subpath->nodepath->desktop->scroll_to_point(p);
@@ -3016,7 +3273,7 @@ static void node_handle_clicked(SPKnot *knot, guint state, gpointer data)
         }
         sp_node_update_handles(n);
         Inkscape::NodePath::Path *nodepath = n->subpath->nodepath;
-        sp_nodepath_update_repr(nodepath);
+        sp_nodepath_update_repr(nodepath, _("Retract handle"));
         sp_nodepath_update_statusbar(nodepath);
 
     } else { // just select or add to selection, depending in Shift
@@ -3044,6 +3301,7 @@ static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data)
         g_assert_not_reached();
     }
 
+    sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5);
 }
 
 /**
@@ -3064,7 +3322,7 @@ static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data)
         g_assert_not_reached();
     }
 
-    sp_nodepath_update_repr(n->subpath->nodepath);
+    sp_nodepath_update_repr(n->subpath->nodepath, _("Move node handle"));
 }
 
 /**
@@ -3382,7 +3640,7 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
         }
     }
 
-    sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n");
+    sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n", _("Rotate nodes"));
 }
 
 /**
@@ -3507,7 +3765,7 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
         }
     }
 
-    sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n");
+    sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n", _("Scale nodes"));
 }
 
 void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath, gdouble const grow, int const which)
@@ -3554,7 +3812,7 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
         }
     }
 
-    sp_nodepath_update_repr(nodepath);
+    sp_nodepath_update_repr(nodepath, _("Flip nodes"));
 }
 
 //-----------------------------------------------
@@ -3765,11 +4023,34 @@ static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node)
 
     node->subpath->nodes = g_list_remove(node->subpath->nodes, node);
 
+    g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_event), node);
+    g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_clicked), node);
+    g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_grabbed), node);
+    g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_ungrabbed), node);
+    g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_request), node);
     g_object_unref(G_OBJECT(node->knot));
-    if (node->p.knot)
+
+    if (node->p.knot) {
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_clicked), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_grabbed), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_ungrabbed), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_request), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_moved), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_event), node);
         g_object_unref(G_OBJECT(node->p.knot));
-    if (node->n.knot)
+        node->p.knot = NULL;
+    }
+
+    if (node->n.knot) {
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_clicked), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_grabbed), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_ungrabbed), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_request), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_moved), node);
+        g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_event), node);
         g_object_unref(G_OBJECT(node->n.knot));
+        node->n.knot = NULL;
+    }
 
     if (node->p.line)
         gtk_object_destroy(GTK_OBJECT(node->p.line));
@@ -3953,7 +4234,7 @@ static gchar const *sp_node_type_description(Inkscape::NodePath::Node *node)
  * Handles content of statusbar as long as node tool is active.
  */
 void
-sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)
+sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to ShapeEditorsCollection
 {
     gchar const *when_selected = _("<b>Drag</b> nodes or node handles; <b>Alt+drag</b> nodes to sculpt; <b>arrow</b> keys to move nodes, <b>&lt; &gt;</b> to scale, <b>[ ]</b> to rotate");
     gchar const *when_selected_one = _("<b>Drag</b> the node or its handles; <b>arrow</b> keys to move the node");