diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 34c850d086099b87a8bf33c85226ebc46ef18de8..8f17ae0133122477bd60f9583553eed265fa15fb 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
#include "preferences.h"
#include "sp-metrics.h"
#include "sp-path.h"
+#include "sp-text.h"
+#include "sp-shape.h"
#include "libnr/nr-matrix-ops.h"
#include "svg/svg.h"
#include "verbs.h"
-#include "display/bezier-utils.h"
+#include <2geom/bezier-utils.h>
#include <vector>
#include <algorithm>
#include <cstring>
@@ -132,7 +134,7 @@ static gboolean node_request(SPKnot *knot, Geom::Point const &p, guint state, gp
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, Geom::Point const &p, guint state, gpointer data);
+static gboolean node_handle_request(SPKnot *knot, Geom::Point &p, guint state, gpointer data);
static void node_handle_moved(SPKnot *knot, Geom::Point const &p, guint state, gpointer data);
static gboolean node_handle_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n);
@@ -159,11 +161,11 @@ static void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve)
Inkscape::NodePath::Node * Inkscape::NodePath::Path::active_node = NULL;
static SPCanvasItem *
-sp_nodepath_make_helper_item(Inkscape::NodePath::Path *np, /*SPDesktop *desktop, */const SPCurve *curve, bool show = false) {
+sp_nodepath_make_helper_item(Inkscape::NodePath::Path *np, /*SPDesktop *desktop, */const SPCurve *curve, bool show = false, guint32 color = 0xff0000ff) {
SPCurve *helper_curve = curve->copy();
helper_curve->transform(np->i2d);
SPCanvasItem *helper_path = sp_canvas_bpath_new(sp_desktop_controls(np->desktop), helper_curve);
- sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(helper_path), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(helper_path), 0, SP_WIND_RULE_NONZERO);
sp_canvas_item_move_to_z(helper_path, 0);
if (show) {
@@ -173,12 +175,6 @@ sp_nodepath_make_helper_item(Inkscape::NodePath::Path *np, /*SPDesktop *desktop,
return helper_path;
}
-static SPCanvasItem *
-canvasitem_from_pathvec(Inkscape::NodePath::Path *np, Geom::PathVector const &pathv, bool show) {
- SPCurve *helper_curve = new SPCurve(pathv);
- return sp_nodepath_make_helper_item(np, helper_curve, show);
-}
-
static void
sp_nodepath_create_helperpaths(Inkscape::NodePath::Path *np) {
//std::map<Inkscape::LivePathEffect::Effect *, std::vector<SPCanvasItem *> > helper_path_vec;
// create new canvas items from the effect's helper paths
std::vector<Geom::PathVector> hpaths = lpe->getHelperPaths(lpeitem);
for (std::vector<Geom::PathVector>::iterator j = hpaths.begin(); j != hpaths.end(); ++j) {
- np->helper_path_vec[lpe].push_back(canvasitem_from_pathvec(np, *j, true));
+ SPCurve *helper_curve = new SPCurve(*j);
+ SPCanvasItem * canvasitem = sp_nodepath_make_helper_item(np, helper_curve, true, 0x509050dd);
+ np->helper_path_vec[lpe].push_back(canvasitem);
+ helper_curve->unref();
}
}
}
}
+static void
+sp_nodepath_destroy_helperpaths(Inkscape::NodePath::Path *np) {
+ for (HelperPathList::iterator i = np->helper_path_vec.begin(); i != np->helper_path_vec.end(); ++i) {
+ for (std::vector<SPCanvasItem *>::iterator j = (*i).second.begin(); j != (*i).second.end(); ++j) {
+ GtkObject *temp = *j;
+ *j = NULL;
+ gtk_object_destroy(temp);
+ }
+ }
+ np->helper_path_vec.clear();
+}
+
+/** updates canvas items from the effect's helper paths */
void
sp_nodepath_update_helperpaths(Inkscape::NodePath::Path *np) {
//std::map<Inkscape::LivePathEffect::Effect *, std::vector<SPCanvasItem *> > helper_path_vec;
SPLPEItem *lpeitem = SP_LPE_ITEM(np->item);
PathEffectList lpelist = sp_lpe_item_get_effect_list(lpeitem);
+
+ /* The number or type or LPEs may have changed, so we need to clear and recreate our
+ * helper_path_vec to make sure it is in sync */
+ sp_nodepath_destroy_helperpaths(np);
+ sp_nodepath_create_helperpaths(np);
+
for (PathEffectList::iterator i = lpelist.begin(); i != lpelist.end(); ++i) {
Inkscape::LivePathEffect::Effect *lpe = (*i)->lpeobject->get_lpe();
if (lpe) {
- /* update canvas items from the effect's helper paths; note that this code relies on the
- * fact that getHelperPaths() will always return the same number of helperpaths in the same
- * order as during their creation in sp_nodepath_create_helperpaths
- */
std::vector<Geom::PathVector> hpaths = lpe->getHelperPaths(lpeitem);
for (unsigned int j = 0; j < hpaths.size(); ++j) {
SPCurve *curve = new SPCurve(hpaths[j]);
}
}
-static void
-sp_nodepath_destroy_helperpaths(Inkscape::NodePath::Path *np) {
- for (HelperPathList::iterator i = np->helper_path_vec.begin(); i != np->helper_path_vec.end(); ++i) {
- for (std::vector<SPCanvasItem *>::iterator j = (*i).second.begin(); j != (*i).second.end(); ++j) {
- GtkObject *temp = *j;
- *j = NULL;
- gtk_object_destroy(temp);
- }
- }
- np->helper_path_vec.clear();
-}
-
-
/**
* \brief Creates new nodepath from item
*
+ * If repr_key_in is not NULL, object *has* to be a LivePathEffectObject !
+ *
* \todo create proper constructor for nodepath::path, this method returns null a constructor cannot so this cannot be simply converted to constructor.
*/
Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, bool show_handles, const char * repr_key_in, SPItem *item)
{
+ if (repr_key_in) {
+ g_assert(IS_LIVEPATHEFFECT(object));
+ }
+
Inkscape::XML::Node *repr = object->repr;
/** \todo
Inkscape::LivePathEffect::Effect *lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(object));
if (lpe && lpe->isVisible() && lpe->showOrigPath()) {
np->show_helperpath = true;
- }
+ }
}
np->straight_path = false;
if (IS_LIVEPATHEFFECT(object) && item) {
np->item = SP_ITEM(object);
}
+ np->drag_origin_mouse = Geom::Point(NR_HUGE, NR_HUGE);
+
// we need to update item's transform from the repr here,
// because they may be out of sync when we respond
// to a change in repr by regenerating nodepath --bb
np->d2i = np->i2d.inverse();
np->repr = repr;
- if (repr_key_in) { // apparently the object is an LPEObject (this is a dirty check, hopefully nobody tries feeding non-lpeobjects into this method with non-null repr_key_in)
+ if (repr_key_in) { // apparently the object is an LPEObject
np->repr_key = g_strdup(repr_key_in);
np->repr_nodetypes_key = g_strconcat(np->repr_key, "-nodetypes", NULL);
Inkscape::LivePathEffect::Effect * lpe = LIVEPATHEFFECT(object)->get_lpe();
// Draw helper curve
if (np->show_helperpath) {
- np->helper_path = sp_nodepath_make_helper_item(np, /*desktop, */np->curve, true);
+ np->helper_path = sp_nodepath_make_helper_item(np, /*desktop, */np->curve, true, np->helperpath_rgba);
}
sp_nodepath_create_helperpaths(np);
@@ -1062,7 +1071,10 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode
start->type = Inkscape::NodePath::NODE_SMOOTH;
if (end->type == Inkscape::NodePath::NODE_AUTO)
end->type = Inkscape::NodePath::NODE_SMOOTH;
-
+
+ start->n.pos = start->pos;
+ end->p.pos = end->pos;
+
sp_node_adjust_handle(start, -1);
sp_node_adjust_handle(end, 1);
@@ -1147,10 +1159,10 @@ sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSi
other_to_me = &othernode->n;
} else if (&node->n == side) {
other_to_me = &othernode->p;
- }
+ }
if (!other_to_me)
return false;
- bool is_line =
+ bool is_line =
(Geom::L2(othernode->pos - other_to_me->pos) < 1e-6 &&
Geom::L2(node->pos - side->pos) < 1e-6);
return is_line;
@@ -1159,7 +1171,7 @@ sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSi
/**
* Same as sp_nodepath_set_node_type(), but also converts, if necessary, adjacent segments from
* lines to curves. If adjacent to one line segment, pulls out or rotates opposite handle to align
- * with that segment, procucing half-smooth node. If already half-smooth, pull out the second handle too.
+ * with that segment, procucing half-smooth node. If already half-smooth, pull out the second handle too.
* If already cusp and set to cusp, retracts handles.
*/
void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
@@ -1173,9 +1185,9 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) {
-/*
+/*
Here's the algorithm of converting node to smooth (Shift+S or toolbar button), in pseudocode:
-
+
if (two_handles) {
// do nothing, adjust_handles called via set_node_type will line them up
} else if (one_handle) {
@@ -1189,7 +1201,9 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
// pull opposite handle in line with the existing one
}
} else if (no_handles) {
- if (both_segments_are_lines OR both_segments_are_curves) {
+ if (both_segments_are_lines
+ OR both_segments_are_curves
+ OR one_is_line_but_the_curveside_node_is_selected_and_has_two_handles) {
//pull both handles
} else {
// pull the handle opposite to line segment, making node half-smooth
@@ -1201,6 +1215,8 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
bool p_is_line = sp_node_side_is_line(node, &node->p);
bool n_is_line = sp_node_side_is_line(node, &node->n);
+#define NODE_HAS_BOTH_HANDLES(node) ((Geom::L2(node->pos - node->n.pos) > 1e-6) && (Geom::L2(node->pos - node->p.pos) > 1e-6))
+
if (p_has_handle && n_has_handle) {
// do nothing, adjust_handles will line them up
} else if (p_has_handle || n_has_handle) {
@@ -1209,6 +1225,7 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
Radial handle (node->pos - node->p.pos);
if (fabs(line.a - handle.a) < 1e-3) { // lined up
// already half-smooth; pull opposite handle too making it fully smooth
+ node->n.other->code = NR_CURVETO;
node->n.pos = node->pos + (node->n.other->pos - node->pos) / 3;
} else {
// do nothing, adjust_handles will line the handle up, producing a half-smooth node
@@ -1218,6 +1235,7 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
Radial handle (node->pos - node->n.pos);
if (fabs(line.a - handle.a) < 1e-3) { // lined up
// already half-smooth; pull opposite handle too making it fully smooth
+ node->code = NR_CURVETO;
node->p.pos = node->pos + (node->p.other->pos - node->pos) / 3;
} else {
// do nothing, adjust_handles will line the handle up, producing a half-smooth node
@@ -1238,9 +1256,13 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
node->p.pos = node->pos - (len / Geom::L2(node->n.pos - node->pos)) * (node->n.pos - node->pos);
}
} else if (!p_has_handle && !n_has_handle) {
- if ((p_is_line && n_is_line) || (!p_is_line && node->p.other && !n_is_line && node->n.other)) {
- // no handles, but both segments are either lnes or curves:
- //pull both handles
+ if ((p_is_line && n_is_line) || (!p_is_line && node->p.other && !n_is_line && node->n.other) ||
+ (n_is_line && node->p.other && node->p.other->selected && NODE_HAS_BOTH_HANDLES(node->p.other)) ||
+ (p_is_line && node->n.other && node->n.other->selected && NODE_HAS_BOTH_HANDLES(node->n.other))
+ ) {
+ // no handles, but: both segments are either lines or curves; or: one is line and the
+ // node at the other side is selected (so it was just smoothed too!) and now has both
+ // handles: then pull both handles here
// convert both to curves:
node->code = NR_CURVETO;
Inkscape::NodePath::Node *node_n = NULL;
if (node->p.other) {
- if (node->code == NR_LINETO) {
+ if (sp_node_side_is_line(node, &node->p)) {
sp_node_adjust_handle(node, 1);
sp_node_adjust_handle(node->p.other, -1);
node_p = node->p.other;
}
}
if (node->n.other) {
- if (node->n.other->code == NR_LINETO) {
+ if (sp_node_side_is_line(node, &node->n)) {
sp_node_adjust_handle(node, -1);
sp_node_adjust_handle(node->n.other, 1);
node_n = node->n.other;
* Call sp_node_moveto() for node selection and handle possible snapping.
*/
static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, Geom::Coord dx, Geom::Coord dy,
- bool const snap, bool constrained = false,
+ bool const snap, bool constrained = false,
Inkscape::Snapper::ConstraintLine const &constraint = Geom::Point())
{
- Geom::Coord best = NR_HUGE;
Geom::Point delta(dx, dy);
Geom::Point best_pt = delta;
- Inkscape::SnappedPoint best_abs;
-
- if (snap) {
+ Inkscape::SnappedPoint best;
+
+ if (snap) {
/* When dragging a (selected) node, it should only snap to other nodes (i.e. unselected nodes), and
- * not to itself. The snapper however can not tell which nodes are selected and which are not, so we
+ * not to itself. The snapper however can not tell which nodes are selected and which are not, so we
* must provide that information. */
-
- // Build a list of the unselected nodes to which the snapper should snap
- std::vector<Geom::Point> unselected_nodes;
+
+ // Build a list of the unselected nodes to which the snapper should snap
+ std::vector<std::pair<Geom::Point, int> > unselected_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) {
- unselected_nodes.push_back(to_2geom(node->pos));
- }
+ unselected_nodes.push_back(std::make_pair(to_2geom(node->pos), node->type == Inkscape::NodePath::NODE_SMOOTH ? Inkscape::SNAPTARGET_NODE_SMOOTH : Inkscape::SNAPTARGET_NODE_CUSP));
+ }
}
- }
-
+ }
+
SnapManager &m = nodepath->desktop->namedview->snap_manager;
-
- for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+
+ // When only the node closest to the mouse pointer is to be snapped
+ // then we will not even try to snap to other points and discard those immediately
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ bool closest_only = prefs->getBool("/options/snapclosestonly/value", false);
+
+ Inkscape::NodePath::Node *closest_node = NULL;
+ Geom::Coord closest_dist = NR_HUGE;
+
+ if (closest_only) {
+ for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ Geom::Coord dist = Geom::L2(nodepath->drag_origin_mouse - n->origin);
+ if (dist < closest_dist) {
+ closest_node = n;
+ closest_dist = dist;
+ }
+ }
+ }
+
+ // Iterate through all selected nodes
+ m.setup(nodepath->desktop, false, nodepath->item, &unselected_nodes);
+ for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
- m.setup(nodepath->desktop, false, SP_PATH(n->subpath->nodepath->item), &unselected_nodes);
- Inkscape::SnappedPoint s;
- if (constrained) {
- Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint;
- dedicated_constraint.setPoint(n->pos);
- s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, to_2geom(n->pos + delta), dedicated_constraint);
- } else {
- s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, to_2geom(n->pos + delta));
- }
- if (s.getSnapped() && (s.getDistance() < best)) {
- best = s.getDistance();
- best_abs = s;
- best_pt = from_2geom(s.getPoint()) - n->pos;
+ if (!closest_only || n == closest_node) { //try to snap either all selected nodes or only the closest one
+ Inkscape::SnappedPoint s;
+ Inkscape::SnapSourceType source_type = (n->type == Inkscape::NodePath::NODE_SMOOTH ? Inkscape::SNAPSOURCE_NODE_SMOOTH : Inkscape::SNAPSOURCE_NODE_CUSP);
+ if (constrained) {
+ Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint;
+ dedicated_constraint.setPoint(n->pos);
+ s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, to_2geom(n->pos + delta), source_type, dedicated_constraint, false);
+ } else {
+ s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, to_2geom(n->pos + delta), source_type);
+ }
+
+ if (s.getSnapped()) {
+ s.setPointerDistance(Geom::L2(nodepath->drag_origin_mouse - n->origin));
+ if (!s.isOtherSnapBetter(best, true)) {
+ best = s;
+ best_pt = from_2geom(s.getPoint()) - n->pos;
+ }
+ }
}
}
-
- if (best_abs.getSnapped()) {
- nodepath->desktop->snapindicator->set_new_snappoint(best_abs);
+
+ if (best.getSnapped()) {
+ nodepath->desktop->snapindicator->set_new_snaptarget(best);
} else {
- nodepath->desktop->snapindicator->remove_snappoint();
+ nodepath->desktop->snapindicator->remove_snaptarget();
}
}
@@ -2267,13 +2314,13 @@ static void do_node_selected_join(Inkscape::NodePath::Path *nodepath, Inkscape::
}
if (b == sb->first) {
- // copy all nodes from b to a, forward
+ // copy all nodes from b to a, forward
sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->first->n.pos);
for (n = sb->first->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) {
- // copy all nodes from b to a, backward
+ // copy all nodes from b to a, backward
sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->last->p.pos);
for (n = sb->last->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);
//would decreasing error create a better fitting approximation?
gdouble error = 1.0;
gint ret;
- ret = sp_bezier_fit_cubic (bez, adata, data.size(), error);
+ ret = Geom::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,
@@ -3304,7 +3351,7 @@ static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adj
}
if (node->type == Inkscape::NodePath::NODE_SYMM) {
- // symmetrize
+ // symmetrize
me->pos = 2 * node->pos - other->pos;
return;
} else {
Geom::Point leg_prev = to_2geom(node->p.other->pos - node->pos);
Geom::Point leg_next = to_2geom(node->n.other->pos - node->pos);
-
+
double norm_leg_prev = Geom::L2(leg_prev);
double norm_leg_next = Geom::L2(leg_next);
-
+
Geom::Point delta;
if (norm_leg_next > 0.0) {
delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev;
delta.normalize();
}
-
+
node->p.pos = node->pos - norm_leg_prev / 3 * delta;
node->n.pos = node->pos + norm_leg_next / 3 * delta;
}
/**
* Mouse grabbed node callback.
*/
-static void node_grabbed(SPKnot */*knot*/, guint state, gpointer data)
+static void node_grabbed(SPKnot *knot, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
}
n->is_dragging = true;
+ // Reconstruct and store the location of the mouse pointer at the time when we started dragging (needed for snapping)
+ n->subpath->nodepath->drag_origin_mouse = knot->grabbed_rel_pos + knot->drag_origin;
+
sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5);
sp_nodepath_remember_origins (n->subpath->nodepath);
n->dragging_out = NULL;
n->is_dragging = false;
+ n->subpath->nodepath->drag_origin_mouse = Geom::Point(NR_HUGE, NR_HUGE);
sp_canvas_end_forced_full_redraws(n->subpath->nodepath->desktop->canvas);
sp_nodepath_update_repr(n->subpath->nodepath, _("Move nodes"));
@@ -3619,7 +3670,7 @@ node_request(SPKnot */*knot*/, Geom::Point const &p, guint state, gpointer data)
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
- n->subpath->nodepath->desktop->snapindicator->remove_snappoint();
+ n->subpath->nodepath->desktop->snapindicator->remove_snaptarget();
// If either (Shift and some handle retracted), or (we're already dragging out a handle)
if ( (!n->subpath->nodepath->straight_path) &&
@@ -3765,16 +3816,16 @@ node_request(SPKnot */*knot*/, Geom::Point const &p, guint state, gpointer data)
// move the node to the closest point
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
n->origin[Geom::X] + c[Geom::X] - n->pos[Geom::X],
- n->origin[Geom::Y] + c[Geom::Y] - n->pos[Geom::Y],
+ n->origin[Geom::Y] + c[Geom::Y] - n->pos[Geom::Y],
true);
} else { // constraining to hor/vert
if (fabs(p[Geom::X] - n->origin[Geom::X]) > fabs(p[Geom::Y] - n->origin[Geom::Y])) { // snap to hor
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
- p[Geom::X] - n->pos[Geom::X],
+ p[Geom::X] - n->pos[Geom::X],
n->origin[Geom::Y] - n->pos[Geom::Y],
- true,
+ true,
true, Inkscape::Snapper::ConstraintLine(component_vectors[Geom::X]));
} else { // snap to vert
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
/**
* Node handle "request" signal callback.
*/
-static gboolean node_handle_request(SPKnot *knot, Geom::Point const &p, guint state, gpointer data)
+static gboolean node_handle_request(SPKnot *knot, Geom::Point &p, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
@@ -3902,14 +3953,15 @@ static gboolean node_handle_request(SPKnot *knot, Geom::Point const &p, guint st
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop, true, n->subpath->nodepath->item);
Inkscape::SnappedPoint s;
-
+
if ((state & GDK_SHIFT_MASK) != 0) {
// We will not try to snap when the shift-key is pressed
- // so remove the old snap indicator and don't wait for it to time-out
- desktop->snapindicator->remove_snappoint();
+ // so remove the old snap indicator and don't wait for it to time-out
+ desktop->snapindicator->remove_snaptarget();
}
Inkscape::NodePath::Node *othernode = opposite->other;
+ Inkscape::SnapSourceType source_type = (n->type == Inkscape::NodePath::NODE_SMOOTH ? Inkscape::SNAPSOURCE_NODE_SMOOTH : Inkscape::SNAPSOURCE_NODE_CUSP);
if (othernode) {
if ((n->type != Inkscape::NodePath::NODE_CUSP) && sp_node_side_is_line(n, opposite)) {
/* We are smooth node adjacent with line */
@@ -3918,25 +3970,26 @@ static gboolean node_handle_request(SPKnot *knot, Geom::Point const &p, guint st
Inkscape::NodePath::Node *othernode = opposite->other;
Geom::Point const ndelta = n->pos - othernode->pos;
Geom::Coord const linelen = Geom::L2(ndelta);
- Geom::Point ptemp = p;
if (len > NR_EPSILON && linelen > NR_EPSILON) {
Geom::Coord const scal = dot(delta, ndelta) / linelen;
- ptemp = n->pos + (scal / linelen) * ndelta;
+ p = n->pos + (scal / linelen) * ndelta;
}
if ((state & GDK_SHIFT_MASK) == 0) {
- s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, ptemp, Inkscape::Snapper::ConstraintLine(ptemp, ndelta));
+ s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p, source_type, Inkscape::Snapper::ConstraintLine(p, ndelta), false);
}
} else {
if ((state & GDK_SHIFT_MASK) == 0) {
- s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p);
+ s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p, source_type);
}
}
} else {
if ((state & GDK_SHIFT_MASK) == 0) {
- s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p);
+ s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p, source_type);
}
}
-
+
+ s.getPoint(p);
+
sp_node_adjust_handle(n, -which);
return FALSE;
@@ -4016,8 +4069,8 @@ static void node_handle_moved(SPKnot *knot, Geom::Point const &p, guint state, g
rnew.r = me->origin_radial.r;
}
- if (( n->type !=Inkscape::NodePath::NODE_CUSP || (state & GDK_SHIFT_MASK))
- && rme.a != HUGE_VAL && rnew.a != HUGE_VAL && (fabs(rme.a - rnew.a) > 0.001 || n->type ==Inkscape::NodePath::NODE_SYMM)) {
+ if (( n->type !=Inkscape::NodePath::NODE_CUSP || (!n->dragging_out && (state & GDK_SHIFT_MASK)))
+ && (rme.a != HUGE_VAL) && (rnew.a != HUGE_VAL) && ((fabs(rme.a - rnew.a) > 0.001) || (n->type ==Inkscape::NodePath::NODE_SYMM))) {
// rotate the other handle correspondingly, if both old and new angles exist and are not the same
rother.a += rnew.a - rme.a;
other->pos = Geom::Point(rother) + n->pos;
@@ -4991,11 +5044,11 @@ sp_nodepath_path_to_canvasitem(Inkscape::NodePath::Path *np, SPPath *path) {
}
*/
-/*
+
+/// \todo this code to generate a helper canvasitem from an spcurve should be moved to different file
SPCanvasItem *
-sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const SPItem *item, guint32 color = 0xff0000ff) {
+sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const Geom::Matrix & i2d, guint32 color = 0xff0000ff) {
SPCurve *flash_curve = curve->copy();
- Geom::Matrix i2d = item ? sp_item_i2d_affine(item) : Geom::identity();
flash_curve->transform(i2d);
SPCanvasItem * canvasitem = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), flash_curve);
// would be nice if its color could be XORed or something, now it is invisible for red stroked objects...
@@ -5008,30 +5061,38 @@ sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const SPItem
}
SPCanvasItem *
-sp_nodepath_generate_helperpath(SPDesktop *desktop, SPPath *path) {
- Inkscape::Preferences *prefs = Inkscape::Preferences::get();
- return sp_nodepath_generate_helperpath(desktop, sp_path_get_curve_for_edit(path), SP_ITEM(path),
- prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff));
-}
-*/
+sp_nodepath_generate_helperpath(SPDesktop *desktop, SPItem *item) {
+ if (!item || !desktop) {
+ return NULL;
+ }
-SPCanvasItem *
-sp_nodepath_helperpath_from_path(SPDesktop *desktop, SPPath *path) {
- SPCurve *flash_curve = sp_path_get_curve_for_edit(path)->copy();
- Geom::Matrix i2d = sp_item_i2d_affine(SP_ITEM(path));
- flash_curve->transform(i2d);
- SPCanvasItem * canvasitem = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), flash_curve);
- // would be nice if its color could be XORed or something, now it is invisible for red stroked objects...
- // unless we also flash the nodes...
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
guint32 color = prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff);
- sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
- sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvasitem), 0, SP_WIND_RULE_NONZERO);
- sp_canvas_item_show(canvasitem);
- flash_curve->unref();
- return canvasitem;
+
+ Geom::Matrix i2d = sp_item_i2d_affine(item);
+
+ SPCurve *curve = NULL;
+ if (SP_IS_PATH(item)) {
+ curve = sp_path_get_curve_for_edit(SP_PATH(item));
+ } else if ( SP_IS_SHAPE(item) && SP_SHAPE(item)->curve ) {
+ curve = sp_shape_get_curve (SP_SHAPE(item));
+ } else if ( SP_IS_TEXT(item) ) {
+ // do not display helperpath for text - we cannot do anything with it in Node tool anyway
+ // curve = SP_TEXT(item)->getNormalizedBpath();
+ return NULL;
+ } else {
+ g_warning ("-----> sp_nodepath_generate_helperpath(SPDesktop *desktop, SPItem *item): TODO: generate the helper path for this item type!\n");
+ return NULL;
+ }
+
+ SPCanvasItem * helperpath = sp_nodepath_generate_helperpath(desktop, curve, i2d, color);
+
+ curve->unref();
+
+ return helperpath;
}
+
// TODO: Merge this with sp_nodepath_make_helper_item()!
void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) {
np->show_helperpath = show;