X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fnodepath.cpp;h=0ad4c66a030c190776b9c53cc158dd6c1ea7ae5e;hb=ad4b3133547bb79aa1362ab40512d31267868c82;hp=e81abdacbd4e73bff87c71e7f28834df7880d282;hpb=09f5ae2dc48630fe49482e0cf7b21eda1f3b765b;p=inkscape.git diff --git a/src/nodepath.cpp b/src/nodepath.cpp index e81abdacb..0ad4c66a0 100644 --- a/src/nodepath.cpp +++ b/src/nodepath.cpp @@ -7,7 +7,7 @@ * Lauris Kaplinski * bulia byak * - * This code is in public domain + * Portions of this code are in public domain; node sculpting functions written by bulia byak are under GNU GPL */ #ifdef HAVE_CONFIG_H @@ -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 #include @@ -97,6 +99,8 @@ static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean inc static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean selected); +static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type); + /* Adjust handle placement, if the node or the other handle is moved */ static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust); static void sp_node_adjust_handles(Inkscape::NodePath::Node *node); @@ -132,12 +136,12 @@ static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::N static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me); // active_node indicates mouseover node -static Inkscape::NodePath::Node *active_node = NULL; +Inkscape::NodePath::Node * Inkscape::NodePath::Path::active_node = NULL; /** * \brief Creates new nodepath from item */ -Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item) +Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item, bool show_handles) { Inkscape::XML::Node *repr = SP_OBJECT(item)->repr; @@ -183,9 +187,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 +214,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 +231,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 +248,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. */ @@ -271,7 +284,51 @@ static gint sp_nodepath_get_node_count(Inkscape::NodePath::Path *np) return nodeCount; } +/** + * Return the subpath count of a given NodePath. + */ +static gint sp_nodepath_get_subpath_count(Inkscape::NodePath::Path *np) +{ + if (!np) + return 0; + return g_list_length (np->subpaths); +} + +/** + * Return the selected node count of a given NodePath. + */ +static gint sp_nodepath_selection_get_node_count(Inkscape::NodePath::Path *np) +{ + if (!np) + return 0; + return g_list_length (np->selected); +} +/** + * Return the number of subpaths where nodes are selected in a given NodePath. + */ +static gint sp_nodepath_selection_get_subpath_count(Inkscape::NodePath::Path *np) +{ + if (!np) + return 0; + if (!np->selected) + return 0; + if (!np->selected->next) + return 1; + gint count = 0; + for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) { + Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data; + for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) { + Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data; + if (node->selected) { + count ++; + break; + } + } + } + return count; +} + /** * Clean up a nodepath after editing. * @@ -281,10 +338,10 @@ static void sp_nodepath_cleanup(Inkscape::NodePath::Path *nodepath) { GList *badSubPaths = NULL; - //Check all subpaths to be >=2 nodes + //Check all closed subpaths to be >=1 nodes, all open subpaths to be >= 2 nodes for (GList *l = nodepath->subpaths; l ; l=l->next) { Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *)l->data; - if (sp_nodepath_subpath_get_node_count(sp)<2) + if ((sp_nodepath_subpath_get_node_count(sp)<2 && !sp->closed) || (sp_nodepath_subpath_get_node_count(sp)<1 && sp->closed)) badSubPaths = g_list_append(badSubPaths, sp); } @@ -411,7 +468,7 @@ 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)); if (repr->attribute("d") == NULL || strcmp(svgpath, repr->attribute("d"))) { // d changed np->local_change++; @@ -431,41 +488,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); } /** @@ -476,7 +528,7 @@ static void stamp_repr(Inkscape::NodePath::Path *np) g_assert(np); Inkscape::XML::Node *old_repr = SP_OBJECT(np->path)->repr; - Inkscape::XML::Node *new_repr = old_repr->duplicate(); + Inkscape::XML::Node *new_repr = old_repr->duplicate(old_repr->document()); // remember the position of the item gint pos = old_repr->position(); @@ -486,7 +538,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); @@ -496,7 +548,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); @@ -612,7 +665,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() { @@ -626,7 +679,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(); } @@ -647,7 +700,7 @@ static void sp_nodepath_line_midpoint(Inkscape::NodePath::Node *new_path,Inkscap if (end->code == NR_LINETO) { new_path->type =Inkscape::NodePath::NODE_CUSP; new_path->code = NR_LINETO; - new_path->pos = (t * start->pos + (1 - t) * end->pos); + new_path->pos = new_path->n.pos = new_path->p.pos = (t * start->pos + (1 - t) * end->pos); } else { new_path->type =Inkscape::NodePath::NODE_SMOOTH; new_path->code = NR_CURVETO; @@ -686,13 +739,16 @@ static Inkscape::NodePath::Node *sp_nodepath_line_add_node(Inkscape::NodePath::N g_assert( start->n.other == end ); Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(end->subpath, end, - Inkscape::NodePath::NODE_SMOOTH, + (NRPathcode)end->code == NR_LINETO? + Inkscape::NodePath::NODE_CUSP : Inkscape::NodePath::NODE_SMOOTH, (NRPathcode)end->code, &start->pos, &start->pos, &start->n.pos); sp_nodepath_line_midpoint(newnode, end, t); + sp_node_adjust_handles(start); sp_node_update_handles(start); sp_node_update_handles(newnode); + sp_node_adjust_handles(end); sp_node_update_handles(end); return newnode; @@ -788,12 +844,14 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode end->code = code; if (code == NR_LINETO) { - if (start->code == NR_LINETO) start->type =Inkscape::NodePath::NODE_CUSP; + if (start->code == NR_LINETO) { + sp_nodepath_set_node_type (start, Inkscape::NodePath::NODE_CUSP); + } if (end->n.other) { - if (end->n.other->code == NR_LINETO) end->type =Inkscape::NodePath::NODE_CUSP; + if (end->n.other->code == NR_LINETO) { + sp_nodepath_set_node_type (end, Inkscape::NodePath::NODE_CUSP); + } } - sp_node_adjust_handle(start, -1); - sp_node_adjust_handle(end, 1); } else { NR::Point delta = end->pos - start->pos; start->n.pos = start->pos + delta / 3; @@ -857,28 +915,28 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N */ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type) { + bool p_line = (node->p.other != NULL) && (node->code == NR_LINETO || node->pos == node->p.pos); + bool n_line = (node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos); + if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) { - if ((node->p.other != NULL) && (node->code == NR_LINETO || node->pos == node->p.pos)) { - // convert adjacent segment BEFORE to curve + if (p_line && n_line) { + // only if both adjacent segments are lines, + // convert both to curves: + + // BEFORE: + { node->code = NR_CURVETO; - NR::Point delta; - if (node->n.other != NULL) - delta = node->n.other->pos - node->p.other->pos; - else - delta = node->pos - node->p.other->pos; + NR::Point delta = node->n.other->pos - node->p.other->pos; node->p.pos = node->pos - delta / 4; - sp_node_update_handles(node); - } + } - if ((node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos)) { - // convert adjacent segment AFTER to curve + // AFTER: + { node->n.other->code = NR_CURVETO; - NR::Point delta; - if (node->p.other != NULL) - delta = node->p.other->pos - node->n.other->pos; - else - delta = node->pos - node->n.other->pos; + NR::Point delta = node->p.other->pos - node->n.other->pos; node->n.pos = node->pos - delta / 4; + } + sp_node_update_handles(node); } } @@ -897,22 +955,33 @@ void sp_node_moveto(Inkscape::NodePath::Node *node, NR::Point p) node->p.pos += delta; node->n.pos += delta; + Inkscape::NodePath::Node *node_p = NULL; + Inkscape::NodePath::Node *node_n = NULL; + if (node->p.other) { if (node->code == NR_LINETO) { sp_node_adjust_handle(node, 1); sp_node_adjust_handle(node->p.other, -1); + node_p = node->p.other; } } if (node->n.other) { if (node->n.other->code == NR_LINETO) { sp_node_adjust_handle(node, -1); sp_node_adjust_handle(node->n.other, 1); + node_n = node->n.other; } } // this function is only called from batch movers that will update display at the end // themselves, so here we just move all the knots without emitting move signals, for speed sp_node_update_handles(node, false); + if (node_n) { + sp_node_update_handles(node_n, false); + } + if (node_p) { + sp_node_update_handles(node_p, false); + } } /** @@ -930,16 +999,16 @@ 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::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAP_POINT, n->pos + delta, NULL); + Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAP_POINT, n->pos + delta, n->subpath->nodepath->path); if (s.getDistance() < best) { best = s.getDistance(); - best_pt = s.getPoint(); + best_pt = s.getPoint() - n->pos; } } } 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); } @@ -947,6 +1016,213 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, update_object(nodepath); } +/** +Function mapping x (in the range 0..1) to y (in the range 1..0) using a smooth half-bell-like +curve; the parameter alpha determines how blunt (alpha > 1) or sharp (alpha < 1) will be the curve +near x = 0. + */ +double +sculpt_profile (double x, double alpha, guint profile) +{ + if (x >= 1) + return 0; + 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 +bezier_length (NR::Point a, NR::Point ah, NR::Point bh, NR::Point b) +{ + // extremely primitive for now, don't have time to look for the real one + double lower = NR::L2(b - a); + double upper = NR::L2(ah - a) + NR::L2(bh - ah) + NR::L2(bh - b); + return (lower + upper)/2; +} + +void +sp_nodepath_move_node_and_handles (Inkscape::NodePath::Node *n, NR::Point delta, NR::Point delta_n, NR::Point delta_p) +{ + n->pos = n->origin + delta; + n->n.pos = n->n.origin + delta_n; + n->p.pos = n->p.origin + delta_p; + sp_node_adjust_handles(n); + sp_node_update_handles(n, false); +} + +/** + * Displace selected nodes and their handles by fractions of delta (from their origins), depending + * on how far they are from the dragged node n. + */ +static void +sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, NR::Point delta) +{ + g_assert (n); + g_assert (nodepath); + g_assert (n->subpath->nodepath == nodepath); + + double pressure = n->knot->pressure; + if (pressure == 0) + pressure = 0.5; // default + pressure = CLAMP (pressure, 0.2, 0.8); + + // map pressure to alpha = 1/5 ... 5 + double alpha = 1 - 2 * fabs(pressure - 0.5); + 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 + + double n_sel_range = 0, p_sel_range = 0; + guint n_nodes = 0, p_nodes = 0; + guint n_sel_nodes = 0, p_sel_nodes = 0; + + // First pass: calculate ranges (TODO: we could cache them, as they don't change while dragging) + { + 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_nodes ++; + 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) { + n_sel_nodes ++; + n_sel_range = n_range; + } + 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_nodes ++; + 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) { + p_sel_nodes ++; + p_sel_range = p_range; + } + if (p_node == n_node) { + n_going = false; + p_going = false; + } + } + } while (n_going || p_going); + } + + // Second pass: actually move nodes in this subpath + sp_nodepath_move_node_and_handles (n, delta, delta, delta); + { + 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->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, 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; + 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->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, 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; + p_going = false; + } + } + } while (n_going || p_going); + } + + } else { + // Multiple subpaths have selected nodes: + // use spatial mode, where the distance from n to node being dragged is measured directly as NR::L2. + // TODO: correct these distances taking into account their angle relative to the bisector, so as to + // fix the pear-like shape when sculpting e.g. a ring + + // First pass: calculate range + gdouble direct_range = 0; + for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) { + Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data; + for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) { + Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data; + if (node->selected) { + direct_range = MAX(direct_range, NR::L2(node->origin - n->origin)); + } + } + } + + // Second pass: actually move nodes + for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) { + Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data; + for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) { + Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data; + if (node->selected) { + if (direct_range > 1e-6) { + sp_nodepath_move_node_and_handles (node, + 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); + } + + } + } + } + } + + // do not update repr here so that node dragging is acceptably fast + update_object(nodepath); +} + + /** * Move node selection to point, adjust its and neighbouring handles, * handle possible snapping, and commit the change with possible undo. @@ -960,11 +1236,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")); } } @@ -988,11 +1264,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")); } } @@ -1099,6 +1375,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); } @@ -1127,6 +1406,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. */ @@ -1158,7 +1447,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. @@ -1220,7 +1509,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")); } @@ -1237,6 +1526,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); @@ -1248,14 +1539,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); } @@ -1270,11 +1566,19 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po return; } - Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p); + sp_nodepath_ensure_livarot_path(nodepath); + NR::Maybe maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p); + if (!maybe_position) { + return; + } + Path::cut_position position = *maybe_position; //find segment to segment Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece); + //fixme: this can return NULL, so check before proceeding. + g_return_if_fail(e != NULL); + gboolean force = FALSE; if (!(e->selected && (!e->p.other || e->p.other->selected))) { force = TRUE; @@ -1298,7 +1602,12 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p) return; } - Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p); + sp_nodepath_ensure_livarot_path(nodepath); + NR::Maybe maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p); + if (!maybe_position) { + return; + } + Path::cut_position position = *maybe_position; //find segment to split Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece); @@ -1313,7 +1622,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); } @@ -1326,8 +1635,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 @@ -1389,7 +1704,7 @@ void sp_node_selected_break() sp_nodepath_update_handles(nodepath); - sp_nodepath_update_repr(nodepath); + sp_nodepath_update_repr(nodepath, _("Break path")); } /** @@ -1419,7 +1734,7 @@ void sp_node_selected_duplicate() sp_nodepath_update_handles(nodepath); - sp_nodepath_update_repr(nodepath); + sp_nodepath_update_repr(nodepath, _("Duplicate node")); } /** @@ -1439,8 +1754,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 two endnodes selected.")); @@ -1464,7 +1782,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; } @@ -1516,7 +1834,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); } @@ -1538,8 +1856,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 two endnodes selected.")); @@ -1563,7 +1884,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; } @@ -1617,7 +1938,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")); } /** @@ -1625,6 +1946,7 @@ void sp_node_selected_join_segment() */ void sp_node_delete_preserve(GList *nodes_to_delete) { + GSList *nodepaths = NULL; while (nodes_to_delete) { Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node*) g_list_first(nodes_to_delete)->data; @@ -1658,7 +1980,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; } @@ -1698,6 +2020,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]; @@ -1716,28 +2044,36 @@ void sp_node_delete_preserve(GList *nodes_to_delete) sp_nodepath_node_destroy(temp); } - //clean up the nodepath (such as for trivial subpaths) - sp_nodepath_cleanup(nodepath); - sp_nodepath_update_handles(nodepath); + if (!g_slist_find(nodepaths, nodepath)) + nodepaths = g_slist_prepend (nodepaths, nodepath); + } + + for (GSList *i = nodepaths; i; i = i->next) { + // FIXME: when/if we teach node tool to have more than one nodepath, deleting nodes from + // different nodepaths will give us one undo event per nodepath + Inkscape::NodePath::Path *nodepath = (Inkscape::NodePath::Path *) i->data; + // if the entire nodepath is removed, delete the selected object. if (nodepath->subpaths == NULL || + //FIXME: a closed path CAN legally have one node, it's only an open one which must be + //at least 2 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? + //FIXME: The following line will be wrong when we have mltiple nodepaths: we only want to + //delete this nodepath's object, not the entire selection! (though at this time, this + //does not matter) sp_selection_delete(); - sp_document_done (document); - return; + sp_document_done (document, SP_VERB_CONTEXT_NODE, + _("Delete nodes")); + } else { + sp_nodepath_update_repr(nodepath, _("Delete nodes preserving shape")); + sp_nodepath_update_statusbar(nodepath); } - - sp_nodepath_update_repr(nodepath); - - sp_nodepath_update_statusbar(nodepath); } + + g_slist_free (nodepaths); } /** @@ -1765,13 +2101,13 @@ void sp_node_selected_delete() if (nodepath->subpaths == NULL || sp_nodepath_get_node_count(nodepath) < 2) { SPDocument *document = sp_desktop_document (nodepath->desktop); - sp_nodepath_destroy(nodepath); 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); } @@ -1910,7 +2246,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); } @@ -1930,15 +2269,7 @@ sp_node_selected_delete_segment(void) sp_nodepath_update_handles(nodepath); - sp_nodepath_update_repr(nodepath); - - // if the entire nodepath is removed, delete the selected object. - if (nodepath->subpaths == NULL || - sp_nodepath_get_node_count(nodepath) < 2) { - sp_nodepath_destroy(nodepath); - sp_selection_delete(); - return; - } + sp_nodepath_update_repr(nodepath, _("Delete segment")); sp_nodepath_update_statusbar(nodepath); } @@ -1960,7 +2291,7 @@ sp_node_selected_set_line_type(NRPathcode code) } } - sp_nodepath_update_repr(nodepath); + sp_nodepath_update_repr(nodepath, _("Change segment type")); } /** @@ -1976,7 +2307,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")); } /** @@ -2244,6 +2575,164 @@ 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 +*/ +void +sp_nodepath_remember_origins(Inkscape::NodePath::Path *nodepath) +{ + 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 *n = (Inkscape::NodePath::Node *) nl->data; + n->origin = n->pos; + n->p.origin = n->p.pos; + n->n.origin = n->n.pos; + } + } +} + /** \brief Saves selected nodes in a nodepath into a list containing integer positions of all selected nodes */ @@ -2403,15 +2892,42 @@ static void sp_node_adjust_handles(Inkscape::NodePath::Node *node) /** * Node event callback. */ -static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n) +static gboolean node_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n) { gboolean ret = FALSE; switch (event->type) { case GDK_ENTER_NOTIFY: - active_node = n; + Inkscape::NodePath::Path::active_node = n; break; case GDK_LEAVE_NOTIFY: - active_node = NULL; + Inkscape::NodePath::Path::active_node = NULL; + break; + case GDK_SCROLL: + if ((event->scroll.state & GDK_CONTROL_MASK) && !(event->scroll.state & GDK_SHIFT_MASK)) { // linearly + switch (event->scroll.direction) { + case GDK_SCROLL_UP: + nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1); + break; + case GDK_SCROLL_DOWN: + nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1); + break; + default: + break; + } + ret = TRUE; + } else if (!(event->scroll.state & GDK_SHIFT_MASK)) { // spatially + switch (event->scroll.direction) { + case GDK_SCROLL_UP: + nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1); + break; + case GDK_SCROLL_DOWN: + nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1); + break; + default: + break; + } + ret = TRUE; + } break; case GDK_KEY_PRESS: switch (get_group0_keyval (&event->key)) { @@ -2422,6 +2938,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; } @@ -2441,33 +2971,33 @@ gboolean node_key(GdkEvent *event) Inkscape::NodePath::Path *np; // there is no way to verify nodes so set active_node to nil when deleting!! - if (active_node == NULL) return FALSE; + if (Inkscape::NodePath::Path::active_node == NULL) return FALSE; if ((event->type == GDK_KEY_PRESS) && !(event->key.state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK))) { gint ret = FALSE; switch (get_group0_keyval (&event->key)) { /// \todo FIXME: this does not seem to work, the keys are stolen by tool contexts! case GDK_BackSpace: - np = active_node->subpath->nodepath; - sp_nodepath_node_destroy(active_node); - sp_nodepath_update_repr(np); - active_node = NULL; + np = Inkscape::NodePath::Path::active_node->subpath->nodepath; + sp_nodepath_node_destroy(Inkscape::NodePath::Path::active_node); + sp_nodepath_update_repr(np, _("Delete node")); + Inkscape::NodePath::Path::active_node = NULL; ret = TRUE; break; case GDK_c: - sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_CUSP); + sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_CUSP); ret = TRUE; break; case GDK_s: - sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_SMOOTH); + sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SMOOTH); ret = TRUE; break; case GDK_y: - sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_SYMM); + sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SYMM); ret = TRUE; break; case GDK_b: - sp_nodepath_node_break(active_node); + sp_nodepath_node_break(Inkscape::NodePath::Path::active_node); ret = TRUE; break; } @@ -2494,7 +3024,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 @@ -2515,11 +3045,14 @@ static void node_grabbed(SPKnot *knot, guint state, gpointer data) { Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - n->origin = knot->pos; - if (!n->selected) { 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); } /** @@ -2530,8 +3063,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")); } /** @@ -2651,8 +3186,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 @@ -2665,8 +3200,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 @@ -2698,8 +3233,6 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data) if (an == 0) na = HUGE_VAL; else na = -1/an; if (ap == 0) pa = HUGE_VAL; else pa = -1/ap; - //g_print("an %g ap %g\n", an, ap); - // mouse point relative to the node's original pos pr = (*p) - n->origin; @@ -2734,10 +3267,16 @@ node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data) } } } else { // move freely - 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); @@ -2760,7 +3299,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 @@ -2781,13 +3320,14 @@ static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data) // remember the origin point of the handle if (n->p.knot == knot) { - n->p.origin = n->p.pos - n->pos; + n->p.origin_radial = n->p.pos - n->pos; } else if (n->n.knot == knot) { - n->n.origin = n->n.pos - n->pos; + n->n.origin_radial = n->n.pos - n->pos; } else { g_assert_not_reached(); } + sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5); } /** @@ -2799,16 +3339,16 @@ static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data) // forget origin and set knot position once more (because it can be wrong now due to restrictions) if (n->p.knot == knot) { - n->p.origin.a = 0; + n->p.origin_radial.a = 0; sp_knot_set_position(knot, &n->p.pos, state); } else if (n->n.knot == knot) { - n->n.origin.a = 0; + n->n.origin_radial.a = 0; sp_knot_set_position(knot, &n->n.pos, state); } else { g_assert_not_reached(); } - sp_nodepath_update_repr(n->subpath->nodepath); + sp_nodepath_update_repr(n->subpath->nodepath, _("Move node handle")); } /** @@ -2891,13 +3431,13 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer // 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) { + if (me->origin_radial.a == HUGE_VAL) { // ortho doesn't exist: original handle was zero length. rnew.a = a_snapped; } else { /* The closest PI/2 angle, starting from original angle (i.e. snapping to original, * its opposite and perpendiculars). */ - double const a_ortho = me->origin.a + floor((rnew.a - me->origin.a)/(M_PI/2) + 0.5) * (M_PI/2); + double const a_ortho = me->origin_radial.a + floor((rnew.a - me->origin_radial.a)/(M_PI/2) + 0.5) * (M_PI/2); // Snap to the closest. rnew.a = ( fabs(a_snapped - rnew.a) < fabs(a_ortho - rnew.a) @@ -2908,26 +3448,26 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer if (state & GDK_MOD1_MASK) { // lock handle length - rnew.r = me->origin.r; + rnew.r = me->origin_radial.r; } if (( n->type !=Inkscape::NodePath::NODE_CUSP || (state & GDK_SHIFT_MASK)) - && rme.a != HUGE_VAL && rnew.a != HUGE_VAL && fabs(rme.a - rnew.a) > 0.001) { + && rme.a != HUGE_VAL && rnew.a != HUGE_VAL && (fabs(rme.a - rnew.a) > 0.001 || n->type ==Inkscape::NodePath::NODE_SYMM)) { // rotate the other handle correspondingly, if both old and new angles exist and are not the same rother.a += rnew.a - rme.a; other->pos = NR::Point(rother) + n->pos; - sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos); - sp_knot_set_position(other->knot, &other->pos, 0); + if (other->knot) { + sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos); + sp_knot_moveto(other->knot, &other->pos); + } } me->pos = NR::Point(rnew) + n->pos; sp_ctrlline_set_coords(SP_CTRLLINE(me->line), n->pos, me->pos); - // this is what sp_knot_set_position does, but without emitting the signal: + // move knot, but without emitting the signal: // we cannot emit a "moved" signal because we're now processing it - if (me->knot->item) SP_CTRL(me->knot->item)->moveto(me->pos); - - knot->desktop->set_coordinate_status(me->pos); + sp_knot_moveto(me->knot, &(me->pos)); update_object(n->subpath->nodepath); @@ -2973,6 +3513,16 @@ static gboolean node_handle_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePa break; } break; + case GDK_ENTER_NOTIFY: + // we use an experimentally determined threshold that seems to work fine + if (NR::L2(n->pos - knot->pos) < 0.75) + Inkscape::NodePath::Path::active_node = n; + break; + case GDK_LEAVE_NOTIFY: + // we use an experimentally determined threshold that seems to work fine + if (NR::L2(n->pos - knot->pos) < 0.75) + Inkscape::NodePath::Path::active_node = NULL; + break; default: break; } @@ -3126,7 +3676,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")); } /** @@ -3251,7 +3801,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) @@ -3263,11 +3813,11 @@ void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath, /** * Flip selected nodes horizontally/vertically. */ -void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis) +void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Maybe center) { if (!nodepath || !nodepath->selected) return; - if (g_list_length(nodepath->selected) == 1) { + if (g_list_length(nodepath->selected) == 1 && !center) { // flip handles of the single selected node Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nodepath->selected->data; double temp = n->p.pos[axis]; @@ -3284,10 +3834,13 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis) box.expandTo (n->pos); // contain all selected nodes } + if (!center) { + center = box.midpoint(); + } NR::Matrix t = - NR::Matrix (NR::translate(-box.midpoint())) * + NR::Matrix (NR::translate(- *center)) * NR::Matrix ((axis == NR::X)? NR::scale(-1, 1) : NR::scale(1, -1)) * - NR::Matrix (NR::translate(box.midpoint())); + NR::Matrix (NR::translate(*center)); for (GList *l = nodepath->selected; l != NULL; l = l->next) { Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; @@ -3298,7 +3851,7 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis) } } - sp_nodepath_update_repr(nodepath); + sp_nodepath_update_repr(nodepath, _("Flip nodes")); } //----------------------------------------------- @@ -3509,11 +4062,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)); @@ -3606,7 +4182,7 @@ static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Ink } /** - * Call sp_nodepath_line_add_node() at t on the segment denoted by piece + * Return node with the given index */ Inkscape::NodePath::Node * sp_nodepath_get_node_by_index(int index) @@ -3697,21 +4273,18 @@ 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 = _("Drag nodes or node handles; arrow keys to move nodes"); + gchar const *when_selected = _("Drag nodes or node handles; Alt+drag nodes to sculpt; arrow keys to move nodes, < > to scale, [ ] to rotate"); gchar const *when_selected_one = _("Drag the node or its handles; arrow keys to move the node"); - gint total = 0; - gint selected = 0; - SPDesktop *desktop = NULL; + gint total_nodes = sp_nodepath_get_node_count(nodepath); + gint selected_nodes = sp_nodepath_selection_get_node_count(nodepath); + gint total_subpaths = sp_nodepath_get_subpath_count(nodepath); + gint selected_subpaths = sp_nodepath_selection_get_subpath_count(nodepath); + SPDesktop *desktop = NULL; if (nodepath) { - for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) { - Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data; - total += g_list_length(subpath->nodes); - } - selected = g_list_length(nodepath->selected); desktop = nodepath->desktop; } else { desktop = SP_ACTIVE_DESKTOP; @@ -3722,7 +4295,7 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath) Inkscape::MessageContext *mc = SP_NODE_CONTEXT (ec)->_node_message_context; if (!mc) return; - if (selected == 0) { + if (selected_nodes == 0) { Inkscape::Selection *sel = desktop->selection; if (!sel || sel->isEmpty()) { mc->setF(Inkscape::NORMAL_MESSAGE, @@ -3732,8 +4305,8 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath) mc->setF(Inkscape::NORMAL_MESSAGE, ngettext("0 out of %i node selected. Click, Shift+click, or drag around nodes to select.", "0 out of %i nodes selected. Click, Shift+click, or drag around nodes to select.", - total), - total); + total_nodes), + total_nodes); } else { if (g_slist_length((GSList *)sel->itemList()) == 1) { mc->setF(Inkscape::NORMAL_MESSAGE, _("Drag the handles of the object to modify it.")); @@ -3742,18 +4315,26 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath) } } } - } else if (nodepath && selected == 1) { + } else if (nodepath && selected_nodes == 1) { mc->setF(Inkscape::NORMAL_MESSAGE, ngettext("%i of %i node selected; %s. %s.", "%i of %i nodes selected; %s. %s.", - total), - selected, total, sp_node_type_description((Inkscape::NodePath::Node *) nodepath->selected->data), when_selected_one); + total_nodes), + selected_nodes, total_nodes, sp_node_type_description((Inkscape::NodePath::Node *) nodepath->selected->data), when_selected_one); } else { - mc->setF(Inkscape::NORMAL_MESSAGE, - ngettext("%i of %i node selected. %s.", - "%i of %i nodes selected. %s.", - total), - selected, total, when_selected); + if (selected_subpaths > 1) { + mc->setF(Inkscape::NORMAL_MESSAGE, + ngettext("%i of %i node selected in %i of %i subpaths. %s.", + "%i of %i nodes selected in %i of %i subpaths. %s.", + total_nodes), + selected_nodes, total_nodes, selected_subpaths, total_subpaths, when_selected); + } else { + mc->setF(Inkscape::NORMAL_MESSAGE, + ngettext("%i of %i node selected. %s.", + "%i of %i nodes selected. %s.", + total_nodes), + selected_nodes, total_nodes, when_selected); + } } }