diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 4b955973774d27f44ed34e55a167441e9a011d12..78d76404df2b0aacbb732d59eac5558760b35edb 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
#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"
#include "libnr/nr-matrix-ops.h"
#include "splivarot.h"
#include "svg/svg.h"
+#include "verbs.h"
#include "display/bezier-utils.h"
#include <vector>
#include <algorithm>
/**
* \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->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
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) {
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);
}
+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.
*/
/**
* 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);
}
/**
// 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);
}
/**
- * Returns current path in context.
+ * Returns current path in context. // later eliminate this function at all!
*/
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();
}
}
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
- Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
sp_node_moveto(n, n->pos + best_pt);
}
@@ -997,11 +1004,23 @@ curve; the parameter alpha determines how blunt (alpha > 1) or sharp (alpha < 1)
near x = 0.
*/
double
-sculpt_profile (double x, double alpha)
+sculpt_profile (double x, double alpha, guint profile)
{
if (x >= 1)
return 0;
- return (0.5 * cos (M_PI * (pow(x, alpha))) + 0.5);
+ if (x <= 0)
+ return 1;
+
+ switch (profile) {
+ case SCULPT_PROFILE_LINEAR:
+ return 1 - x;
+ case SCULPT_PROFILE_BELL:
+ return (0.5 * cos (M_PI * (pow(x, alpha))) + 0.5);
+ case SCULPT_PROFILE_ELLIPTIC:
+ return sqrt(1 - x*x);
+ }
+
+ return 1;
}
double
@@ -1044,6 +1063,8 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
if (pressure > 0.5)
alpha = 1/alpha;
+ guint profile = prefs_get_int_attribute("tools.nodes", "sculpting_profile", SCULPT_PROFILE_BELL);
+
if (sp_nodepath_selection_get_subpath_count(nodepath) <= 1) {
// Only one subpath has selected nodes:
// use linear mode, where the distance from n to node being dragged is calculated along the path
@@ -1112,9 +1133,9 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
n_range += bezier_length (n_node->p.other->origin, n_node->p.other->n.origin, n_node->p.origin, n_node->origin);
if (n_node->selected) {
sp_nodepath_move_node_and_handles (n_node,
- sculpt_profile (n_range / n_sel_range, alpha) * delta,
- sculpt_profile ((n_range + NR::L2(n_node->n.origin - n_node->origin)) / n_sel_range, alpha) * delta,
- sculpt_profile ((n_range - NR::L2(n_node->p.origin - n_node->origin)) / n_sel_range, alpha) * delta);
+ sculpt_profile (n_range / n_sel_range, alpha, profile) * delta,
+ sculpt_profile ((n_range + NR::L2(n_node->n.origin - n_node->origin)) / n_sel_range, alpha, profile) * delta,
+ sculpt_profile ((n_range - NR::L2(n_node->p.origin - n_node->origin)) / n_sel_range, alpha, profile) * delta);
}
if (n_node == p_node) {
n_going = false;
@@ -1129,9 +1150,9 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
p_range += bezier_length (p_node->n.other->origin, p_node->n.other->p.origin, p_node->n.origin, p_node->origin);
if (p_node->selected) {
sp_nodepath_move_node_and_handles (p_node,
- sculpt_profile (p_range / p_sel_range, alpha) * delta,
- sculpt_profile ((p_range - NR::L2(p_node->n.origin - p_node->origin)) / p_sel_range, alpha) * delta,
- sculpt_profile ((p_range + NR::L2(p_node->p.origin - p_node->origin)) / p_sel_range, alpha) * delta);
+ sculpt_profile (p_range / p_sel_range, alpha, profile) * delta,
+ sculpt_profile ((p_range - NR::L2(p_node->n.origin - p_node->origin)) / p_sel_range, alpha, profile) * delta,
+ sculpt_profile ((p_range + NR::L2(p_node->p.origin - p_node->origin)) / p_sel_range, alpha, profile) * delta);
}
if (p_node == n_node) {
n_going = false;
@@ -1167,9 +1188,9 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
if (node->selected) {
if (direct_range > 1e-6) {
sp_nodepath_move_node_and_handles (node,
- sculpt_profile (NR::L2(node->origin - n->origin) / direct_range, alpha) * delta,
- sculpt_profile (NR::L2(node->n.origin - n->origin) / direct_range, alpha) * delta,
- sculpt_profile (NR::L2(node->p.origin - n->origin) / direct_range, alpha) * delta);
+ sculpt_profile (NR::L2(node->origin - n->origin) / direct_range, alpha, profile) * delta,
+ sculpt_profile (NR::L2(node->n.origin - n->origin) / direct_range, alpha, profile) * delta,
+ sculpt_profile (NR::L2(node->p.origin - n->origin) / direct_range, alpha, profile) * delta);
} else {
sp_nodepath_move_node_and_handles (node, delta, delta, delta);
}
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"));
}
}
sp_nodepath_selected_nodes_move(nodepath, zdx, zdy, false);
if (dx == 0) {
- sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical", _("Move nodes vertically"));
} else if (dy == 0) {
- sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal", _("Move nodes horizontally"));
} else {
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Move nodes"));
}
}
@@ -1336,6 +1357,9 @@ static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_mov
if (node->n.other->selected) show_handles = TRUE;
}
+ if (node->subpath->nodepath->show_handles == false)
+ show_handles = FALSE;
+
sp_node_update_handle(node, -1, show_handles, fire_move_signals);
sp_node_update_handle(node, 1, show_handles, fire_move_signals);
}
}
}
+void
+sp_nodepath_show_handles(bool show)
+{
+ Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
+ if (nodepath == NULL) return;
+
+ nodepath->show_handles = show;
+ sp_nodepath_update_handles(nodepath);
+}
+
/**
* Adds all selected nodes in nodepath to list.
*/
@@ -1395,7 +1429,7 @@ void sp_nodepath_selected_align(Inkscape::NodePath::Path *nodepath, NR::Dim2 axi
}
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Align nodes"));
}
/// Helper struct.
@@ -1457,7 +1491,7 @@ void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, NR::Dim
pos += step;
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Distribute nodes"));
}
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);
while (nl) {
Inkscape::NodePath::Node *t = (Inkscape::NodePath::Node *) nl->data;
Inkscape::NodePath::Node *n = sp_nodepath_line_add_node(t, 0.5);
- sp_nodepath_node_select(n, TRUE, FALSE);
- nl = g_list_remove(nl, t);
+ sp_nodepath_node_select(n, TRUE, FALSE);
+ n_added ++;
+ nl = g_list_remove(nl, t);
}
/** \todo fixme: adjust ? */
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ if (n_added > 1) {
+ sp_nodepath_update_repr(nodepath, _("Add nodes"));
+ } else if (n_added > 0) {
+ sp_nodepath_update_repr(nodepath, _("Add node"));
+ }
sp_nodepath_update_statusbar(nodepath);
}
@@ -1507,11 +1548,15 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po
return;
}
+ sp_nodepath_ensure_livarot_path(nodepath);
Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
//find segment to segment
Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
+ //fixme: this can return NULL, so check before proceeding.
+ g_return_if_fail(e != NULL);
+
gboolean force = FALSE;
if (!(e->selected && (!e->p.other || e->p.other->selected))) {
force = TRUE;
@@ -1535,6 +1580,7 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
return;
}
+ sp_nodepath_ensure_livarot_path(nodepath);
Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
//find segment to split
@@ -1550,7 +1596,7 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
/* fixme: adjust ? */
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Add node"));
sp_nodepath_update_statusbar(nodepath);
}
@@ -1563,8 +1609,14 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
* cf. app/vectors/gimpbezierstroke.c, gimp_bezier_stroke_point_move_relative()
*/
void
-sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
+sp_nodepath_curve_drag(int node, double t, NR::Point delta)
{
+ Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(node);
+
+ //fixme: e and e->p can be NULL, so check for those before proceeding
+ g_return_if_fail(e != NULL);
+ g_return_if_fail(&e->p != NULL);
+
/* feel good is an arbitrary parameter that distributes the delta between handles
* if t of the drag point is less than 1/6 distance form the endpoint only
* the corresponding hadle is adjusted. This matches the behavior in GIMP
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Break path"));
}
/**
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Duplicate node"));
}
/**
Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
g_assert(a != b);
- g_assert(a->p.other || a->n.other);
- g_assert(b->p.other || b->n.other);
+ if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) {
+ // someone tried to join an orphan node (i.e. a single-node subpath).
+ // this is not worth an error message, just fail silently.
+ return;
+ }
if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
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;
}
sp_nodepath_update_handles(sa->nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Join nodes"));
sp_nodepath_update_statusbar(nodepath);
}
Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
g_assert(a != b);
- g_assert(a->p.other || a->n.other);
- g_assert(b->p.other || b->n.other);
+ if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) {
+ // someone tried to join an orphan node (i.e. a single-node subpath).
+ // this is not worth an error message, just fail silently.
+ return;
+ }
if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
sp_nodepath_update_handles(sp->nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Close subpath by segment"));
return;
}
sp_nodepath_update_handles(sa->nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Join nodes by segment"));
}
/**
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;
}
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];
//delete this nodepath's object, not the entire selection! (though at this time, this
//does not matter)
sp_selection_delete();
- sp_document_done (document);
+ sp_document_done (document, SP_VERB_CONTEXT_NODE,
+ _("Delete nodes"));
} else {
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Delete nodes preserving shape"));
sp_nodepath_update_statusbar(nodepath);
}
}
sp_nodepath_get_node_count(nodepath) < 2) {
SPDocument *document = sp_desktop_document (nodepath->desktop);
sp_selection_delete();
- sp_document_done (document);
+ sp_document_done (document, SP_VERB_CONTEXT_NODE,
+ _("Delete nodes"));
return;
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Delete nodes"));
sp_nodepath_update_statusbar(nodepath);
}
//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);
}
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Delete segment"));
sp_nodepath_update_statusbar(nodepath);
}
}
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Change segment type"));
}
/**
sp_nodepath_convert_node_type((Inkscape::NodePath::Node *) l->data, type);
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Change node type"));
}
/**
@@ -2481,6 +2550,146 @@ void sp_nodepath_select_rect(Inkscape::NodePath::Path *nodepath, NR::Rect const
}
+void
+nodepath_grow_selection_linearly (Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, int grow)
+{
+ g_assert (n);
+ g_assert (nodepath);
+ g_assert (n->subpath->nodepath == nodepath);
+
+ if (g_list_length (nodepath->selected) == 0) {
+ if (grow > 0) {
+ sp_nodepath_node_select(n, TRUE, TRUE);
+ }
+ return;
+ }
+
+ if (g_list_length (nodepath->selected) == 1) {
+ if (grow < 0) {
+ sp_nodepath_deselect (nodepath);
+ return;
+ }
+ }
+
+ double n_sel_range = 0, p_sel_range = 0;
+ Inkscape::NodePath::Node *farthest_n_node = n;
+ Inkscape::NodePath::Node *farthest_p_node = n;
+
+ // Calculate ranges
+ {
+ double n_range = 0, p_range = 0;
+ bool n_going = true, p_going = true;
+ Inkscape::NodePath::Node *n_node = n;
+ Inkscape::NodePath::Node *p_node = n;
+ do {
+ // Do one step in both directions from n, until reaching the end of subpath or bumping into each other
+ if (n_node && n_going)
+ n_node = n_node->n.other;
+ if (n_node == NULL) {
+ n_going = false;
+ } else {
+ n_range += bezier_length (n_node->p.other->pos, n_node->p.other->n.pos, n_node->p.pos, n_node->pos);
+ if (n_node->selected) {
+ n_sel_range = n_range;
+ farthest_n_node = n_node;
+ }
+ if (n_node == p_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ if (p_node && p_going)
+ p_node = p_node->p.other;
+ if (p_node == NULL) {
+ p_going = false;
+ } else {
+ p_range += bezier_length (p_node->n.other->pos, p_node->n.other->p.pos, p_node->n.pos, p_node->pos);
+ if (p_node->selected) {
+ p_sel_range = p_range;
+ farthest_p_node = p_node;
+ }
+ if (p_node == n_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ } while (n_going || p_going);
+ }
+
+ if (grow > 0) {
+ if (n_sel_range < p_sel_range && farthest_n_node && farthest_n_node->n.other && !(farthest_n_node->n.other->selected)) {
+ sp_nodepath_node_select(farthest_n_node->n.other, TRUE, TRUE);
+ } else if (farthest_p_node && farthest_p_node->p.other && !(farthest_p_node->p.other->selected)) {
+ sp_nodepath_node_select(farthest_p_node->p.other, TRUE, TRUE);
+ }
+ } else {
+ if (n_sel_range > p_sel_range && farthest_n_node && farthest_n_node->selected) {
+ sp_nodepath_node_select(farthest_n_node, TRUE, FALSE);
+ } else if (farthest_p_node && farthest_p_node->selected) {
+ sp_nodepath_node_select(farthest_p_node, TRUE, FALSE);
+ }
+ }
+}
+
+void
+nodepath_grow_selection_spatially (Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, int grow)
+{
+ g_assert (n);
+ g_assert (nodepath);
+ g_assert (n->subpath->nodepath == nodepath);
+
+ if (g_list_length (nodepath->selected) == 0) {
+ if (grow > 0) {
+ sp_nodepath_node_select(n, TRUE, TRUE);
+ }
+ return;
+ }
+
+ if (g_list_length (nodepath->selected) == 1) {
+ if (grow < 0) {
+ sp_nodepath_deselect (nodepath);
+ return;
+ }
+ }
+
+ Inkscape::NodePath::Node *farthest_selected = NULL;
+ double farthest_dist = 0;
+
+ Inkscape::NodePath::Node *closest_unselected = NULL;
+ double closest_dist = NR_HUGE;
+
+ for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
+ Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
+ for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
+ Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
+ if (node == n)
+ continue;
+ if (node->selected) {
+ if (NR::L2(node->pos - n->pos) > farthest_dist) {
+ farthest_dist = NR::L2(node->pos - n->pos);
+ farthest_selected = node;
+ }
+ } else {
+ if (NR::L2(node->pos - n->pos) < closest_dist) {
+ closest_dist = NR::L2(node->pos - n->pos);
+ closest_unselected = node;
+ }
+ }
+ }
+ }
+
+ if (grow > 0) {
+ if (closest_unselected) {
+ sp_nodepath_node_select(closest_unselected, TRUE, TRUE);
+ }
+ } else {
+ if (farthest_selected) {
+ sp_nodepath_node_select(farthest_selected, TRUE, FALSE);
+ }
+ }
+}
+
+
/**
\brief Saves all nodes' and handles' current positions in their origin members
*/
/**
* Node event callback.
*/
-static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
+static gboolean node_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n)
{
gboolean ret = FALSE;
switch (event->type) {
@@ -2667,6 +2876,33 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Nod
case GDK_LEAVE_NOTIFY:
active_node = NULL;
break;
+ case GDK_SCROLL:
+ if ((event->scroll.state & GDK_CONTROL_MASK) && !(event->scroll.state & GDK_SHIFT_MASK)) { // linearly
+ switch (event->scroll.direction) {
+ case GDK_SCROLL_UP:
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+ break;
+ case GDK_SCROLL_DOWN:
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+ break;
+ default:
+ break;
+ }
+ ret = TRUE;
+ } else if (!(event->scroll.state & GDK_SHIFT_MASK)) { // spatially
+ switch (event->scroll.direction) {
+ case GDK_SCROLL_UP:
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+ break;
+ case GDK_SCROLL_DOWN:
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+ break;
+ default:
+ break;
+ }
+ ret = TRUE;
+ }
+ break;
case GDK_KEY_PRESS:
switch (get_group0_keyval (&event->key)) {
case GDK_space:
@@ -2676,6 +2912,20 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Nod
ret = TRUE;
}
break;
+ case GDK_Page_Up:
+ if (event->key.state & GDK_CONTROL_MASK) {
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+ } else {
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+ }
+ break;
+ case GDK_Page_Down:
+ if (event->key.state & GDK_CONTROL_MASK) {
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+ } else {
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+ }
+ break;
default:
break;
}
case GDK_BackSpace:
np = active_node->subpath->nodepath;
sp_nodepath_node_destroy(active_node);
- sp_nodepath_update_repr(np);
+ sp_nodepath_update_repr(np, _("Delete node"));
active_node = NULL;
ret = TRUE;
break;
} 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
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);
}
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"));
}
/**
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
}
}
} else { // move freely
- if (state & GDK_MOD1_MASK) { // sculpt
- sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, (*p) - n->origin);
- } else {
- sp_nodepath_selected_nodes_move(n->subpath->nodepath,
- (*p)[NR::X] - n->pos[NR::X],
- (*p)[NR::Y] - n->pos[NR::Y],
- (state & GDK_SHIFT_MASK) == 0);
- }
+ if (n->is_dragging) {
+ if (state & GDK_MOD1_MASK) { // sculpt
+ sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, (*p) - n->origin);
+ } else {
+ sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+ (*p)[NR::X] - n->pos[NR::X],
+ (*p)[NR::Y] - n->pos[NR::Y],
+ (state & GDK_SHIFT_MASK) == 0);
+ }
+ }
}
n->subpath->nodepath->desktop->scroll_to_point(p);
}
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
g_assert_not_reached();
}
+ sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5);
}
/**
g_assert_not_reached();
}
- sp_nodepath_update_repr(n->subpath->nodepath);
+ sp_nodepath_update_repr(n->subpath->nodepath, _("Move node handle"));
}
/**
@@ -3382,7 +3640,7 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
}
}
- sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n");
+ sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n", _("Rotate nodes"));
}
/**
@@ -3507,7 +3765,7 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
}
}
- sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n");
+ sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n", _("Scale nodes"));
}
void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath, gdouble const grow, int const which)
}
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Flip nodes"));
}
//-----------------------------------------------
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));
* Handles content of statusbar as long as node tool is active.
*/
void
-sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)
+sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to ShapeEditorsCollection
{
gchar const *when_selected = _("<b>Drag</b> nodes or node handles; <b>Alt+drag</b> nodes to sculpt; <b>arrow</b> keys to move nodes, <b>< ></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");