![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 8aed0420bb461f94f5ccf051ea5f6d456535474b..96820d85bc8dbcfbaa0c2d3d6cfb08fae5d9f47b 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
* Lauris Kaplinski <lauris@kaplinski.com>
* bulia byak <buliabyak@users.sf.net>
*
- * 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
/**
* \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;
np->nodeContext = NULL; //Let the context 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
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.
*
{
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);
}
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++;
void sp_nodepath_update_repr(Inkscape::NodePath::Path *np)
{
update_repr_internal(np);
- sp_document_done(SP_DT_DOCUMENT(np->desktop));
+ sp_document_done(sp_desktop_document(np->desktop));
if (np->livarot_path) {
delete np->livarot_path;
static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key)
{
update_repr_internal(np);
- sp_document_maybe_done(SP_DT_DOCUMENT(np->desktop), key);
+ sp_document_maybe_done(sp_desktop_document(np->desktop), key);
if (np->livarot_path) {
delete np->livarot_path;
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);
// move to the saved position
new_repr->setPosition(pos > 0 ? pos : 0);
- sp_document_done(SP_DT_DOCUMENT(np->desktop));
+ sp_document_done(sp_desktop_document(np->desktop));
Inkscape::GC::release(new_repr);
g_free(svgpath);
@@ -836,9 +881,9 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
}
// if one of handles is mouseovered, preserve its position
- if (node->p.knot && SP_KNOT_IS_MOSEOVER(node->p.knot)) {
+ if (node->p.knot && SP_KNOT_IS_MOUSEOVER(node->p.knot)) {
sp_node_adjust_handle(node, 1);
- } else if (node->n.knot && SP_KNOT_IS_MOSEOVER(node->n.knot)) {
+ } else if (node->n.knot && SP_KNOT_IS_MOUSEOVER(node->n.knot)) {
sp_node_adjust_handle(node, -1);
} else {
sp_node_adjust_handles(node);
static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, NR::Coord dx, NR::Coord dy,
bool const snap = true)
{
- NR::Coord best[2] = { NR_HUGE, NR_HUGE };
+ NR::Coord best = NR_HUGE;
NR::Point delta(dx, dy);
NR::Point best_pt = delta;
if (snap) {
+ SnapManager const &m = nodepath->desktop->namedview->snap_manager;
+
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
- Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
- NR::Point p = n->pos + delta;
- for (int dim = 0; dim < 2; dim++) {
- NR::Coord dist = namedview_dim_snap(nodepath->desktop->namedview,
- Inkscape::Snapper::SNAP_POINT, p,
- NR::Dim2(dim), nodepath->path);
- if (dist < best[dim]) {
- best[dim] = dist;
- best_pt[dim] = p[dim] - n->pos[dim];
- }
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAP_POINT, n->pos + delta, NULL);
+ if (s.getDistance() < best) {
+ best = s.getDistance();
+ best_pt = s.getPoint() - n->pos;
}
}
}
@@ -950,6 +992,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.
@@ -1021,7 +1270,7 @@ static void sp_node_ensure_knot_exists (SPDesktop *desktop, Inkscape::NodePath::
}
if (!side->line) {
- side->line = sp_canvas_item_new(SP_DT_CONTROLS(desktop),
+ side->line = sp_canvas_item_new(sp_desktop_controls(desktop),
SP_TYPE_CTRLLINE, NULL);
}
}
@@ -1102,6 +1351,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);
}
}
}
+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.
*/
/* a and b are endpoints */
- NR::Point c = (a->pos + b->pos) / 2;
+ NR::Point c;
+ if (a->knot && SP_KNOT_IS_MOUSEOVER(a->knot)) {
+ c = a->pos;
+ } else if (b->knot && SP_KNOT_IS_MOUSEOVER(b->knot)) {
+ c = b->pos;
+ } else {
+ c = (a->pos + b->pos) / 2;
+ }
if (a->subpath == b->subpath) {
Inkscape::NodePath::SubPath *sp = a->subpath;
sp_nodepath_subpath_close(sp);
+ sp_node_moveto (sp->first, c);
sp_nodepath_update_handles(sp->nodepath);
-
sp_nodepath_update_repr(nodepath);
-
return;
}
*/
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;
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_DT_DOCUMENT (nodepath->desktop);
- sp_nodepath_destroy(nodepath);
- g_list_free(nodes_to_delete);
- nodes_to_delete = NULL;
- //is the next line necessary?
+ SPDocument *document = sp_desktop_document (nodepath->desktop);
+ //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;
+ } else {
+ sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_statusbar(nodepath);
}
-
- sp_nodepath_update_repr(nodepath);
-
- sp_nodepath_update_statusbar(nodepath);
}
+
+ g_slist_free (nodepaths);
}
/**
// if the entire nodepath is removed, delete the selected object.
if (nodepath->subpaths == NULL ||
sp_nodepath_get_node_count(nodepath) < 2) {
- SPDocument *document = SP_DT_DOCUMENT (nodepath->desktop);
- sp_nodepath_destroy(nodepath);
+ SPDocument *document = sp_desktop_document (nodepath->desktop);
sp_selection_delete();
sp_document_done (document);
return;
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_statusbar(nodepath);
}
@@ -2241,6 +2508,24 @@ void sp_nodepath_select_rect(Inkscape::NodePath::Path *nodepath, NR::Rect const
}
}
+
+/**
+\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
*/
{
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);
}
+
+ sp_nodepath_remember_origins (n->subpath->nodepath);
}
/**
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
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
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;
}
}
} else { // move freely
- sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+ 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);
// 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();
}
// 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();
@@ -2833,7 +3120,7 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpo
NRPathcode const othercode = sp_node_path_code_from_side(n, opposite);
- SnapManager const m(n->subpath->nodepath->desktop->namedview);
+ SnapManager const &m = n->subpath->nodepath->desktop->namedview->snap_manager;
if (opposite->other && (n->type != Inkscape::NodePath::NODE_CUSP) && (othercode == NR_LINETO)) {
/* We are smooth node adjacent with line */
@@ -2846,7 +3133,7 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpo
NR::Coord const scal = dot(delta, ndelta) / linelen;
(*p) = n->pos + (scal / linelen) * ndelta;
}
- *p = m.constrainedSnap(Inkscape::Snapper::SNAP_POINT, *p, ndelta, NULL).getPoint();
+ *p = m.constrainedSnap(Inkscape::Snapper::SNAP_POINT, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), NULL).getPoint();
} else {
*p = m.freeSnap(Inkscape::Snapper::SNAP_POINT, *p, NULL).getPoint();
}
@@ -2888,13 +3175,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)
@@ -2905,7 +3192,7 @@ 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))
//Link the head to the tail
sp->first->p.other = sp->last;
sp->last->n.other = sp->first;
- sp->last->n.pos = sp->first->n.pos;
+ sp->last->n.pos = sp->last->pos + (sp->first->n.pos - sp->first->pos);
sp->first = sp->last;
//Remove the extra end node
@@ -3696,19 +3983,16 @@ static gchar const *sp_node_type_description(Inkscape::NodePath::Node *node)
void
sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)
{
- gchar const *when_selected = _("<b>Drag</b> nodes or node handles; <b>arrow</b> keys to move nodes");
+ 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>< ></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");
- 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;
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,
mc->setF(Inkscape::NORMAL_MESSAGE,
ngettext("<b>0</b> out of <b>%i</b> node selected. <b>Click</b>, <b>Shift+click</b>, or <b>drag around</b> nodes to select.",
"<b>0</b> out of <b>%i</b> nodes selected. <b>Click</b>, <b>Shift+click</b>, or <b>drag around</b> 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."));
}
}
}
- } else if (nodepath && selected == 1) {
+ } else if (nodepath && selected_nodes == 1) {
mc->setF(Inkscape::NORMAL_MESSAGE,
ngettext("<b>%i</b> of <b>%i</b> node selected; %s. %s.",
"<b>%i</b> of <b>%i</b> 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("<b>%i</b> of <b>%i</b> node selected. %s.",
- "<b>%i</b> of <b>%i</b> nodes selected. %s.",
- total),
- selected, total, when_selected);
+ if (selected_subpaths > 1) {
+ mc->setF(Inkscape::NORMAL_MESSAGE,
+ ngettext("<b>%i</b> of <b>%i</b> node selected in <b>%i</b> of <b>%i</b> subpaths. %s.",
+ "<b>%i</b> of <b>%i</b> nodes selected in <b>%i</b> of <b>%i</b> subpaths. %s.",
+ total_nodes),
+ selected_nodes, total_nodes, selected_subpaths, total_subpaths, when_selected);
+ } else {
+ mc->setF(Inkscape::NORMAL_MESSAGE,
+ ngettext("<b>%i</b> of <b>%i</b> node selected. %s.",
+ "<b>%i</b> of <b>%i</b> nodes selected. %s.",
+ total_nodes),
+ selected_nodes, total_nodes, when_selected);
+ }
}
}