1 #define __SP_DESKTOP_SNAP_C__
3 /**
4 * \file snap.cpp
5 * \brief SnapManager class.
6 *
7 * Authors:
8 * Lauris Kaplinski <lauris@kaplinski.com>
9 * Frank Felfe <innerspace@iname.com>
10 * Nathan Hurst <njh@njhurst.com>
11 * Carl Hetherington <inkscape@carlh.net>
12 * Diederik van Lierop <mail@diedenrezi.nl>
13 *
14 * Copyright (C) 2006-2007 Johan Engelen <johan@shouraizou.nl>
15 * Copyrigth (C) 2004 Nathan Hurst
16 * Copyright (C) 1999-2010 Authors
17 *
18 * Released under GNU GPL, read the file 'COPYING' for more information
19 */
21 #include <utility>
23 #include "sp-namedview.h"
24 #include "snap.h"
25 #include "snapped-line.h"
26 #include "snapped-curve.h"
28 #include "display/canvas-grid.h"
29 #include "display/snap-indicator.h"
31 #include "inkscape.h"
32 #include "desktop.h"
33 #include "selection.h"
34 #include "sp-guide.h"
35 #include "preferences.h"
36 #include "event-context.h"
37 using std::vector;
39 /**
40 * Construct a SnapManager for a SPNamedView.
41 *
42 * \param v `Owning' SPNamedView.
43 */
45 SnapManager::SnapManager(SPNamedView const *v) :
46 guide(this, 0),
47 object(this, 0),
48 snapprefs(),
49 _named_view(v)
50 {
51 }
53 /**
54 * \brief Return a list of snappers
55 *
56 * Inkscape snaps to objects, grids, and guides. For each of these snap targets a
57 * separate class is used, which has been derived from the base Snapper class. The
58 * getSnappers() method returns a list of pointers to instances of this class. This
59 * list contains exactly one instance of the guide snapper and of the object snapper
60 * class, but any number of grid snappers (because each grid has its own snapper
61 * instance)
62 *
63 * \return List of snappers that we use.
64 */
65 SnapManager::SnapperList
66 SnapManager::getSnappers() const
67 {
68 SnapManager::SnapperList s;
69 s.push_back(&guide);
70 s.push_back(&object);
72 SnapManager::SnapperList gs = getGridSnappers();
73 s.splice(s.begin(), gs);
75 return s;
76 }
78 /**
79 * \brief Return a list of gridsnappers
80 *
81 * Each grid has its own instance of the snapper class. This way snapping can
82 * be enabled per grid individually. A list will be returned containing the
83 * pointers to these instances, but only for grids that are being displayed
84 * and for which snapping is enabled.
85 *
86 * \return List of gridsnappers that we use.
87 */
88 SnapManager::SnapperList
89 SnapManager::getGridSnappers() const
90 {
91 SnapperList s;
93 if (_desktop && _desktop->gridsEnabled() && snapprefs.getSnapToGrids()) {
94 for ( GSList const *l = _named_view->grids; l != NULL; l = l->next) {
95 Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
96 s.push_back(grid->snapper);
97 }
98 }
100 return s;
101 }
103 /**
104 * \brief Return true if any snapping might occur, whether its to grids, guides or objects
105 *
106 * Each snapper instance handles its own snapping target, e.g. grids, guides or
107 * objects. This method iterates through all these snapper instances and returns
108 * true if any of the snappers might possible snap, considering only the relevant
109 * snapping preferences.
110 *
111 * \return true if one of the snappers will try to snap to something.
112 */
114 bool SnapManager::someSnapperMightSnap() const
115 {
116 if ( !snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally() ) {
117 return false;
118 }
120 SnapperList const s = getSnappers();
121 SnapperList::const_iterator i = s.begin();
122 while (i != s.end() && (*i)->ThisSnapperMightSnap() == false) {
123 i++;
124 }
126 return (i != s.end());
127 }
129 /**
130 * \return true if one of the grids might be snapped to.
131 */
133 bool SnapManager::gridSnapperMightSnap() const
134 {
135 if ( !snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally() ) {
136 return false;
137 }
139 SnapperList const s = getGridSnappers();
140 SnapperList::const_iterator i = s.begin();
141 while (i != s.end() && (*i)->ThisSnapperMightSnap() == false) {
142 i++;
143 }
145 return (i != s.end());
146 }
148 /**
149 * \brief Try to snap a point to grids, guides or objects.
150 *
151 * Try to snap a point to grids, guides or objects, in two degrees-of-freedom,
152 * i.e. snap in any direction on the two dimensional canvas to the nearest
153 * snap target. freeSnapReturnByRef() is equal in snapping behavior to
154 * freeSnap(), but the former returns the snapped point trough the referenced
155 * parameter p. This parameter p initially contains the position of the snap
156 * source and will we overwritten by the target position if snapping has occurred.
157 * This makes snapping transparent to the calling code. If this is not desired
158 * because either the calling code must know whether snapping has occurred, or
159 * because the original position should not be touched, then freeSnap() should be
160 * called instead.
161 *
162 * PS:
163 * 1) SnapManager::setup() must have been called before calling this method,
164 * but only once for a set of points
165 * 2) Only to be used when a single source point is to be snapped; it assumes
166 * that source_num = 0, which is inefficient when snapping sets our source points
167 *
168 * \param p Current position of the snap source; will be overwritten by the position of the snap target if snapping has occurred
169 * \param source_type Detailed description of the source type, will be used by the snap indicator
170 * \param bbox_to_snap Bounding box hulling the set of points, all from the same selection and having the same transformation
171 */
173 void SnapManager::freeSnapReturnByRef(Geom::Point &p,
174 Inkscape::SnapSourceType const source_type,
175 Geom::OptRect const &bbox_to_snap) const
176 {
177 //TODO: SnapCandidatePoint and point_type are somewhat redundant; can't we get rid of the point_type parameter?
178 Inkscape::SnappedPoint const s = freeSnap(Inkscape::SnapCandidatePoint(p, source_type), bbox_to_snap);
179 s.getPoint(p);
180 }
183 /**
184 * \brief Try to snap a point to grids, guides or objects.
185 *
186 * Try to snap a point to grids, guides or objects, in two degrees-of-freedom,
187 * i.e. snap in any direction on the two dimensional canvas to the nearest
188 * snap target. freeSnap() is equal in snapping behavior to
189 * freeSnapReturnByRef(). Please read the comments of the latter for more details
190 *
191 * PS: SnapManager::setup() must have been called before calling this method,
192 * but only once for a set of points
193 *
194 * \param p Source point to be snapped
195 * \param bbox_to_snap Bounding box hulling the set of points, all from the same selection and having the same transformation
196 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics
197 */
200 Inkscape::SnappedPoint SnapManager::freeSnap(Inkscape::SnapCandidatePoint const &p,
201 Geom::OptRect const &bbox_to_snap) const
202 {
203 if (!someSnapperMightSnap()) {
204 return Inkscape::SnappedPoint(p, Inkscape::SNAPTARGET_UNDEFINED, NR_HUGE, 0, false, false, false);
205 }
207 SnappedConstraints sc;
208 SnapperList const snappers = getSnappers();
210 for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
211 (*i)->freeSnap(sc, p, bbox_to_snap, &_items_to_ignore, _unselected_nodes);
212 }
214 return findBestSnap(p, sc, false);
215 }
217 void SnapManager::preSnap(Inkscape::SnapCandidatePoint const &p)
218 {
219 // setup() must have been called before calling this method!
221 if (_snapindicator) {
222 _snapindicator = false; // prevent other methods from drawing a snap indicator; we want to control this here
223 Inkscape::SnappedPoint s = freeSnap(p);
224 if (s.getSnapped()) {
225 _desktop->snapindicator->set_new_snaptarget(s, true);
226 } else {
227 _desktop->snapindicator->remove_snaptarget(true);
228 }
229 _snapindicator = true; // restore the original value
230 }
231 }
233 /**
234 * \brief Snap to the closest multiple of a grid pitch
235 *
236 * When pasting, we would like to snap to the grid. Problem is that we don't know which
237 * nodes were aligned to the grid at the time of copying, so we don't know which nodes
238 * to snap. If we'd snap an unaligned node to the grid, previously aligned nodes would
239 * become unaligned. That's undesirable. Instead we will make sure that the offset
240 * between the source and its pasted copy is a multiple of the grid pitch. If the source
241 * was aligned, then the copy will therefore also be aligned.
242 *
243 * PS: Whether we really find a multiple also depends on the snapping range! Most users
244 * will have "always snap" enabled though, in which case a multiple will always be found.
245 * PS2: When multiple grids are present then the result will become ambiguous. There is no
246 * way to control to which grid this method will snap.
247 *
248 * \param t Vector that represents the offset of the pasted copy with respect to the original
249 * \return Offset vector after snapping to the closest multiple of a grid pitch
250 */
252 Geom::Point SnapManager::multipleOfGridPitch(Geom::Point const &t, Geom::Point const &origin)
253 {
254 if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally())
255 return t;
257 if (_desktop && _desktop->gridsEnabled()) {
258 bool success = false;
259 Geom::Point nearest_multiple;
260 Geom::Coord nearest_distance = NR_HUGE;
261 Inkscape::SnappedPoint bestSnappedPoint(t);
263 // It will snap to the grid for which we find the closest snap. This might be a different
264 // grid than to which the objects were initially aligned. I don't see an easy way to fix
265 // this, so when using multiple grids one can get unexpected results
267 // Cannot use getGridSnappers() because we need both the grids AND their snappers
268 // Therefore we iterate through all grids manually
269 for (GSList const *l = _named_view->grids; l != NULL; l = l->next) {
270 Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
271 const Inkscape::Snapper* snapper = grid->snapper;
272 if (snapper && snapper->ThisSnapperMightSnap()) {
273 // To find the nearest multiple of the grid pitch for a given translation t, we
274 // will use the grid snapper. Simply snapping the value t to the grid will do, but
275 // only if the origin of the grid is at (0,0). If it's not then compensate for this
276 // in the translation t
277 Geom::Point const t_offset = t + grid->origin;
278 SnappedConstraints sc;
279 // Only the first three parameters are being used for grid snappers
280 snapper->freeSnap(sc, Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_GRID_PITCH),Geom::OptRect(), NULL, NULL);
281 // Find the best snap for this grid, including intersections of the grid-lines
282 bool old_val = _snapindicator;
283 _snapindicator = false;
284 Inkscape::SnappedPoint s = findBestSnap(Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_GRID_PITCH), sc, false, false, true);
285 _snapindicator = old_val;
286 if (s.getSnapped() && (s.getSnapDistance() < nearest_distance)) {
287 // use getSnapDistance() instead of getWeightedDistance() here because the pointer's position
288 // doesn't tell us anything about which node to snap
289 success = true;
290 nearest_multiple = s.getPoint() - to_2geom(grid->origin);
291 nearest_distance = s.getSnapDistance();
292 bestSnappedPoint = s;
293 }
294 }
295 }
297 if (success) {
298 bestSnappedPoint.setPoint(origin + nearest_multiple);
299 _desktop->snapindicator->set_new_snaptarget(bestSnappedPoint);
300 return nearest_multiple;
301 }
302 }
304 return t;
305 }
307 /**
308 * \brief Try to snap a point along a constraint line to grids, guides or objects.
309 *
310 * Try to snap a point to grids, guides or objects, in only one degree-of-freedom,
311 * i.e. snap in a specific direction on the two dimensional canvas to the nearest
312 * snap target.
313 *
314 * constrainedSnapReturnByRef() is equal in snapping behavior to
315 * constrainedSnap(), but the former returns the snapped point trough the referenced
316 * parameter p. This parameter p initially contains the position of the snap
317 * source and will we overwritten by the target position if snapping has occurred.
318 * This makes snapping transparent to the calling code. If this is not desired
319 * because either the calling code must know whether snapping has occurred, or
320 * because the original position should not be touched, then constrainedSnap() should
321 * be called instead.
322 *
323 * PS:
324 * 1) SnapManager::setup() must have been called before calling this method,
325 * but only once for a set of points
326 * 2) Only to be used when a single source point is to be snapped; it assumes
327 * that source_num = 0, which is inefficient when snapping sets our source points
329 *
330 * \param p Current position of the snap source; will be overwritten by the position of the snap target if snapping has occurred
331 * \param source_type Detailed description of the source type, will be used by the snap indicator
332 * \param constraint The direction or line along which snapping must occur
333 * \param bbox_to_snap Bounding box hulling the set of points, all from the same selection and having the same transformation
334 */
336 void SnapManager::constrainedSnapReturnByRef(Geom::Point &p,
337 Inkscape::SnapSourceType const source_type,
338 Inkscape::Snapper::SnapConstraint const &constraint,
339 Geom::OptRect const &bbox_to_snap) const
340 {
341 Inkscape::SnappedPoint const s = constrainedSnap(Inkscape::SnapCandidatePoint(p, source_type, 0), constraint, bbox_to_snap);
342 s.getPoint(p);
343 }
345 /**
346 * \brief Try to snap a point along a constraint line to grids, guides or objects.
347 *
348 * Try to snap a point to grids, guides or objects, in only one degree-of-freedom,
349 * i.e. snap in a specific direction on the two dimensional canvas to the nearest
350 * snap target. constrainedSnap is equal in snapping behavior to
351 * constrainedSnapReturnByRef(). Please read the comments of the latter for more details.
352 *
353 * PS: SnapManager::setup() must have been called before calling this method,
354 * but only once for a set of points
355 *
356 * \param p Source point to be snapped
357 * \param constraint The direction or line along which snapping must occur
358 * \param bbox_to_snap Bounding box hulling the set of points, all from the same selection and having the same transformation
359 */
361 Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::SnapCandidatePoint const &p,
362 Inkscape::Snapper::SnapConstraint const &constraint,
363 Geom::OptRect const &bbox_to_snap) const
364 {
365 // First project the mouse pointer onto the constraint
366 Geom::Point pp = constraint.projection(p.getPoint());
368 Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(pp, p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, NR_HUGE, 0, false, true, false);
369 if (constraint.isCircular()) {
370 Geom::Point v_orig = constraint.getDirection(); // vector from the origin to the original (untransformed) point
371 Geom::Point v_proj = pp - constraint.getPoint(); // vector from the origin to the projected point
372 Geom::Coord angle = atan2(Geom::dot(Geom::rot90(v_orig), v_proj), Geom::dot(v_orig, v_proj));
373 no_snap.setTransformation(Geom::Point(angle, angle)); // Store the rotation (in radians), needed in case of snapping while rotating
374 }
376 if (!someSnapperMightSnap()) {
377 // Always return point on constraint
378 return no_snap;
379 }
381 SnappedConstraints sc;
382 SnapperList const snappers = getSnappers();
383 for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
384 (*i)->constrainedSnap(sc, p, bbox_to_snap, constraint, &_items_to_ignore);
385 }
387 Inkscape::SnappedPoint result = findBestSnap(p, sc, true);
389 if (result.getSnapped()) {
390 // only change the snap indicator if we really snapped to something
391 if (_snapindicator) {
392 _desktop->snapindicator->set_new_snaptarget(result);
393 }
394 return result;
395 }
396 return no_snap;
397 }
399 /**
400 * \brief Try to snap a point of a guide to another guide or to a node
401 *
402 * Try to snap a point of a guide to another guide or to a node in two degrees-
403 * of-freedom, i.e. snap in any direction on the two dimensional canvas to the
404 * nearest snap target. This method is used when dragging or rotating a guide
405 *
406 * PS: SnapManager::setup() must have been called before calling this method,
407 *
408 * \param p Current position of the point on the guide that is to be snapped; will be overwritten by the position of the snap target if snapping has occurred
409 * \param guide_normal Vector normal to the guide line
410 */
411 void SnapManager::guideFreeSnap(Geom::Point &p, Geom::Point const &guide_normal, SPGuideDragType drag_type) const
412 {
413 if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally()) {
414 return;
415 }
417 if (!(object.GuidesMightSnap() || snapprefs.getSnapToGuides())) {
418 return;
419 }
421 Inkscape::SnapCandidatePoint candidate(p, Inkscape::SNAPSOURCE_GUIDE_ORIGIN);
422 if (drag_type == SP_DRAG_ROTATE) {
423 candidate = Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_GUIDE);
424 }
426 // Snap to nodes
427 SnappedConstraints sc;
428 if (object.GuidesMightSnap()) {
429 object.guideFreeSnap(sc, p, guide_normal);
430 }
432 // Snap to guides & grid lines
433 SnapperList snappers = getGridSnappers();
434 snappers.push_back(&guide);
435 for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
436 (*i)->freeSnap(sc, candidate, Geom::OptRect(), NULL, NULL);
437 }
439 // Snap to intersections of curves, but not to the curves themselves! (see _snapTranslatingGuideToNodes in object-snapper.cpp)
440 Inkscape::SnappedPoint const s = findBestSnap(candidate, sc, false, true);
442 s.getPoint(p);
443 }
445 /**
446 * \brief Try to snap a point on a guide to the intersection with another guide or a path
447 *
448 * Try to snap a point on a guide to the intersection of that guide with another
449 * guide or with a path. The snapped point will lie somewhere on the guide-line,
450 * making this is a constrained snap, i.e. in only one degree-of-freedom.
451 * This method is used when dragging the origin of the guide along the guide itself.
452 *
453 * PS: SnapManager::setup() must have been called before calling this method,
454 *
455 * \param p Current position of the point on the guide that is to be snapped; will be overwritten by the position of the snap target if snapping has occurred
456 * \param guide_normal Vector normal to the guide line
457 */
459 void SnapManager::guideConstrainedSnap(Geom::Point &p, SPGuide const &guideline) const
460 {
461 if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally()) {
462 return;
463 }
465 if (!(object.ThisSnapperMightSnap() || snapprefs.getSnapToGuides())) {
466 return;
467 }
469 Inkscape::SnapCandidatePoint candidate(p, Inkscape::SNAPSOURCE_GUIDE_ORIGIN, Inkscape::SNAPTARGET_UNDEFINED);
471 // Snap to nodes or paths
472 SnappedConstraints sc;
473 Inkscape::Snapper::SnapConstraint cl(guideline.point_on_line, Geom::rot90(guideline.normal_to_line));
474 if (object.ThisSnapperMightSnap()) {
475 object.constrainedSnap(sc, candidate, Geom::OptRect(), cl, NULL);
476 }
478 // Snap to guides & grid lines
479 SnapperList snappers = getGridSnappers();
480 snappers.push_back(&guide);
481 for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
482 (*i)->constrainedSnap(sc, candidate, Geom::OptRect(), cl, NULL);
483 }
485 Inkscape::SnappedPoint const s = findBestSnap(candidate, sc, false);
486 s.getPoint(p);
487 }
489 /**
490 * \brief Method for snapping sets of points while they are being transformed
491 *
492 * Method for snapping sets of points while they are being transformed, when using
493 * for example the selector tool. This method is for internal use only, and should
494 * not have to be called directly. Use freeSnapTransalation(), constrainedSnapScale(),
495 * etc. instead.
496 *
497 * This is what is being done in this method: transform each point, find out whether
498 * a free snap or constrained snap is more appropriate, do the snapping, calculate
499 * some metrics to quantify the snap "distance", and see if it's better than the
500 * previous snap. Finally, the best ("nearest") snap from all these points is returned.
501 *
502 * \param points Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
503 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
504 * \param constrained true if the snap is constrained, e.g. for stretching or for purely horizontal translation.
505 * \param constraint The direction or line along which snapping must occur, if 'constrained' is true; otherwise undefined.
506 * \param transformation_type Type of transformation to apply to points before trying to snap them.
507 * \param transformation Description of the transformation; details depend on the type.
508 * \param origin Origin of the transformation, if applicable.
509 * \param dim Dimension to which the transformation applies, if applicable.
510 * \param uniform true if the transformation should be uniform; only applicable for stretching and scaling.
511 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
512 */
514 Inkscape::SnappedPoint SnapManager::_snapTransformed(
515 std::vector<Inkscape::SnapCandidatePoint> const &points,
516 Geom::Point const &pointer,
517 bool constrained,
518 Inkscape::Snapper::SnapConstraint const &constraint,
519 Transformation transformation_type,
520 Geom::Point const &transformation,
521 Geom::Point const &origin,
522 Geom::Dim2 dim,
523 bool uniform) const
524 {
525 /* We have a list of points, which we are proposing to transform in some way. We need to see
526 ** if any of these points, when transformed, snap to anything. If they do, we return the
527 ** appropriate transformation with `true'; otherwise we return the original scale with `false'.
528 */
530 /* Quick check to see if we have any snappers that are enabled
531 ** Also used to globally disable all snapping
532 */
533 if (someSnapperMightSnap() == false || points.size() == 0) {
534 return Inkscape::SnappedPoint(pointer);
535 }
537 std::vector<Inkscape::SnapCandidatePoint> transformed_points;
538 Geom::Rect bbox;
540 long source_num = 0;
541 for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); i++) {
543 /* Work out the transformed version of this point */
544 Geom::Point transformed = _transformPoint(*i, transformation_type, transformation, origin, dim, uniform);
546 // add the current transformed point to the box hulling all transformed points
547 if (i == points.begin()) {
548 bbox = Geom::Rect(transformed, transformed);
549 } else {
550 bbox.expandTo(transformed);
551 }
553 transformed_points.push_back(Inkscape::SnapCandidatePoint(transformed, (*i).getSourceType(), source_num));
554 source_num++;
555 }
557 /* The current best transformation */
558 Geom::Point best_transformation = transformation;
560 /* The current best metric for the best transformation; lower is better, NR_HUGE
561 ** means that we haven't snapped anything.
562 */
563 Geom::Point best_scale_metric(NR_HUGE, NR_HUGE);
564 Inkscape::SnappedPoint best_snapped_point;
565 g_assert(best_snapped_point.getAlwaysSnap() == false); // Check initialization of snapped point
566 g_assert(best_snapped_point.getAtIntersection() == false);
568 // Warnings for the devs
569 if (constrained && transformation_type == SCALE && !uniform) {
570 g_warning("Non-uniform constrained scaling is not supported!");
571 }
573 if (!constrained && transformation_type == ROTATE) {
574 // We do not yet allow for simultaneous rotation and scaling
575 g_warning("Unconstrained rotation is not supported!");
576 }
578 std::vector<Inkscape::SnapCandidatePoint>::iterator j = transformed_points.begin();
580 // std::cout << std::endl;
581 bool first_free_snap = true;
582 for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); i++) {
584 /* Snap it */
585 Inkscape::SnappedPoint snapped_point;
586 Inkscape::Snapper::SnapConstraint dedicated_constraint = constraint;
587 Geom::Point const b = ((*i).getPoint() - origin); // vector to original point (not the transformed point! required for rotations!)
589 if (constrained) {
590 if (((transformation_type == SCALE || transformation_type == STRETCH) && uniform)) {
591 // When uniformly scaling, each point will have its own unique constraint line,
592 // running from the scaling origin to the original untransformed point. We will
593 // calculate that line here
594 dedicated_constraint = Inkscape::Snapper::SnapConstraint(origin, b);
595 } else if (transformation_type == ROTATE) {
596 // Geom::L2(b) is the radius of the circular constraint
597 dedicated_constraint = Inkscape::Snapper::SnapConstraint(origin, b, Geom::L2(b));
598 } else if (transformation_type == STRETCH) { // when non-uniform stretching {
599 dedicated_constraint = Inkscape::Snapper::SnapConstraint((*i).getPoint(), component_vectors[dim]);
600 } else if (transformation_type == TRANSLATE) {
601 // When doing a constrained translation, all points will move in the same direction, i.e.
602 // either horizontally or vertically. The lines along which they move are therefore all
603 // parallel, but might not be colinear. Therefore we will have to specify the point through
604 // which the constraint-line runs here, for each point individually. (we could also have done this
605 // earlier on, e.g. in seltrans.cpp but we're being lazy there and don't want to add an iteration loop)
606 dedicated_constraint = Inkscape::Snapper::SnapConstraint((*i).getPoint(), constraint.getDirection());
607 } // else: leave the original constraint, e.g. for skewing
608 snapped_point = constrainedSnap(*j, dedicated_constraint, bbox);
609 } else {
610 bool const c1 = fabs(b[Geom::X]) < 1e-6;
611 bool const c2 = fabs(b[Geom::Y]) < 1e-6;
612 if (transformation_type == SCALE && (c1 || c2) && !(c1 && c2)) {
613 // When scaling, a point aligned either horizontally or vertically with the origin can only
614 // move in that specific direction; therefore it should only snap in that direction, otherwise
615 // we will get snapped points with an invalid transformation
616 dedicated_constraint = Inkscape::Snapper::SnapConstraint(origin, component_vectors[c1]);
617 snapped_point = constrainedSnap(*j, dedicated_constraint, bbox);
618 } else {
619 // If we have a collection of SnapCandidatePoints, with mixed constrained snapping and free snapping
620 // requirements, then freeSnap might never see the SnapCandidatePoint with source_num == 0. The freeSnap()
621 // method in the object snapper depends on this, because only for source-num == 0 the target nodes will
622 // be collected. Therefore we enforce that the first SnapCandidatePoint that is to be freeSnapped always
623 // has source_num == 0;
624 // TODO: This is a bit ugly so fix this; do we need sourcenum for anything else? if we don't then get rid
625 // of it and explicitely communicate to the object snapper that this is a first point
626 if (first_free_snap) {
627 (*j).setSourceNum(0);
628 first_free_snap = false;
629 }
630 snapped_point = freeSnap(*j, bbox);
631 }
632 }
633 // std::cout << "dist = " << snapped_point.getSnapDistance() << std::endl;
634 snapped_point.setPointerDistance(Geom::L2(pointer - (*i).getPoint()));
636 Geom::Point result;
638 if (snapped_point.getSnapped()) {
639 /* We snapped. Find the transformation that describes where the snapped point has
640 ** ended up, and also the metric for this transformation.
641 */
642 Geom::Point const a = (snapped_point.getPoint() - origin); // vector to snapped point
643 //Geom::Point const b = (*i - origin); // vector to original point
645 switch (transformation_type) {
646 case TRANSLATE:
647 result = snapped_point.getPoint() - (*i).getPoint();
648 /* Consider the case in which a box is almost aligned with a grid in both
649 * horizontal and vertical directions. The distance to the intersection of
650 * the grid lines will always be larger then the distance to a single grid
651 * line. If we prefer snapping to an intersection instead of to a single
652 * grid line, then we cannot use "metric = Geom::L2(result)". Therefore the
653 * snapped distance will be used as a metric. Please note that the snapped
654 * distance is defined as the distance to the nearest line of the intersection,
655 * and not to the intersection itself!
656 */
657 // Only for translations, the relevant metric will be the real snapped distance,
658 // so we don't have to do anything special here
659 break;
660 case SCALE:
661 {
662 result = Geom::Point(NR_HUGE, NR_HUGE);
663 // If this point *i is horizontally or vertically aligned with
664 // the origin of the scaling, then it will scale purely in X or Y
665 // We can therefore only calculate the scaling in this direction
666 // and the scaling factor for the other direction should remain
667 // untouched (unless scaling is uniform of course)
668 for (int index = 0; index < 2; index++) {
669 if (fabs(b[index]) > 1e-6) { // if SCALING CAN occur in this direction
670 if (fabs(fabs(a[index]/b[index]) - fabs(transformation[index])) > 1e-12) { // if SNAPPING DID occur in this direction
671 result[index] = a[index] / b[index]; // then calculate it!
672 }
673 // we might leave result[1-index] = NR_HUGE
674 // if scaling didn't occur in the other direction
675 }
676 }
677 if (uniform) {
678 if (fabs(result[0]) < fabs(result[1])) {
679 result[1] = result[0];
680 } else {
681 result[0] = result[1];
682 }
683 }
684 // Compare the resulting scaling with the desired scaling
685 Geom::Point scale_metric = Geom::abs(result - transformation); // One or both of its components might be NR_HUGE
686 snapped_point.setSnapDistance(std::min(scale_metric[0], scale_metric[1]));
687 snapped_point.setSecondSnapDistance(std::max(scale_metric[0], scale_metric[1]));
688 break;
689 }
690 case STRETCH:
691 result = Geom::Point(NR_HUGE, NR_HUGE);
692 if (fabs(b[dim]) > 1e-6) { // if STRETCHING will occur for this point
693 result[dim] = a[dim] / b[dim];
694 result[1-dim] = uniform ? result[dim] : 1;
695 } else { // STRETCHING might occur for this point, but only when the stretching is uniform
696 if (uniform && fabs(b[1-dim]) > 1e-6) {
697 result[1-dim] = a[1-dim] / b[1-dim];
698 result[dim] = result[1-dim];
699 }
700 }
701 // Store the metric for this transformation as a virtual distance
702 snapped_point.setSnapDistance(std::abs(result[dim] - transformation[dim]));
703 snapped_point.setSecondSnapDistance(NR_HUGE);
704 break;
705 case SKEW:
706 result[0] = (snapped_point.getPoint()[dim] - ((*i).getPoint())[dim]) / (((*i).getPoint())[1 - dim] - origin[1 - dim]); // skew factor
707 result[1] = transformation[1]; // scale factor
708 // Store the metric for this transformation as a virtual distance
709 snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));
710 snapped_point.setSecondSnapDistance(NR_HUGE);
711 break;
712 case ROTATE:
713 result = snapped_point.getTransformation();
714 // Store the metric for this transformation as a virtual distance (we're storing an angle)
715 snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));
716 snapped_point.setSecondSnapDistance(NR_HUGE);
717 break;
718 default:
719 g_assert_not_reached();
720 }
722 if (best_snapped_point.isOtherSnapBetter(snapped_point, true)) {
723 best_transformation = result;
724 best_snapped_point = snapped_point;
725 }
726 }
728 j++;
729 }
731 Geom::Coord best_metric;
732 if (transformation_type == SCALE) {
733 // When scaling, don't ever exit with one of scaling components set to NR_HUGE
734 for (int index = 0; index < 2; index++) {
735 if (best_transformation[index] == NR_HUGE) {
736 if (uniform && best_transformation[1-index] < NR_HUGE) {
737 best_transformation[index] = best_transformation[1-index];
738 } else {
739 best_transformation[index] = transformation[index];
740 }
741 }
742 }
743 }
745 best_metric = best_snapped_point.getSnapDistance();
746 best_snapped_point.setTransformation(best_transformation);
747 // Using " < 1e6" instead of " < NR_HUGE" for catching some rounding errors
748 // These rounding errors might be caused by NRRects, see bug #1584301
749 best_snapped_point.setSnapDistance(best_metric < 1e6 ? best_metric : NR_HUGE);
750 return best_snapped_point;
751 }
754 /**
755 * \brief Apply a translation to a set of points and try to snap freely in 2 degrees-of-freedom
756 *
757 * \param p Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
758 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
759 * \param tr Proposed translation; the final translation can only be calculated after snapping has occurred
760 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
761 */
763 Inkscape::SnappedPoint SnapManager::freeSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
764 Geom::Point const &pointer,
765 Geom::Point const &tr) const
766 {
767 if (p.size() == 1) {
768 Geom::Point pt = _transformPoint(p.at(0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
769 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
770 }
772 return _snapTransformed(p, pointer, false, Geom::Point(0,0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
773 }
775 /**
776 * \brief Apply a translation to a set of points and try to snap along a constraint
777 *
778 * \param p Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
779 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
780 * \param constraint The direction or line along which snapping must occur.
781 * \param tr Proposed translation; the final translation can only be calculated after snapping has occurred.
782 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
783 */
785 Inkscape::SnappedPoint SnapManager::constrainedSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
786 Geom::Point const &pointer,
787 Inkscape::Snapper::SnapConstraint const &constraint,
788 Geom::Point const &tr) const
789 {
790 if (p.size() == 1) {
791 Geom::Point pt = _transformPoint(p.at(0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
792 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
793 }
795 return _snapTransformed(p, pointer, true, constraint, TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
796 }
799 /**
800 * \brief Apply a scaling to a set of points and try to snap freely in 2 degrees-of-freedom
801 *
802 * \param p Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
803 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
804 * \param s Proposed scaling; the final scaling can only be calculated after snapping has occurred
805 * \param o Origin of the scaling
806 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
807 */
809 Inkscape::SnappedPoint SnapManager::freeSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
810 Geom::Point const &pointer,
811 Geom::Scale const &s,
812 Geom::Point const &o) const
813 {
814 if (p.size() == 1) {
815 Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);
816 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
817 }
819 return _snapTransformed(p, pointer, false, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);
820 }
823 /**
824 * \brief Apply a scaling to a set of points and snap such that the aspect ratio of the selection is preserved
825 *
826 * \param p Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
827 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
828 * \param s Proposed scaling; the final scaling can only be calculated after snapping has occurred
829 * \param o Origin of the scaling
830 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
831 */
833 Inkscape::SnappedPoint SnapManager::constrainedSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
834 Geom::Point const &pointer,
835 Geom::Scale const &s,
836 Geom::Point const &o) const
837 {
838 // When constrained scaling, only uniform scaling is supported.
839 if (p.size() == 1) {
840 Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);
841 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
842 }
844 return _snapTransformed(p, pointer, true, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);
845 }
847 /**
848 * \brief Apply a stretch to a set of points and snap such that the direction of the stretch is preserved
849 *
850 * \param p Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
851 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
852 * \param s Proposed stretch; the final stretch can only be calculated after snapping has occurred
853 * \param o Origin of the stretching
854 * \param d Dimension in which to apply proposed stretch.
855 * \param u true if the stretch should be uniform (i.e. to be applied equally in both dimensions)
856 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
857 */
859 Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(std::vector<Inkscape::SnapCandidatePoint> const &p,
860 Geom::Point const &pointer,
861 Geom::Coord const &s,
862 Geom::Point const &o,
863 Geom::Dim2 d,
864 bool u) const
865 {
866 if (p.size() == 1) {
867 Geom::Point pt = _transformPoint(p.at(0), STRETCH, Geom::Point(s, s), o, d, u);
868 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
869 }
871 return _snapTransformed(p, pointer, true, Geom::Point(0,0), STRETCH, Geom::Point(s, s), o, d, u);
872 }
874 /**
875 * \brief Apply a skew to a set of points and snap such that the direction of the skew is preserved
876 *
877 * \param p Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
878 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
879 * \param constraint The direction or line along which snapping must occur.
880 * \param s Proposed skew; the final skew can only be calculated after snapping has occurred
881 * \param o Origin of the proposed skew
882 * \param d Dimension in which to apply proposed skew.
883 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
884 */
886 Inkscape::SnappedPoint SnapManager::constrainedSnapSkew(std::vector<Inkscape::SnapCandidatePoint> const &p,
887 Geom::Point const &pointer,
888 Inkscape::Snapper::SnapConstraint const &constraint,
889 Geom::Point const &s,
890 Geom::Point const &o,
891 Geom::Dim2 d) const
892 {
893 // "s" contains skew factor in s[0], and scale factor in s[1]
895 // Snapping the nodes of the bounding box of a selection that is being transformed, will only work if
896 // the transformation of the bounding box is equal to the transformation of the individual nodes. This is
897 // NOT the case for example when rotating or skewing. The bounding box itself cannot possibly rotate or skew,
898 // so it's corners have a different transformation. The snappers cannot handle this, therefore snapping
899 // of bounding boxes is not allowed here.
900 if (p.size() > 0) {
901 g_assert(!(p.at(0).getSourceType() & Inkscape::SNAPSOURCE_BBOX_CATEGORY));
902 }
904 if (p.size() == 1) {
905 Geom::Point pt = _transformPoint(p.at(0), SKEW, s, o, d, false);
906 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
907 }
909 return _snapTransformed(p, pointer, true, constraint, SKEW, s, o, d, false);
910 }
912 /**
913 * \brief Apply a rotation to a set of points and snap, without scaling
914 *
915 * \param p Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
916 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
917 * \param angle Proposed rotation (in radians); the final rotation can only be calculated after snapping has occurred
918 * \param o Origin of the rotation
919 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
920 */
922 Inkscape::SnappedPoint SnapManager::constrainedSnapRotate(std::vector<Inkscape::SnapCandidatePoint> const &p,
923 Geom::Point const &pointer,
924 Geom::Coord const &angle,
925 Geom::Point const &o) const
926 {
927 // Snapping the nodes of the bounding box of a selection that is being transformed, will only work if
928 // the transformation of the bounding box is equal to the transformation of the individual nodes. This is
929 // NOT the case for example when rotating or skewing. The bounding box itself cannot possibly rotate or skew,
930 // so it's corners have a different transformation. The snappers cannot handle this, therefore snapping
931 // of bounding boxes is not allowed here.
933 if (p.size() == 1) {
934 Geom::Point pt = _transformPoint(p.at(0), ROTATE, Geom::Point(angle, angle), o, Geom::X, false);
935 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
936 }
938 return _snapTransformed(p, pointer, true, Geom::Point(0,0), ROTATE, Geom::Point(angle, angle), o, Geom::X, false);
940 }
942 /**
943 * \brief Given a set of possible snap targets, find the best target (which is not necessarily
944 * also the nearest target), and show the snap indicator if requested
945 *
946 * \param p Source point to be snapped
947 * \param sc A structure holding all snap targets that have been found so far
948 * \param constrained True if the snap is constrained, e.g. for stretching or for purely horizontal translation.
949 * \param noCurves If true, then do consider snapping to intersections of curves, but not to the curves themselves
950 * \param allowOffScreen If true, then snapping to points which are off the screen is allowed (needed for example when pasting to the grid)
951 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics
952 */
954 Inkscape::SnappedPoint SnapManager::findBestSnap(Inkscape::SnapCandidatePoint const &p,
955 SnappedConstraints const &sc,
956 bool constrained,
957 bool noCurves,
958 bool allowOffScreen) const
959 {
962 /*
963 std::cout << "Type and number of snapped constraints: " << std::endl;
964 std::cout << " Points : " << sc.points.size() << std::endl;
965 std::cout << " Lines : " << sc.lines.size() << std::endl;
966 std::cout << " Grid lines : " << sc.grid_lines.size()<< std::endl;
967 std::cout << " Guide lines : " << sc.guide_lines.size()<< std::endl;
968 std::cout << " Curves : " << sc.curves.size()<< std::endl;
969 */
971 // Store all snappoints
972 std::list<Inkscape::SnappedPoint> sp_list;
974 // search for the closest snapped point
975 Inkscape::SnappedPoint closestPoint;
976 if (getClosestSP(sc.points, closestPoint)) {
977 sp_list.push_back(closestPoint);
978 }
980 // search for the closest snapped curve
981 if (!noCurves) {
982 Inkscape::SnappedCurve closestCurve;
983 if (getClosestCurve(sc.curves, closestCurve)) {
984 sp_list.push_back(Inkscape::SnappedPoint(closestCurve));
985 }
986 }
988 if (snapprefs.getSnapIntersectionCS()) {
989 // search for the closest snapped intersection of curves
990 Inkscape::SnappedPoint closestCurvesIntersection;
991 if (getClosestIntersectionCS(sc.curves, p.getPoint(), closestCurvesIntersection, _desktop->dt2doc())) {
992 closestCurvesIntersection.setSource(p.getSourceType());
993 sp_list.push_back(closestCurvesIntersection);
994 }
995 }
997 // search for the closest snapped grid line
998 Inkscape::SnappedLine closestGridLine;
999 if (getClosestSL(sc.grid_lines, closestGridLine)) {
1000 sp_list.push_back(Inkscape::SnappedPoint(closestGridLine));
1001 }
1003 // search for the closest snapped guide line
1004 Inkscape::SnappedLine closestGuideLine;
1005 if (getClosestSL(sc.guide_lines, closestGuideLine)) {
1006 sp_list.push_back(Inkscape::SnappedPoint(closestGuideLine));
1007 }
1009 // When freely snapping to a grid/guide/path, only one degree of freedom is eliminated
1010 // Therefore we will try get fully constrained by finding an intersection with another grid/guide/path
1012 // When doing a constrained snap however, we're already at an intersection of the constrained line and
1013 // the grid/guide/path we're snapping to. This snappoint is therefore fully constrained, so there's
1014 // no need to look for additional intersections
1015 if (!constrained) {
1016 // search for the closest snapped intersection of grid lines
1017 Inkscape::SnappedPoint closestGridPoint;
1018 if (getClosestIntersectionSL(sc.grid_lines, closestGridPoint)) {
1019 closestGridPoint.setSource(p.getSourceType());
1020 closestGridPoint.setTarget(Inkscape::SNAPTARGET_GRID_INTERSECTION);
1021 sp_list.push_back(closestGridPoint);
1022 }
1024 // search for the closest snapped intersection of guide lines
1025 Inkscape::SnappedPoint closestGuidePoint;
1026 if (getClosestIntersectionSL(sc.guide_lines, closestGuidePoint)) {
1027 closestGuidePoint.setSource(p.getSourceType());
1028 closestGuidePoint.setTarget(Inkscape::SNAPTARGET_GUIDE_INTERSECTION);
1029 sp_list.push_back(closestGuidePoint);
1030 }
1032 // search for the closest snapped intersection of grid with guide lines
1033 if (snapprefs.getSnapIntersectionGG()) {
1034 Inkscape::SnappedPoint closestGridGuidePoint;
1035 if (getClosestIntersectionSL(sc.grid_lines, sc.guide_lines, closestGridGuidePoint)) {
1036 closestGridGuidePoint.setSource(p.getSourceType());
1037 closestGridGuidePoint.setTarget(Inkscape::SNAPTARGET_GRID_GUIDE_INTERSECTION);
1038 sp_list.push_back(closestGridGuidePoint);
1039 }
1040 }
1041 }
1043 // now let's see which snapped point gets a thumbs up
1044 Inkscape::SnappedPoint bestSnappedPoint(p.getPoint());
1045 // std::cout << "Finding the best snap..." << std::endl;
1046 for (std::list<Inkscape::SnappedPoint>::const_iterator i = sp_list.begin(); i != sp_list.end(); i++) {
1047 // std::cout << "sp = " << (*i).getPoint() << " | source = " << (*i).getSource() << " | target = " << (*i).getTarget();
1048 bool onScreen = _desktop->get_display_area().contains((*i).getPoint());
1049 if (onScreen || allowOffScreen) { // Only snap to points which are not off the screen
1050 if ((*i).getSnapDistance() <= (*i).getTolerance()) { // Only snap to points within snapping range
1051 // if it's the first point, or if it is closer than the best snapped point so far
1052 if (i == sp_list.begin() || bestSnappedPoint.isOtherSnapBetter(*i, false)) {
1053 // then prefer this point over the previous one
1054 bestSnappedPoint = *i;
1055 }
1056 }
1057 }
1058 // std::cout << std::endl;
1059 }
1061 // Update the snap indicator, if requested
1062 if (_snapindicator) {
1063 if (bestSnappedPoint.getSnapped()) {
1064 _desktop->snapindicator->set_new_snaptarget(bestSnappedPoint);
1065 } else {
1066 _desktop->snapindicator->remove_snaptarget();
1067 }
1068 }
1070 // std::cout << "findBestSnap = " << bestSnappedPoint.getPoint() << " | dist = " << bestSnappedPoint.getSnapDistance() << std::endl;
1071 return bestSnappedPoint;
1072 }
1074 /// Convenience shortcut when there is only one item to ignore
1075 void SnapManager::setup(SPDesktop const *desktop,
1076 bool snapindicator,
1077 SPItem const *item_to_ignore,
1078 std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,
1079 SPGuide *guide_to_ignore)
1080 {
1081 g_assert(desktop != NULL);
1082 _items_to_ignore.clear();
1083 _items_to_ignore.push_back(item_to_ignore);
1084 _desktop = desktop;
1085 _snapindicator = snapindicator;
1086 _unselected_nodes = unselected_nodes;
1087 _guide_to_ignore = guide_to_ignore;
1088 }
1090 /**
1091 * \brief Prepare the snap manager for the actual snapping, which includes building a list of snap targets
1092 * to ignore and toggling the snap indicator
1093 *
1094 * There are two overloaded setup() methods, of which the other one only allows for a single item to be ignored
1095 * whereas this one will take a list of items to ignore
1096 *
1097 * \param desktop Reference to the desktop to which this snap manager is attached
1098 * \param snapindicator If true then a snap indicator will be displayed automatically (when enabled in the preferences)
1099 * \param items_to_ignore These items will not be snapped to, e.g. the items that are currently being dragged. This avoids "self-snapping"
1100 * \param unselected_nodes Stationary nodes of the path that is currently being edited in the node tool and
1101 * that can be snapped too. Nodes not in this list will not be snapped to, to avoid "self-snapping". Of each
1102 * unselected node both the position (Geom::Point) and the type (Inkscape::SnapTargetType) will be stored
1103 * \param guide_to_ignore Guide that is currently being dragged and should not be snapped to
1104 */
1106 void SnapManager::setup(SPDesktop const *desktop,
1107 bool snapindicator,
1108 std::vector<SPItem const *> &items_to_ignore,
1109 std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,
1110 SPGuide *guide_to_ignore)
1111 {
1112 g_assert(desktop != NULL);
1113 _items_to_ignore = items_to_ignore;
1114 _desktop = desktop;
1115 _snapindicator = snapindicator;
1116 _unselected_nodes = unselected_nodes;
1117 _guide_to_ignore = guide_to_ignore;
1118 }
1120 /// Setup, taking the list of items to ignore from the desktop's selection.
1121 void SnapManager::setupIgnoreSelection(SPDesktop const *desktop,
1122 bool snapindicator,
1123 std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,
1124 SPGuide *guide_to_ignore)
1125 {
1126 _desktop = desktop;
1127 _snapindicator = snapindicator;
1128 _unselected_nodes = unselected_nodes;
1129 _guide_to_ignore = guide_to_ignore;
1130 _items_to_ignore.clear();
1132 Inkscape::Selection *sel = _desktop->selection;
1133 GSList const *items = sel->itemList();
1134 for (GSList *i = const_cast<GSList*>(items); i; i = i->next) {
1135 _items_to_ignore.push_back(static_cast<SPItem const *>(i->data));
1136 }
1137 }
1139 SPDocument *SnapManager::getDocument() const
1140 {
1141 return _named_view->document;
1142 }
1144 /**
1145 * \brief Takes an untransformed point, applies the given transformation, and returns the transformed point. Eliminates lots of duplicated code
1146 *
1147 * \param p The untransformed position of the point, paired with an identifier of the type of the snap source.
1148 * \param transformation_type Type of transformation to apply.
1149 * \param transformation Mathematical description of the transformation; details depend on the type.
1150 * \param origin Origin of the transformation, if applicable.
1151 * \param dim Dimension to which the transformation applies, if applicable.
1152 * \param uniform true if the transformation should be uniform; only applicable for stretching and scaling.
1153 * \return The position of the point after transformation
1154 */
1156 Geom::Point SnapManager::_transformPoint(Inkscape::SnapCandidatePoint const &p,
1157 Transformation const transformation_type,
1158 Geom::Point const &transformation,
1159 Geom::Point const &origin,
1160 Geom::Dim2 const dim,
1161 bool const uniform) const
1162 {
1163 /* Work out the transformed version of this point */
1164 Geom::Point transformed;
1165 switch (transformation_type) {
1166 case TRANSLATE:
1167 transformed = p.getPoint() + transformation;
1168 break;
1169 case SCALE:
1170 transformed = (p.getPoint() - origin) * Geom::Scale(transformation[Geom::X], transformation[Geom::Y]) + origin;
1171 break;
1172 case STRETCH:
1173 {
1174 Geom::Scale s(1, 1);
1175 if (uniform)
1176 s[Geom::X] = s[Geom::Y] = transformation[dim];
1177 else {
1178 s[dim] = transformation[dim];
1179 s[1 - dim] = 1;
1180 }
1181 transformed = ((p.getPoint() - origin) * s) + origin;
1182 break;
1183 }
1184 case SKEW:
1185 // Apply the skew factor
1186 transformed[dim] = (p.getPoint())[dim] + transformation[0] * ((p.getPoint())[1 - dim] - origin[1 - dim]);
1187 // While skewing, mirroring and scaling (by integer multiples) in the opposite direction is also allowed.
1188 // Apply that scale factor here
1189 transformed[1-dim] = (p.getPoint() - origin)[1 - dim] * transformation[1] + origin[1 - dim];
1190 break;
1191 case ROTATE:
1192 // for rotations: transformation[0] stores the angle in radians
1193 transformed = (p.getPoint() - origin) * Geom::Rotate(transformation[0]) + origin;
1194 break;
1195 default:
1196 g_assert_not_reached();
1197 }
1199 return transformed;
1200 }
1202 /**
1203 * \brief Mark the location of the snap source (not the snap target!) on the canvas by drawing a symbol
1204 *
1205 * \param point_type Category of points to which the source point belongs: node, guide or bounding box
1206 * \param p The transformed position of the source point, paired with an identifier of the type of the snap source.
1207 */
1209 void SnapManager::_displaySnapsource(Inkscape::SnapCandidatePoint const &p) const {
1211 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1212 if (prefs->getBool("/options/snapclosestonly/value")) {
1213 bool p_is_a_node = p.getSourceType() & Inkscape::SNAPSOURCE_NODE_CATEGORY;
1214 bool p_is_a_bbox = p.getSourceType() & Inkscape::SNAPSOURCE_BBOX_CATEGORY;
1216 if (snapprefs.getSnapEnabledGlobally() && ((p_is_a_node && snapprefs.getSnapModeNode()) || (p_is_a_bbox && snapprefs.getSnapModeBBox()))) {
1217 _desktop->snapindicator->set_new_snapsource(p);
1218 } else {
1219 _desktop->snapindicator->remove_snapsource();
1220 }
1221 }
1222 }
1224 /*
1225 Local Variables:
1226 mode:c++
1227 c-file-style:"stroustrup"
1228 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1229 indent-tabs-mode:nil
1230 fill-column:99
1231 End:
1232 */
1233 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :