![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 26078ea92d30bb6accf1d635ffc9c42c658d8ae8..97be9355cb2863be8d05a993b9324e54c182184e 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
static SPCurve *create_curve(Inkscape::NodePath::Path *np);
static gchar *create_typestr(Inkscape::NodePath::Path *np);
-static void sp_node_ensure_ctrls(Inkscape::NodePath::Node *node);
+static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_move_signals = true);
static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean incremental, gboolean override);
static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean selected);
-/* Control knot placement, if node or other knot is moved */
-
-static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjust);
-static void sp_node_adjust_knots(Inkscape::NodePath::Node *node);
-
-/* Knot event handlers */
+/* 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);
+/* Node event callbacks */
static void node_clicked(SPKnot *knot, guint state, gpointer data);
static void node_grabbed(SPKnot *knot, guint state, gpointer data);
static void node_ungrabbed(SPKnot *knot, guint state, gpointer data);
static gboolean node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data);
-static void node_ctrl_clicked(SPKnot *knot, guint state, gpointer data);
-static void node_ctrl_grabbed(SPKnot *knot, guint state, gpointer data);
-static void node_ctrl_ungrabbed(SPKnot *knot, guint state, gpointer data);
-static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpointer data);
-static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data);
-static gboolean node_ctrl_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n);
+
+/* Handle event callbacks */
+static void node_handle_clicked(SPKnot *knot, guint state, gpointer data);
+static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data);
+static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data);
+static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpointer data);
+static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data);
+static gboolean node_handle_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n);
/* Constructors and destructors */
np->subpaths = NULL;
np->selected = NULL;
np->nodeContext = NULL; //Let the context that makes this set it
+ np->livarot_path = NULL;
// we need to update item's transform from the repr here,
// because they may be out of sync when we respond
np->d2i = np->i2d.inverse();
np->repr = repr;
- /* Now the bitchy part (lauris) */
-
+ // create the subpath(s) from the bpath
NArtBpath *b = bpath;
-
while (b->code != NR_END) {
b = subpath_from_bpath(np, b, typestr + (b - bpath));
}
+ // reverse the list, because sp_nodepath_subpath_new() used g_list_prepend instead of append (for speed)
+ np->subpaths = g_list_reverse(np->subpaths);
+
g_free(typestr);
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);
+
return np;
}
g_assert(!np->selected);
+ if (np->livarot_path) {
+ delete np->livarot_path;
+ np->livarot_path = NULL;
+ }
+
np->desktop = NULL;
g_free(np);
* This may happen if repr was changed in, e.g., XML editor or by undo.
*
* \todo
- * UGLY HACK, think how we can eliminate it.
+ * UGLY HACK, think how we can eliminate it. IDEA: try instead a local_change flag in node context?
*/
gboolean nodepath_repr_d_changed(Inkscape::NodePath::Path *np, char const *newd)
{
@@ -322,6 +334,7 @@ gboolean nodepath_repr_d_changed(Inkscape::NodePath::Path *np, char const *newd)
* attribute in its repr do not match.
*
* This may happen if repr was changed in, e.g., the XML editor or by undo.
+ * IDEA: try instead a local_change flag in node context?
*/
gboolean nodepath_repr_typestr_changed(Inkscape::NodePath::Path *np, char const *newtypestr)
{
}
/**
- * Make curve out of path and associate it with it.
+ * Make curve out of nodepath, write it into that nodepath's SPShape item so that display is
+ * updated but repr is not (for speed). Used during curve and node drag.
*/
static void update_object(Inkscape::NodePath::Path *np)
{
/**
* Update XML path node with data from path object, commit changes forever.
*/
-static void update_repr(Inkscape::NodePath::Path *np)
+void sp_nodepath_update_repr(Inkscape::NodePath::Path *np)
{
update_repr_internal(np);
sp_document_done(SP_DT_DOCUMENT(np->desktop));
+
+ 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 XML path node with data from path object, commit changes with undo.
*/
-static void update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key)
+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);
+
+ 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);
+ }
}
/**
/**
- \brief Fills node and control positions for three nodes, splitting line
+ \brief Fills node and handle positions for three nodes, splitting line
marked by end at distance t.
*/
static void sp_nodepath_line_midpoint(Inkscape::NodePath::Node *new_path,Inkscape::NodePath::Node *end, gdouble t)
@@ -700,9 +736,9 @@ static Inkscape::NodePath::Node *sp_nodepath_line_add_node(Inkscape::NodePath::N
&start->pos, &start->pos, &start->n.pos);
sp_nodepath_line_midpoint(newnode, end, t);
- sp_node_ensure_ctrls(start);
- sp_node_ensure_ctrls(newnode);
- sp_node_ensure_ctrls(end);
+ sp_node_update_handles(start);
+ sp_node_update_handles(newnode);
+ sp_node_update_handles(end);
return newnode;
}
@@ -770,12 +806,12 @@ static Inkscape::NodePath::Node *sp_nodepath_node_duplicate(Inkscape::NodePath::
return newnode; // otherwise select the newly created node
}
-static void sp_node_control_mirror_n_to_p(Inkscape::NodePath::Node *node)
+static void sp_node_handle_mirror_n_to_p(Inkscape::NodePath::Node *node)
{
node->p.pos = (node->pos + (node->pos - node->n.pos));
}
-static void sp_node_control_mirror_p_to_n(Inkscape::NodePath::Node *node)
+static void sp_node_handle_mirror_p_to_n(Inkscape::NodePath::Node *node)
{
node->n.pos = (node->pos + (node->pos - node->p.pos));
}
@@ -801,24 +837,24 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode
if (end->n.other) {
if (end->n.other->code == NR_LINETO) end->type =Inkscape::NodePath::NODE_CUSP;
}
- sp_node_adjust_knot(start, -1);
- sp_node_adjust_knot(end, 1);
+ 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;
end->p.pos = end->pos - delta / 3;
- sp_node_adjust_knot(start, 1);
- sp_node_adjust_knot(end, -1);
+ sp_node_adjust_handle(start, 1);
+ sp_node_adjust_handle(end, -1);
}
- sp_node_ensure_ctrls(start);
- sp_node_ensure_ctrls(end);
+ sp_node_update_handles(start);
+ sp_node_update_handles(end);
}
/**
* Change node type, and its handles accordingly.
*/
-static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeType type)
+static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
{
g_assert(node);
g_assert(node->subpath);
@@ -844,7 +880,16 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
sp_knot_update_ctrl(node->knot);
}
- sp_node_adjust_knots(node);
+ // if one of handles is mouseovered, preserve its position
+ if (node->p.knot && SP_KNOT_IS_MOSEOVER(node->p.knot)) {
+ sp_node_adjust_handle(node, 1);
+ } else if (node->n.knot && SP_KNOT_IS_MOSEOVER(node->n.knot)) {
+ sp_node_adjust_handle(node, -1);
+ } else {
+ sp_node_adjust_handles(node);
+ }
+
+ sp_node_update_handles(node);
sp_nodepath_update_statusbar(node->subpath->nodepath);
@@ -867,7 +912,7 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
else
delta = node->pos - node->p.other->pos;
node->p.pos = node->pos - delta / 4;
- sp_node_ensure_ctrls(node);
+ sp_node_update_handles(node);
}
if ((node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos)) {
@@ -879,7 +924,7 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
else
delta = node->pos - node->n.other->pos;
node->n.pos = node->pos - delta / 4;
- sp_node_ensure_ctrls(node);
+ sp_node_update_handles(node);
}
}
if (node->p.other) {
if (node->code == NR_LINETO) {
- sp_node_adjust_knot(node, 1);
- sp_node_adjust_knot(node->p.other, -1);
+ sp_node_adjust_handle(node, 1);
+ sp_node_adjust_handle(node->p.other, -1);
}
}
if (node->n.other) {
if (node->n.other->code == NR_LINETO) {
- sp_node_adjust_knot(node, -1);
- sp_node_adjust_knot(node->n.other, 1);
+ sp_node_adjust_handle(node, -1);
+ sp_node_adjust_handle(node->n.other, 1);
}
}
- sp_node_ensure_ctrls(node);
+ // 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);
}
/**
sp_node_moveto(n, n->pos + best_pt);
}
+ // do not update repr here so that node dragging is acceptably fast
update_object(nodepath);
}
sp_nodepath_selected_nodes_move(nodepath, dx, dy, false);
if (dx == 0) {
- update_repr_keyed(nodepath, "node:move:vertical");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
} else if (dy == 0) {
- update_repr_keyed(nodepath, "node:move:horizontal");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
} else {
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
}
sp_nodepath_selected_nodes_move(nodepath, zdx, zdy, false);
if (dx == 0) {
- update_repr_keyed(nodepath, "node:move:vertical");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
} else if (dy == 0) {
- update_repr_keyed(nodepath, "node:move:horizontal");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
} else {
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
}
@@ -1009,12 +1057,12 @@ static void sp_node_ensure_knot_exists (SPDesktop *desktop, Inkscape::NodePath::
side->knot->setStroke(KNOT_STROKE, KNOT_STROKE_HI, KNOT_STROKE_HI);
sp_knot_update_ctrl(side->knot);
- g_signal_connect(G_OBJECT(side->knot), "clicked", G_CALLBACK(node_ctrl_clicked), node);
- g_signal_connect(G_OBJECT(side->knot), "grabbed", G_CALLBACK(node_ctrl_grabbed), node);
- g_signal_connect(G_OBJECT(side->knot), "ungrabbed", G_CALLBACK(node_ctrl_ungrabbed), node);
- g_signal_connect(G_OBJECT(side->knot), "request", G_CALLBACK(node_ctrl_request), node);
- g_signal_connect(G_OBJECT(side->knot), "moved", G_CALLBACK(node_ctrl_moved), node);
- g_signal_connect(G_OBJECT(side->knot), "event", G_CALLBACK(node_ctrl_event), node);
+ g_signal_connect(G_OBJECT(side->knot), "clicked", G_CALLBACK(node_handle_clicked), node);
+ g_signal_connect(G_OBJECT(side->knot), "grabbed", G_CALLBACK(node_handle_grabbed), node);
+ g_signal_connect(G_OBJECT(side->knot), "ungrabbed", G_CALLBACK(node_handle_ungrabbed), node);
+ g_signal_connect(G_OBJECT(side->knot), "request", G_CALLBACK(node_handle_request), node);
+ g_signal_connect(G_OBJECT(side->knot), "moved", G_CALLBACK(node_handle_moved), node);
+ g_signal_connect(G_OBJECT(side->knot), "event", G_CALLBACK(node_handle_event), node);
}
if (!side->line) {
@@ -1024,28 +1072,34 @@ static void sp_node_ensure_knot_exists (SPDesktop *desktop, Inkscape::NodePath::
}
/**
- * Ensure knot on side of node is visible/invisible.
+ * Ensure the given handle of the node is visible/invisible, update its screen position
*/
-static void sp_node_ensure_knot(Inkscape::NodePath::Node *node, gint which, gboolean show_knot)
+static void sp_node_update_handle(Inkscape::NodePath::Node *node, gint which, gboolean show_handle, bool fire_move_signals)
{
g_assert(node != NULL);
Inkscape::NodePath::NodeSide *side = sp_node_get_side(node, which);
NRPathcode code = sp_node_path_code_from_side(node, side);
- show_knot = show_knot && (code == NR_CURVETO) && (NR::L2(side->pos - node->pos) > 1e-6);
+ show_handle = show_handle && (code == NR_CURVETO) && (NR::L2(side->pos - node->pos) > 1e-6);
- if (show_knot) {
- if (!side->knot) {
+ if (show_handle) {
+ if (!side->knot) { // No handle knot at all
sp_node_ensure_knot_exists(node->subpath->nodepath->desktop, node, side);
// Just created, so we shouldn't fire the node_moved callback - instead set the knot position directly
side->knot->pos = side->pos;
- if (side->knot->item) SP_CTRL(side->knot->item)->moveto(side->pos);
+ if (side->knot->item)
+ SP_CTRL(side->knot->item)->moveto(side->pos);
sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos);
sp_knot_show(side->knot);
} else {
if (side->knot->pos != side->pos) { // only if it's really moved
- sp_knot_set_position(side->knot, &side->pos, 0); // this will set coords of the line as well
+ if (fire_move_signals) {
+ sp_knot_set_position(side->knot, &side->pos, 0); // this will set coords of the line as well
+ } else {
+ sp_knot_moveto(side->knot, &side->pos);
+ sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos);
+ }
}
if (!SP_KNOT_IS_VISIBLE(side->knot)) {
sp_knot_show(side->knot);
@@ -1065,9 +1119,12 @@ static void sp_node_ensure_knot(Inkscape::NodePath::Node *node, gint which, gboo
}
/**
- * Ensure handles on node and neighbours of node are visible if selected.
+ * Ensure the node itself is visible, its handles and those of the neighbours of the node are
+ * visible if selected, update their screen positions. If fire_move_signals, move the node and its
+ * handles so that the corresponding signals are fired, callbacks are activated, and curve is
+ * updated; otherwise, just move the knots silently (used in batch moves).
*/
-static void sp_node_ensure_ctrls(Inkscape::NodePath::Node *node)
+static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_move_signals)
{
g_assert(node != NULL);
sp_knot_show(node->knot);
}
- sp_knot_set_position(node->knot, &node->pos, 0);
+ if (node->knot->pos != node->pos) { // visible knot is in a different position, need to update
+ if (fire_move_signals)
+ sp_knot_set_position(node->knot, &node->pos, 0);
+ else
+ sp_knot_moveto(node->knot, &node->pos);
+ }
- gboolean show_knots = node->selected;
+ gboolean show_handles = node->selected;
if (node->p.other != NULL) {
- if (node->p.other->selected) show_knots = TRUE;
+ if (node->p.other->selected) show_handles = TRUE;
}
if (node->n.other != NULL) {
- if (node->n.other->selected) show_knots = TRUE;
+ if (node->n.other->selected) show_handles = TRUE;
}
- sp_node_ensure_knot(node, -1, show_knots);
- sp_node_ensure_knot(node, 1, show_knots);
+ sp_node_update_handle(node, -1, show_handles, fire_move_signals);
+ sp_node_update_handle(node, 1, show_handles, fire_move_signals);
}
/**
- * Call sp_node_ensure_ctrls() for all nodes on subpath.
+ * Call sp_node_update_handles() for all nodes on subpath.
*/
-static void sp_nodepath_subpath_ensure_ctrls(Inkscape::NodePath::SubPath *subpath)
+static void sp_nodepath_subpath_update_handles(Inkscape::NodePath::SubPath *subpath)
{
g_assert(subpath != NULL);
for (GList *l = subpath->nodes; l != NULL; l = l->next) {
- sp_node_ensure_ctrls((Inkscape::NodePath::Node *) l->data);
+ sp_node_update_handles((Inkscape::NodePath::Node *) l->data);
}
}
/**
- * Call sp_nodepath_subpath_ensure_ctrls() for all subpaths of nodepath.
+ * Call sp_nodepath_subpath_update_handles() for all subpaths of nodepath.
*/
-static void sp_nodepath_ensure_ctrls(Inkscape::NodePath::Path *nodepath)
+static void sp_nodepath_update_handles(Inkscape::NodePath::Path *nodepath)
{
g_assert(nodepath != NULL);
for (GList *l = nodepath->subpaths; l != NULL; l = l->next) {
- sp_nodepath_subpath_ensure_ctrls((Inkscape::NodePath::SubPath *) l->data);
+ sp_nodepath_subpath_update_handles((Inkscape::NodePath::SubPath *) l->data);
}
}
@@ -1143,11 +1205,8 @@ void sp_nodepath_selected_align(Inkscape::NodePath::Path *nodepath, NR::Dim2 axi
sp_node_moveto(pNode, dest);
}
}
- if (axis == NR::X) {
- update_repr_keyed(nodepath, "node:move:vertical");
- } else {
- update_repr_keyed(nodepath, "node:move:horizontal");
- }
+
+ sp_nodepath_update_repr(nodepath);
}
/// Helper struct.
@@ -1209,11 +1268,7 @@ void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, NR::Dim
pos += step;
}
- if (axis == NR::X) {
- update_repr_keyed(nodepath, "node:move:horizontal");
- } else {
- update_repr_keyed(nodepath, "node:move:vertical");
- }
+ sp_nodepath_update_repr(nodepath);
}
}
/** \todo fixme: adjust ? */
- sp_nodepath_ensure_ctrls(nodepath);
+ sp_nodepath_update_handles(nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
sp_nodepath_update_statusbar(nodepath);
}
* Select segment nearest to point
*/
void
-sp_nodepath_select_segment_near_point(SPItem * item, NR::Point p, bool toggle)
+sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p, bool toggle)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) {
return;
}
- Path::cut_position position = get_nearest_position_on_Path(item, p);
+ 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);
@@ -1277,7 +1331,7 @@ sp_nodepath_select_segment_near_point(SPItem * item, NR::Point p, bool toggle)
if (e->p.other)
sp_nodepath_node_select(e->p.other, TRUE, force);
- sp_nodepath_ensure_ctrls(nodepath);
+ sp_nodepath_update_handles(nodepath);
sp_nodepath_update_statusbar(nodepath);
}
@@ -1286,14 +1340,13 @@ sp_nodepath_select_segment_near_point(SPItem * item, NR::Point p, bool toggle)
* Add a node nearest to point
*/
void
-sp_nodepath_add_node_near_point(SPItem * item, NR::Point p)
+sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) {
return;
}
- Path::cut_position position = get_nearest_position_on_Path(item, p);
+ Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
//find segment to split
Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
sp_nodepath_node_select(n, FALSE, TRUE);
/* fixme: adjust ? */
- sp_nodepath_ensure_ctrls(nodepath);
+ sp_nodepath_update_handles(nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
sp_nodepath_update_statusbar(nodepath);
}
* 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, char * key)
+sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
{
/* 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
@@ -1347,13 +1400,13 @@ sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta,
e->p.other->n.pos += offsetcoord0;
e->p.pos += offsetcoord1;
- // adjust controls of adjacent segments where necessary
- sp_node_adjust_knot(e,1);
- sp_node_adjust_knot(e->p.other,-1);
+ // adjust handles of adjacent nodes where necessary
+ sp_node_adjust_handle(e,1);
+ sp_node_adjust_handle(e->p.other,-1);
- sp_nodepath_ensure_ctrls(e->subpath->nodepath);
+ sp_nodepath_update_handles(e->subpath->nodepath);
- update_repr_keyed(e->subpath->nodepath, key);
+ update_object(e->subpath->nodepath);
sp_nodepath_update_statusbar(e->subpath->nodepath);
}
sp_nodepath_node_select((Inkscape::NodePath::Node *) l->data, TRUE, TRUE);
}
- sp_nodepath_ensure_ctrls(nodepath);
+ sp_nodepath_update_handles(nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
/**
sp_nodepath_node_select((Inkscape::NodePath::Node *) l->data, TRUE, TRUE);
}
- sp_nodepath_ensure_ctrls(nodepath);
+ sp_nodepath_update_handles(nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
/**
Inkscape::NodePath::SubPath *sp = a->subpath;
sp_nodepath_subpath_close(sp);
- sp_nodepath_ensure_ctrls(sp->nodepath);
+ sp_nodepath_update_handles(sp->nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
return;
}
sp_nodepath_subpath_destroy(sb);
- sp_nodepath_ensure_ctrls(sa->nodepath);
+ sp_nodepath_update_handles(sa->nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
sp_nodepath_update_statusbar(nodepath);
}
sp->first->p.other = sp->last;
sp->last->n.other = sp->first;
- sp_node_control_mirror_p_to_n(sp->last);
- sp_node_control_mirror_n_to_p(sp->first);
+ sp_node_handle_mirror_p_to_n(sp->last);
+ sp_node_handle_mirror_n_to_p(sp->first);
sp->first->code = sp->last->code;
sp->first = sp->last;
- sp_nodepath_ensure_ctrls(sp->nodepath);
+ sp_nodepath_update_handles(sp->nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
return;
}
if (b == sb->first) {
n = sb->first;
- sp_node_control_mirror_p_to_n(sa->last);
+ sp_node_handle_mirror_p_to_n(sa->last);
sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &n->p.pos, &n->pos, &n->n.pos);
- sp_node_control_mirror_n_to_p(sa->last);
+ sp_node_handle_mirror_n_to_p(sa->last);
for (n = n->n.other; n != NULL; n = n->n.other) {
sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->code, &n->p.pos, &n->pos, &n->n.pos);
}
} else if (b == sb->last) {
n = sb->last;
- sp_node_control_mirror_p_to_n(sa->last);
+ sp_node_handle_mirror_p_to_n(sa->last);
sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &n->pos, &n->p.pos);
- sp_node_control_mirror_n_to_p(sa->last);
+ sp_node_handle_mirror_n_to_p(sa->last);
for (n = n->p.other; n != NULL; n = n->p.other) {
sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos);
}
sp_nodepath_subpath_destroy(sb);
- sp_nodepath_ensure_ctrls(sa->nodepath);
+ sp_nodepath_update_handles(sa->nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
/**
//clean up the nodepath (such as for trivial subpaths)
sp_nodepath_cleanup(nodepath);
- sp_nodepath_ensure_ctrls(nodepath);
+ sp_nodepath_update_handles(nodepath);
// if the entire nodepath is removed, delete the selected object.
if (nodepath->subpaths == NULL ||
return;
}
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
sp_nodepath_update_statusbar(nodepath);
}
//clean up the nodepath (such as for trivial subpaths)
sp_nodepath_cleanup(nodepath);
- sp_nodepath_ensure_ctrls(nodepath);
+ sp_nodepath_update_handles(nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
// if the entire nodepath is removed, delete the selected object.
if (nodepath->subpaths == NULL ||
}
}
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
/**
sp_nodepath_convert_node_type((Inkscape::NodePath::Node *) l->data, type);
}
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
/**
@@ -1867,9 +1920,9 @@ static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean select
sp_knot_update_ctrl(node->knot);
}
- sp_node_ensure_ctrls(node);
- if (node->n.other) sp_node_ensure_ctrls(node->n.other);
- if (node->p.other) sp_node_ensure_ctrls(node->p.other);
+ sp_node_update_handles(node);
+ if (node->n.other) sp_node_update_handles(node->n.other);
+ if (node->p.other) sp_node_update_handles(node->p.other);
}
/**
}
/**
-\brief Adjusts control point according to node type and line code.
+\brief Adjusts handle according to node type and line code.
*/
-static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjust)
+static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust)
{
double len, otherlen, linelen;
@@ -2202,19 +2255,15 @@ static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjus
len = NR::L2(me->pos - node->pos);
delta = node->pos - othernode->pos;
linelen = NR::L2(delta);
- if (linelen < 1e-18) return;
-
+ if (linelen < 1e-18)
+ return;
me->pos = node->pos + (len / linelen)*delta;
-
- sp_node_ensure_ctrls(node);
return;
}
if (node->type == Inkscape::NodePath::NODE_SYMM) {
me->pos = 2 * node->pos - other->pos;
-
- sp_node_ensure_ctrls(node);
return;
}
@@ -2226,14 +2275,12 @@ static void sp_node_adjust_knot(Inkscape::NodePath::Node *node, gint which_adjus
if (otherlen < 1e-18) return;
me->pos = node->pos - (len / otherlen) * delta;
-
- sp_node_ensure_ctrls(node);
}
/**
- \brief Adjusts control point according to node type and line code
+ \brief Adjusts both handles according to node type and line code
*/
-static void sp_node_adjust_knots(Inkscape::NodePath::Node *node)
+static void sp_node_adjust_handles(Inkscape::NodePath::Node *node)
{
g_assert(node);
if (node->code == NR_LINETO) {
if (node->n.other->code == NR_LINETO) return;
- sp_node_adjust_knot(node, 1);
- sp_node_ensure_ctrls(node);
+ sp_node_adjust_handle(node, 1);
return;
}
if (node->n.other->code == NR_LINETO) {
if (node->code == NR_LINETO) return;
- sp_node_adjust_knot(node, -1);
- sp_node_ensure_ctrls(node);
+ sp_node_adjust_handle(node, -1);
return;
}
/* both are curves */
-
NR::Point const delta( node->n.pos - node->p.pos );
if (node->type == Inkscape::NodePath::NODE_SYMM) {
node->p.pos = node->pos - delta / 2;
node->n.pos = node->pos + delta / 2;
- sp_node_ensure_ctrls(node);
return;
}
/* We are smooth */
-
double plen = NR::L2(node->p.pos - node->pos);
if (plen < 1e-18) return;
double nlen = NR::L2(node->n.pos - node->pos);
if (nlen < 1e-18) return;
node->p.pos = node->pos - (plen / (plen + nlen)) * delta;
node->n.pos = node->pos + (nlen / (plen + nlen)) * delta;
- sp_node_ensure_ctrls(node);
}
/**
- * Knot events handler callback.
+ * Node event callback.
*/
static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
{
case GDK_BackSpace:
np = active_node->subpath->nodepath;
sp_nodepath_node_destroy(active_node);
- update_repr(np);
+ sp_nodepath_update_repr(np);
active_node = NULL;
ret = TRUE;
break;
} else {
sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_CUSP);
}
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
sp_nodepath_update_statusbar(nodepath);
} else { //ctrl+alt+click: delete node
sp_document_done (document);
} else {
- sp_nodepath_ensure_ctrls(nodepath);
- update_repr(nodepath);
+ sp_nodepath_update_handles(nodepath);
+ sp_nodepath_update_repr(nodepath);
sp_nodepath_update_statusbar(nodepath);
}
}
n->dragging_out = NULL;
- update_repr(n->subpath->nodepath);
+ sp_nodepath_update_repr(n->subpath->nodepath);
}
/**
}
// pass this on to the handle-moved callback
- node_ctrl_moved(n->dragging_out->knot, &mouse, state, (gpointer) n);
- sp_node_ensure_ctrls(n);
+ node_handle_moved(n->dragging_out->knot, &mouse, state, (gpointer) n);
+ sp_node_update_handles(n);
return TRUE;
}
// sliding on handles, only if at least one of the handles is non-vertical
// (otherwise it's the same as ctrl+drag anyway)
- // calculate angles of the control handles
+ // calculate angles of the handles
if (xn == 0) {
if (yn == 0) { // no handle, consider it the continuation of the other one
an = 0;
/**
* Node handle clicked callback.
*/
-static void node_ctrl_clicked(SPKnot *knot, guint state, gpointer data)
+static void node_handle_clicked(SPKnot *knot, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
} else if (n->n.knot == knot) {
n->n.pos = n->pos;
}
- sp_node_ensure_ctrls(n);
+ sp_node_update_handles(n);
Inkscape::NodePath::Path *nodepath = n->subpath->nodepath;
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
sp_nodepath_update_statusbar(nodepath);
} else { // just select or add to selection, depending in Shift
/**
* Node handle grabbed callback.
*/
-static void node_ctrl_grabbed(SPKnot *knot, guint state, gpointer data)
+static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE);
}
- // remember the origin of the control
+ // remember the origin point of the handle
if (n->p.knot == knot) {
n->p.origin = n->p.pos - n->pos;
} else if (n->n.knot == knot) {
/**
* Node handle ungrabbed callback.
*/
-static void node_ctrl_ungrabbed(SPKnot *knot, guint state, gpointer data)
+static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
g_assert_not_reached();
}
- update_repr(n->subpath->nodepath);
+ sp_nodepath_update_repr(n->subpath->nodepath);
}
/**
* Node handle "request" signal callback.
*/
-static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
+static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
@@ -2749,7 +2790,7 @@ static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpoin
*p = m.freeSnap(Inkscape::Snapper::SNAP_POINT, *p, NULL).getPoint();
}
- sp_node_adjust_knot(n, -which);
+ sp_node_adjust_handle(n, -which);
return FALSE;
}
@@ -2757,7 +2798,7 @@ static gboolean node_ctrl_request(SPKnot *knot, NR::Point *p, guint state, gpoin
/**
* Node handle moved callback.
*/
-static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data)
+static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
@@ -2775,7 +2816,7 @@ static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer da
g_assert_not_reached();
}
- // calculate radial coordinates of the grabbed control, other control, and the mouse point
+ // calculate radial coordinates of the grabbed handle, its other handle, and the mouse point
Radial rme(me->pos - n->pos);
Radial rother(other->pos - n->pos);
Radial rnew(*p - n->pos);
@@ -2787,7 +2828,7 @@ static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer da
// 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) {
- // ortho doesn't exist: original control was zero length.
+ // 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,
@@ -2851,7 +2892,7 @@ static void node_ctrl_moved(SPKnot *knot, NR::Point *p, guint state, gpointer da
/**
* Node handle event callback.
*/
-static gboolean node_ctrl_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
+static gboolean node_handle_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
{
gboolean ret = FALSE;
switch (event->type) {
@@ -2972,7 +3013,9 @@ static void node_rotate_one (Inkscape::NodePath::Node *n, gdouble angle, int whi
other->pos = n->pos + NR::Point(rother);
}
- sp_node_ensure_ctrls(n);
+ // this function is only called from sp_nodepath_selected_nodes_rotate that will update display at the end,
+ // so here we just move all the knots without emitting move signals, for speed
+ sp_node_update_handles(n, false);
}
/**
@@ -3015,13 +3058,11 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
n->pos *= t;
n->n.pos *= t;
n->p.pos *= t;
- sp_node_ensure_ctrls(n);
+ sp_node_update_handles(n, false);
}
}
- update_object(nodepath);
- /// \todo fixme: use _keyed
- update_repr(nodepath);
+ sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n");
}
/**
@@ -3104,7 +3145,9 @@ static void node_scale_one (Inkscape::NodePath::Node *n, gdouble grow, int which
other->pos = n->pos + NR::Point(rother);
}
- sp_node_ensure_ctrls(n);
+ // this function is only called from sp_nodepath_selected_nodes_scale that will update display at the end,
+ // so here we just move all the knots without emitting move signals, for speed
+ sp_node_update_handles(n, false);
}
/**
@@ -3140,13 +3183,11 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
n->pos *= t;
n->n.pos *= t;
n->p.pos *= t;
- sp_node_ensure_ctrls(n);
+ sp_node_update_handles(n, false);
}
}
- update_object(nodepath);
- /// \todo fixme: use _keyed
- update_repr(nodepath);
+ sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n");
}
void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath, gdouble const grow, int const which)
double temp = n->p.pos[axis];
n->p.pos[axis] = n->n.pos[axis];
n->n.pos[axis] = temp;
- sp_node_ensure_ctrls(n);
+ sp_node_update_handles(n, false);
} else {
// scale nodes as an "object":
n->pos *= t;
n->n.pos *= t;
n->p.pos *= t;
- sp_node_ensure_ctrls(n);
+ sp_node_update_handles(n, false);
}
}
- update_object(nodepath);
- /// \todo fixme: use _keyed
- update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath);
}
//-----------------------------------------------
@@ -3215,13 +3254,9 @@ static Inkscape::NodePath::SubPath *sp_nodepath_subpath_new(Inkscape::NodePath::
s->first = NULL;
s->last = NULL;
- // do not use prepend here because:
- // if you have a path like "subpath_1 subpath_2 ... subpath_k" in the svg, you end up with
- // subpath_k -> ... ->subpath_1 in the nodepath structure. thus the i-th node of the svg is not
- // the i-th node in the nodepath (only if there are multiple subpaths)
- // note that the problem only arise when called from subpath_from_bpath(), since for all the other
- // cases, the repr is updated after the call to sp_nodepath_subpath_new()
- nodepath->subpaths = g_list_append /*g_list_prepend*/ (nodepath->subpaths, s);
+ // using prepend here saves up to 10% of time on paths with many subpaths, but requires that
+ // the caller reverses the list after it's ready (this is done in sp_nodepath_new)
+ nodepath->subpaths = g_list_prepend (nodepath->subpaths, s);
return s;
}
@@ -3381,7 +3416,7 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *
g_signal_connect(G_OBJECT(n->knot), "request", G_CALLBACK(node_request), n);
sp_knot_show(n->knot);
- // We only create side knots and lines on demand
+ // We only create handle knots and lines on demand
n->p.knot = NULL;
n->p.line = NULL;
n->n.knot = NULL;
g_assert(node);
g_assert(node->subpath);
g_assert(SP_IS_KNOT(node->knot));
-// g_assert(g_list_find(node->subpath->nodes, node));
Inkscape::NodePath::SubPath *sp = node->subpath;
}
/**
- * Returns one of the node's two knots (node sides).
+ * Returns one of the node's two sides.
* \param which Indicates which side.
* \return Pointer to previous node side if which==-1, next if which==1.
*/
@@ -3471,9 +3505,9 @@ static Inkscape::NodePath::NodeSide *sp_node_get_side(Inkscape::NodePath::Node *
}
/**
- * Return knot on other side of node.
+ * Return the other side of the node, given one of its sides.
*/
-static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me)
+static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *me)
{
g_assert(node);
@@ -3486,7 +3520,7 @@ static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::N
}
/**
- * Return NRPathcode on this knot's side of the node.
+ * Return NRPathcode on the given side of the node.
*/
static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me)
{