diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 01a7cfa6b87da34734f92c452e3c670f75195875..f9f6f169132f4205cb5eff0fb7f52b61ff2acbe8 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
/**
* \brief Creates new nodepath from item
*/
/**
* \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;
{
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->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
// we need to update item's transform from the repr here,
// because they may be out of sync when we respond
@@ -997,11 +998,23 @@ curve; the parameter alpha determines how blunt (alpha > 1) or sharp (alpha < 1)
near x = 0.
*/
double
near x = 0.
*/
double
-sculpt_profile (double x, double alpha)
+sculpt_profile (double x, double alpha, guint profile)
{
if (x >= 1)
return 0;
{
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
}
double
@@ -1044,64 +1057,115 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
if (pressure > 0.5)
alpha = 1/alpha;
if (pressure > 0.5)
alpha = 1/alpha;
- 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) {
+ 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;
n_going = false;
- p_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 && 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;
+ }
}
}
- if (p_node == n_node) {
+ } 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;
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;
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);
- }
+ } while (n_going || p_going);
+ }
- // Now let's see if we also need to move nodes on other subpaths, and calculate their range too
- gdouble direct_range = 0;
- if (sp_nodepath_selection_get_subpath_count(nodepath) > 1) {
- // For nodes in other subpaths, we calculate the distance from n simply by NR::L2 without
- // any bezier lengths; the range is the maximum such distance
+ } 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
// 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 *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
- if (subpath == n->subpath)
- continue; // this is our source subpath, already processed above
for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
if (node->selected) {
for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
if (node->selected) {
@@ -1109,80 +1173,22 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
}
}
}
}
}
}
- }
-
- // is ALL of the current nodepath selected?
- if (n_nodes + p_nodes == n_sel_nodes + p_sel_nodes) {
- // then we should really use direct-range instead of n_ and p_ ranges if it is bigger
- if (direct_range > n_sel_range)
- n_sel_range = direct_range;
- if (direct_range > p_sel_range)
- p_sel_range = direct_range;
- }
-
- // 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) * 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);
- }
- 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) * 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);
- }
- if (p_node == n_node) {
- n_going = false;
- p_going = false;
- }
- }
- } while (n_going || p_going);
- }
-
- // Now let's see if we also need to move nodes on other subpaths
- if (sp_nodepath_selection_get_subpath_count(nodepath) > 1) {
- // For nodes in other subpaths, we calculate the distance from n simply by NR::L2 without
- // any bezier lengths; the range is the maximum such distance
// Second pass: actually move nodes
for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
// Second pass: actually move nodes
for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
- if (subpath == n->subpath)
- continue; // this is our source subpath, already processed above
for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
if (node->selected) {
for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
if (node->selected) {
- 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);
+ 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);
+ }
+
}
}
}
}
}
}
@@ -1345,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->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);
}
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.
*/
/**
* Adds all selected nodes in nodepath to list.
*/
@@ -2490,6 +2509,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
*/
/**
\brief Saves all nodes' and handles' current positions in their origin members
*/
/**
* Node event callback.
*/
/**
* 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) {
{
gboolean ret = FALSE;
switch (event->type) {
@@ -2685,6 +2844,20 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Nod
ret = TRUE;
}
break;
ret = TRUE;
}
break;
+ case GDK_Page_Up:
+ if (event->key.state & GDK_CONTROL_MASK) {
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+ } else {
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+ }
+ break;
+ case GDK_Page_Down:
+ if (event->key.state & GDK_CONTROL_MASK) {
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+ } else {
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+ }
+ break;
default:
break;
}
default:
break;
}
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
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 (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)
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 (xp < 0) { xp = -xp; yp = -yp; } // limit the angle to between 0 and pi