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);
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 /**
218 * \brief Snap to the closest multiple of a grid pitch
219 *
220 * When pasting, we would like to snap to the grid. Problem is that we don't know which
221 * nodes were aligned to the grid at the time of copying, so we don't know which nodes
222 * to snap. If we'd snap an unaligned node to the grid, previously aligned nodes would
223 * become unaligned. That's undesirable. Instead we will make sure that the offset
224 * between the source and its pasted copy is a multiple of the grid pitch. If the source
225 * was aligned, then the copy will therefore also be aligned.
226 *
227 * PS: Whether we really find a multiple also depends on the snapping range! Most users
228 * will have "always snap" enabled though, in which case a multiple will always be found.
229 * PS2: When multiple grids are present then the result will become ambiguous. There is no
230 * way to control to which grid this method will snap.
231 *
232 * \param t Vector that represents the offset of the pasted copy with respect to the original
233 * \return Offset vector after snapping to the closest multiple of a grid pitch
234 */
236 Geom::Point SnapManager::multipleOfGridPitch(Geom::Point const &t) const
237 {
238 if (!snapprefs.getSnapEnabledGlobally()) // No need to check for snapprefs.getSnapPostponedGlobally() here
239 return t;
241 if (_desktop && _desktop->gridsEnabled()) {
242 bool success = false;
243 Geom::Point nearest_multiple;
244 Geom::Coord nearest_distance = NR_HUGE;
246 // It will snap to the grid for which we find the closest snap. This might be a different
247 // grid than to which the objects were initially aligned. I don't see an easy way to fix
248 // this, so when using multiple grids one can get unexpected results
250 // Cannot use getGridSnappers() because we need both the grids AND their snappers
251 // Therefore we iterate through all grids manually
252 for (GSList const *l = _named_view->grids; l != NULL; l = l->next) {
253 Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
254 const Inkscape::Snapper* snapper = grid->snapper;
255 if (snapper && snapper->ThisSnapperMightSnap()) {
256 // To find the nearest multiple of the grid pitch for a given translation t, we
257 // will use the grid snapper. Simply snapping the value t to the grid will do, but
258 // only if the origin of the grid is at (0,0). If it's not then compensate for this
259 // in the translation t
260 Geom::Point const t_offset = t + grid->origin;
261 SnappedConstraints sc;
262 // Only the first three parameters are being used for grid snappers
263 snapper->freeSnap(sc, Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_UNDEFINED),Geom::OptRect(), NULL, NULL);
264 // Find the best snap for this grid, including intersections of the grid-lines
265 Inkscape::SnappedPoint s = findBestSnap(Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_UNDEFINED), sc, false);
266 if (s.getSnapped() && (s.getSnapDistance() < nearest_distance)) {
267 // use getSnapDistance() instead of getWeightedDistance() here because the pointer's position
268 // doesn't tell us anything about which node to snap
269 success = true;
270 nearest_multiple = s.getPoint() - to_2geom(grid->origin);
271 nearest_distance = s.getSnapDistance();
272 }
273 }
274 }
276 if (success)
277 return nearest_multiple;
278 }
280 return t;
281 }
283 /**
284 * \brief Try to snap a point along a constraint line to grids, guides or objects.
285 *
286 * Try to snap a point to grids, guides or objects, in only one degree-of-freedom,
287 * i.e. snap in a specific direction on the two dimensional canvas to the nearest
288 * snap target.
289 *
290 * constrainedSnapReturnByRef() is equal in snapping behavior to
291 * constrainedSnap(), but the former returns the snapped point trough the referenced
292 * parameter p. This parameter p initially contains the position of the snap
293 * source and will we overwritten by the target position if snapping has occurred.
294 * This makes snapping transparent to the calling code. If this is not desired
295 * because either the calling code must know whether snapping has occurred, or
296 * because the original position should not be touched, then constrainedSnap() should
297 * be called instead.
298 *
299 * PS:
300 * 1) SnapManager::setup() must have been called before calling this method,
301 * but only once for a set of points
302 * 2) Only to be used when a single source point is to be snapped; it assumes
303 * that source_num = 0, which is inefficient when snapping sets our source points
305 *
306 * \param p Current position of the snap source; will be overwritten by the position of the snap target if snapping has occurred
307 * \param source_type Detailed description of the source type, will be used by the snap indicator
308 * \param constraint The direction or line along which snapping must occur
309 * \param bbox_to_snap Bounding box hulling the set of points, all from the same selection and having the same transformation
310 */
312 void SnapManager::constrainedSnapReturnByRef(Geom::Point &p,
313 Inkscape::SnapSourceType const source_type,
314 Inkscape::Snapper::ConstraintLine const &constraint,
315 Geom::OptRect const &bbox_to_snap) const
316 {
317 Inkscape::SnappedPoint const s = constrainedSnap(Inkscape::SnapCandidatePoint(p, source_type, 0), constraint, bbox_to_snap);
318 s.getPoint(p);
319 }
321 /**
322 * \brief Try to snap a point along a constraint line to grids, guides or objects.
323 *
324 * Try to snap a point to grids, guides or objects, in only one degree-of-freedom,
325 * i.e. snap in a specific direction on the two dimensional canvas to the nearest
326 * snap target. constrainedSnap is equal in snapping behavior to
327 * constrainedSnapReturnByRef(). Please read the comments of the latter for more details.
328 *
329 * PS: SnapManager::setup() must have been called before calling this method,
330 * but only once for a set of points
331 *
332 * \param p Source point to be snapped
333 * \param constraint The direction or line along which snapping must occur
334 * \param bbox_to_snap Bounding box hulling the set of points, all from the same selection and having the same transformation
335 */
337 Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::SnapCandidatePoint const &p,
338 Inkscape::Snapper::ConstraintLine const &constraint,
339 Geom::OptRect const &bbox_to_snap) const
340 {
341 if (!someSnapperMightSnap()) {
342 return Inkscape::SnappedPoint(p, Inkscape::SNAPTARGET_UNDEFINED, NR_HUGE, 0, false, false);
343 }
345 // First project the mouse pointer onto the constraint
346 Geom::Point pp = constraint.projection(p.getPoint());
347 // Then try to snap the projected point
348 Inkscape::SnapCandidatePoint candidate(pp, p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_UNDEFINED, Geom::Rect());
350 SnappedConstraints sc;
351 SnapperList const snappers = getSnappers();
352 for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
353 (*i)->constrainedSnap(sc, candidate, bbox_to_snap, constraint, &_items_to_ignore);
354 }
356 return findBestSnap(candidate, sc, true);
357 }
359 /**
360 * \brief Try to snap a point of a guide to another guide or to a node
361 *
362 * Try to snap a point of a guide to another guide or to a node in two degrees-
363 * of-freedom, i.e. snap in any direction on the two dimensional canvas to the
364 * nearest snap target. This method is used when dragging or rotating a guide
365 *
366 * PS: SnapManager::setup() must have been called before calling this method,
367 *
368 * \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
369 * \param guide_normal Vector normal to the guide line
370 */
371 void SnapManager::guideFreeSnap(Geom::Point &p, Geom::Point const &guide_normal, SPGuideDragType drag_type) const
372 {
373 if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally()) {
374 return;
375 }
377 if (!(object.GuidesMightSnap() || snapprefs.getSnapToGuides())) {
378 return;
379 }
381 Inkscape::SnapCandidatePoint candidate(p, Inkscape::SNAPSOURCE_GUIDE_ORIGIN);
382 if (drag_type == SP_DRAG_ROTATE) {
383 candidate = Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_GUIDE);
384 }
386 // Snap to nodes
387 SnappedConstraints sc;
388 if (object.GuidesMightSnap()) {
389 object.guideFreeSnap(sc, p, guide_normal);
390 }
392 // Snap to guides & grid lines
393 SnapperList snappers = getGridSnappers();
394 snappers.push_back(&guide);
395 for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
396 (*i)->freeSnap(sc, candidate, Geom::OptRect(), NULL, NULL);
397 }
399 // Snap to intersections of curves, but not to the curves themselves! (see _snapTranslatingGuideToNodes in object-snapper.cpp)
400 Inkscape::SnappedPoint const s = findBestSnap(candidate, sc, false, true);
402 s.getPoint(p);
403 }
405 /**
406 * \brief Try to snap a point on a guide to the intersection with another guide or a path
407 *
408 * Try to snap a point on a guide to the intersection of that guide with another
409 * guide or with a path. The snapped point will lie somewhere on the guide-line,
410 * making this is a constrained snap, i.e. in only one degree-of-freedom.
411 * This method is used when dragging the origin of the guide along the guide itself.
412 *
413 * PS: SnapManager::setup() must have been called before calling this method,
414 *
415 * \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
416 * \param guide_normal Vector normal to the guide line
417 */
419 void SnapManager::guideConstrainedSnap(Geom::Point &p, SPGuide const &guideline) const
420 {
421 if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally()) {
422 return;
423 }
425 if (!(object.ThisSnapperMightSnap() || snapprefs.getSnapToGuides())) {
426 return;
427 }
429 Inkscape::SnapCandidatePoint candidate(p, Inkscape::SNAPSOURCE_GUIDE_ORIGIN, Inkscape::SNAPTARGET_UNDEFINED);
431 // Snap to nodes or paths
432 SnappedConstraints sc;
433 Inkscape::Snapper::ConstraintLine cl(guideline.point_on_line, Geom::rot90(guideline.normal_to_line));
434 if (object.ThisSnapperMightSnap()) {
435 object.constrainedSnap(sc, candidate, Geom::OptRect(), cl, NULL);
436 }
438 // Snap to guides & grid lines
439 SnapperList snappers = getGridSnappers();
440 snappers.push_back(&guide);
441 for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
442 (*i)->constrainedSnap(sc, candidate, Geom::OptRect(), cl, NULL);
443 }
445 Inkscape::SnappedPoint const s = findBestSnap(candidate, sc, false);
446 s.getPoint(p);
447 }
449 /**
450 * \brief Method for snapping sets of points while they are being transformed
451 *
452 * Method for snapping sets of points while they are being transformed, when using
453 * for example the selector tool. This method is for internal use only, and should
454 * not have to be called directly. Use freeSnapTransalation(), constrainedSnapScale(),
455 * etc. instead.
456 *
457 * This is what is being done in this method: transform each point, find out whether
458 * a free snap or constrained snap is more appropriate, do the snapping, calculate
459 * some metrics to quantify the snap "distance", and see if it's better than the
460 * previous snap. Finally, the best ("nearest") snap from all these points is returned.
461 *
462 * \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.
463 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
464 * \param constrained true if the snap is constrained, e.g. for stretching or for purely horizontal translation.
465 * \param constraint The direction or line along which snapping must occur, if 'constrained' is true; otherwise undefined.
466 * \param transformation_type Type of transformation to apply to points before trying to snap them.
467 * \param transformation Description of the transformation; details depend on the type.
468 * \param origin Origin of the transformation, if applicable.
469 * \param dim Dimension to which the transformation applies, if applicable.
470 * \param uniform true if the transformation should be uniform; only applicable for stretching and scaling.
471 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
472 */
474 Inkscape::SnappedPoint SnapManager::_snapTransformed(
475 std::vector<Inkscape::SnapCandidatePoint> const &points,
476 Geom::Point const &pointer,
477 bool constrained,
478 Inkscape::Snapper::ConstraintLine const &constraint,
479 Transformation transformation_type,
480 Geom::Point const &transformation,
481 Geom::Point const &origin,
482 Geom::Dim2 dim,
483 bool uniform) const
484 {
485 /* We have a list of points, which we are proposing to transform in some way. We need to see
486 ** if any of these points, when transformed, snap to anything. If they do, we return the
487 ** appropriate transformation with `true'; otherwise we return the original scale with `false'.
488 */
490 /* Quick check to see if we have any snappers that are enabled
491 ** Also used to globally disable all snapping
492 */
493 if (someSnapperMightSnap() == false) {
494 return Inkscape::SnappedPoint(pointer);
495 }
497 std::vector<Inkscape::SnapCandidatePoint> transformed_points;
498 Geom::Rect bbox;
500 long source_num = 0;
501 for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); i++) {
503 /* Work out the transformed version of this point */
504 Geom::Point transformed = _transformPoint(*i, transformation_type, transformation, origin, dim, uniform);
506 // add the current transformed point to the box hulling all transformed points
507 if (i == points.begin()) {
508 bbox = Geom::Rect(transformed, transformed);
509 } else {
510 bbox.expandTo(transformed);
511 }
513 transformed_points.push_back(Inkscape::SnapCandidatePoint(transformed, (*i).getSourceType(), source_num));
514 source_num++;
515 }
517 /* The current best transformation */
518 Geom::Point best_transformation = transformation;
520 /* The current best metric for the best transformation; lower is better, NR_HUGE
521 ** means that we haven't snapped anything.
522 */
523 Geom::Point best_scale_metric(NR_HUGE, NR_HUGE);
524 Inkscape::SnappedPoint best_snapped_point;
525 g_assert(best_snapped_point.getAlwaysSnap() == false); // Check initialization of snapped point
526 g_assert(best_snapped_point.getAtIntersection() == false);
528 std::vector<Inkscape::SnapCandidatePoint>::const_iterator j = transformed_points.begin();
531 // std::cout << std::endl;
532 for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); i++) {
534 /* Snap it */
535 Inkscape::SnappedPoint snapped_point;
536 Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint;
537 Geom::Point const b = ((*i).getPoint() - origin); // vector to original point
539 if (constrained) {
540 if ((transformation_type == SCALE || transformation_type == STRETCH) && uniform) {
541 // When uniformly scaling, each point will have its own unique constraint line,
542 // running from the scaling origin to the original untransformed point. We will
543 // calculate that line here
544 dedicated_constraint = Inkscape::Snapper::ConstraintLine(origin, b);
545 } else if (transformation_type == STRETCH) { // when non-uniform stretching {
546 dedicated_constraint = Inkscape::Snapper::ConstraintLine((*i).getPoint(), component_vectors[dim]);
547 } else if (transformation_type == TRANSLATION) {
548 // When doing a constrained translation, all points will move in the same direction, i.e.
549 // either horizontally or vertically. The lines along which they move are therefore all
550 // parallel, but might not be colinear. Therefore we will have to set the point through
551 // which the constraint-line runs here, for each point individually.
552 dedicated_constraint.setPoint((*i).getPoint());
553 } // else: leave the original constraint, e.g. for skewing
554 if (transformation_type == SCALE && !uniform) {
555 g_warning("Non-uniform constrained scaling is not supported!");
556 }
557 snapped_point = constrainedSnap(*j, dedicated_constraint, bbox);
558 } else {
559 bool const c1 = fabs(b[Geom::X]) < 1e-6;
560 bool const c2 = fabs(b[Geom::Y]) < 1e-6;
561 if (transformation_type == SCALE && (c1 || c2) && !(c1 && c2)) {
562 // When scaling, a point aligned either horizontally or vertically with the origin can only
563 // move in that specific direction; therefore it should only snap in that direction, otherwise
564 // we will get snapped points with an invalid transformation
565 dedicated_constraint = Inkscape::Snapper::ConstraintLine(origin, component_vectors[c1]);
566 snapped_point = constrainedSnap(*j, dedicated_constraint, bbox);
567 } else {
568 snapped_point = freeSnap(*j, bbox);
569 }
570 }
571 // std::cout << "dist = " << snapped_point.getSnapDistance() << std::endl;
572 snapped_point.setPointerDistance(Geom::L2(pointer - (*i).getPoint()));
574 Geom::Point result;
576 if (snapped_point.getSnapped()) {
577 /* We snapped. Find the transformation that describes where the snapped point has
578 ** ended up, and also the metric for this transformation.
579 */
580 Geom::Point const a = (snapped_point.getPoint() - origin); // vector to snapped point
581 //Geom::Point const b = (*i - origin); // vector to original point
583 switch (transformation_type) {
584 case TRANSLATION:
585 result = snapped_point.getPoint() - (*i).getPoint();
586 /* Consider the case in which a box is almost aligned with a grid in both
587 * horizontal and vertical directions. The distance to the intersection of
588 * the grid lines will always be larger then the distance to a single grid
589 * line. If we prefer snapping to an intersection instead of to a single
590 * grid line, then we cannot use "metric = Geom::L2(result)". Therefore the
591 * snapped distance will be used as a metric. Please note that the snapped
592 * distance is defined as the distance to the nearest line of the intersection,
593 * and not to the intersection itself!
594 */
595 // Only for translations, the relevant metric will be the real snapped distance,
596 // so we don't have to do anything special here
597 break;
598 case SCALE:
599 {
600 result = Geom::Point(NR_HUGE, NR_HUGE);
601 // If this point *i is horizontally or vertically aligned with
602 // the origin of the scaling, then it will scale purely in X or Y
603 // We can therefore only calculate the scaling in this direction
604 // and the scaling factor for the other direction should remain
605 // untouched (unless scaling is uniform ofcourse)
606 for (int index = 0; index < 2; index++) {
607 if (fabs(b[index]) > 1e-6) { // if SCALING CAN occur in this direction
608 if (fabs(fabs(a[index]/b[index]) - fabs(transformation[index])) > 1e-12) { // if SNAPPING DID occur in this direction
609 result[index] = a[index] / b[index]; // then calculate it!
610 }
611 // we might leave result[1-index] = NR_HUGE
612 // if scaling didn't occur in the other direction
613 }
614 }
615 if (uniform) {
616 if (fabs(result[0]) < fabs(result[1])) {
617 result[1] = result[0];
618 } else {
619 result[0] = result[1];
620 }
621 }
622 // Compare the resulting scaling with the desired scaling
623 Geom::Point scale_metric = Geom::abs(result - transformation); // One or both of its components might be NR_HUGE
624 snapped_point.setSnapDistance(std::min(scale_metric[0], scale_metric[1]));
625 snapped_point.setSecondSnapDistance(std::max(scale_metric[0], scale_metric[1]));
626 break;
627 }
628 case STRETCH:
629 result = Geom::Point(NR_HUGE, NR_HUGE);
630 if (fabs(b[dim]) > 1e-6) { // if STRETCHING will occur for this point
631 result[dim] = a[dim] / b[dim];
632 result[1-dim] = uniform ? result[dim] : 1;
633 } else { // STRETCHING might occur for this point, but only when the stretching is uniform
634 if (uniform && fabs(b[1-dim]) > 1e-6) {
635 result[1-dim] = a[1-dim] / b[1-dim];
636 result[dim] = result[1-dim];
637 }
638 }
639 // Store the metric for this transformation as a virtual distance
640 snapped_point.setSnapDistance(std::abs(result[dim] - transformation[dim]));
641 snapped_point.setSecondSnapDistance(NR_HUGE);
642 break;
643 case SKEW:
644 result[0] = (snapped_point.getPoint()[dim] - ((*i).getPoint())[dim]) / (((*i).getPoint())[1 - dim] - origin[1 - dim]); // skew factor
645 result[1] = transformation[1]; // scale factor
646 // Store the metric for this transformation as a virtual distance
647 snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));
648 snapped_point.setSecondSnapDistance(NR_HUGE);
649 break;
650 default:
651 g_assert_not_reached();
652 }
654 // When scaling, we're considering the best transformation in each direction separately. We will have a metric in each
655 // direction, whereas for all other transformation we only a single one-dimensional metric. That's why we need to handle
656 // the scaling metric differently
657 if (best_snapped_point.isOtherSnapBetter(snapped_point, true)) {
658 best_transformation = result;
659 best_snapped_point = snapped_point;
660 }
661 }
663 j++;
664 }
666 Geom::Coord best_metric;
667 if (transformation_type == SCALE) {
668 // When scaling, don't ever exit with one of scaling components set to NR_HUGE
669 for (int index = 0; index < 2; index++) {
670 if (best_transformation[index] == NR_HUGE) {
671 if (uniform && best_transformation[1-index] < NR_HUGE) {
672 best_transformation[index] = best_transformation[1-index];
673 } else {
674 best_transformation[index] = transformation[index];
675 }
676 }
677 }
678 }
680 best_metric = best_snapped_point.getSnapDistance();
681 best_snapped_point.setTransformation(best_transformation);
682 // Using " < 1e6" instead of " < NR_HUGE" for catching some rounding errors
683 // These rounding errors might be caused by NRRects, see bug #1584301
684 best_snapped_point.setSnapDistance(best_metric < 1e6 ? best_metric : NR_HUGE);
685 return best_snapped_point;
686 }
689 /**
690 * \brief Apply a translation to a set of points and try to snap freely in 2 degrees-of-freedom
691 *
692 * \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.
693 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
694 * \param tr Proposed translation; the final translation can only be calculated after snapping has occurred
695 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
696 */
698 Inkscape::SnappedPoint SnapManager::freeSnapTranslation(std::vector<Inkscape::SnapCandidatePoint> const &p,
699 Geom::Point const &pointer,
700 Geom::Point const &tr) const
701 {
702 if (p.size() == 1) {
703 Geom::Point pt = _transformPoint(p.at(0), TRANSLATION, tr, Geom::Point(0,0), Geom::X, false);
704 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
705 }
707 return _snapTransformed(p, pointer, false, Geom::Point(0,0), TRANSLATION, tr, Geom::Point(0,0), Geom::X, false);
708 }
710 /**
711 * \brief Apply a translation to a set of points and try to snap along a constraint
712 *
713 * \param point_type Category of points to which the source point belongs: node or bounding box.
714 * \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.
715 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
716 * \param constraint The direction or line along which snapping must occur.
717 * \param tr Proposed translation; the final translation can only be calculated after snapping has occurred.
718 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
719 */
721 Inkscape::SnappedPoint SnapManager::constrainedSnapTranslation(std::vector<Inkscape::SnapCandidatePoint> const &p,
722 Geom::Point const &pointer,
723 Inkscape::Snapper::ConstraintLine const &constraint,
724 Geom::Point const &tr) const
725 {
726 if (p.size() == 1) {
727 Geom::Point pt = _transformPoint(p.at(0), TRANSLATION, tr, Geom::Point(0,0), Geom::X, false);
728 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
729 }
731 return _snapTransformed(p, pointer, true, constraint, TRANSLATION, tr, Geom::Point(0,0), Geom::X, false);
732 }
735 /**
736 * \brief Apply a scaling to a set of points and try to snap freely in 2 degrees-of-freedom
737 *
738 * \param point_type Category of points to which the source point belongs: node or bounding box.
739 * \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.
740 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
741 * \param s Proposed scaling; the final scaling can only be calculated after snapping has occurred
742 * \param o Origin of the scaling
743 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
744 */
746 Inkscape::SnappedPoint SnapManager::freeSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
747 Geom::Point const &pointer,
748 Geom::Scale const &s,
749 Geom::Point const &o) const
750 {
751 if (p.size() == 1) {
752 Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);
753 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
754 }
756 return _snapTransformed(p, pointer, false, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);
757 }
760 /**
761 * \brief Apply a scaling to a set of points and snap such that the aspect ratio of the selection is preserved
762 *
763 * \param point_type Category of points to which the source point belongs: node or bounding box.
764 * \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.
765 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
766 * \param s Proposed scaling; the final scaling can only be calculated after snapping has occurred
767 * \param o Origin of the scaling
768 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
769 */
771 Inkscape::SnappedPoint SnapManager::constrainedSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
772 Geom::Point const &pointer,
773 Geom::Scale const &s,
774 Geom::Point const &o) const
775 {
776 // When constrained scaling, only uniform scaling is supported.
777 if (p.size() == 1) {
778 Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);
779 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
780 }
782 return _snapTransformed(p, pointer, true, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);
783 }
785 /**
786 * \brief Apply a stretch to a set of points and snap such that the direction of the stretch is preserved
787 *
788 * \param point_type Category of points to which the source point belongs: node or bounding box.
789 * \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.
790 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
791 * \param s Proposed stretch; the final stretch can only be calculated after snapping has occurred
792 * \param o Origin of the stretching
793 * \param d Dimension in which to apply proposed stretch.
794 * \param u true if the stretch should be uniform (i.e. to be applied equally in both dimensions)
795 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
796 */
798 Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(std::vector<Inkscape::SnapCandidatePoint> const &p,
799 Geom::Point const &pointer,
800 Geom::Coord const &s,
801 Geom::Point const &o,
802 Geom::Dim2 d,
803 bool u) const
804 {
805 if (p.size() == 1) {
806 Geom::Point pt = _transformPoint(p.at(0), STRETCH, Geom::Point(s, s), o, d, u);
807 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
808 }
810 return _snapTransformed(p, pointer, true, Geom::Point(0,0), STRETCH, Geom::Point(s, s), o, d, u);
811 }
813 /**
814 * \brief Apply a skew to a set of points and snap such that the direction of the skew is preserved
815 *
816 * \param point_type Category of points to which the source point belongs: node or bounding box.
817 * \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.
818 * \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
819 * \param constraint The direction or line along which snapping must occur.
820 * \param s Proposed skew; the final skew can only be calculated after snapping has occurred
821 * \param o Origin of the proposed skew
822 * \param d Dimension in which to apply proposed skew.
823 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics.
824 */
826 Inkscape::SnappedPoint SnapManager::constrainedSnapSkew(std::vector<Inkscape::SnapCandidatePoint> const &p,
827 Geom::Point const &pointer,
828 Inkscape::Snapper::ConstraintLine const &constraint,
829 Geom::Point const &s,
830 Geom::Point const &o,
831 Geom::Dim2 d) const
832 {
833 // "s" contains skew factor in s[0], and scale factor in s[1]
835 // Snapping the nodes of the bounding box of a selection that is being transformed, will only work if
836 // the transformation of the bounding box is equal to the transformation of the individual nodes. This is
837 // NOT the case for example when rotating or skewing. The bounding box itself cannot possibly rotate or skew,
838 // so it's corners have a different transformation. The snappers cannot handle this, therefore snapping
839 // of bounding boxes is not allowed here.
840 if (p.size() > 0) {
841 g_assert(!(p.at(0).getSourceType() & Inkscape::SNAPSOURCE_BBOX_CATEGORY));
842 }
844 if (p.size() == 1) {
845 Geom::Point pt = _transformPoint(p.at(0), SKEW, s, o, d, false);
846 _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
847 }
849 return _snapTransformed(p, pointer, true, constraint, SKEW, s, o, d, false);
850 }
852 /**
853 * \brief Given a set of possible snap targets, find the best target (which is not necessarily
854 * also the nearest target), and show the snap indicator if requested
855 *
856 * \param p Source point to be snapped
857 * \param sc A structure holding all snap targets that have been found so far
858 * \param constrained True if the snap is constrained, e.g. for stretching or for purely horizontal translation.
859 * \param noCurves If true, then do consider snapping to intersections of curves, but not to the curves themselves
860 * \return An instance of the SnappedPoint class, which holds data on the snap source, snap target, and various metrics
861 */
863 Inkscape::SnappedPoint SnapManager::findBestSnap(Inkscape::SnapCandidatePoint const &p,
864 SnappedConstraints const &sc,
865 bool constrained,
866 bool noCurves) const
867 {
869 /*
870 std::cout << "Type and number of snapped constraints: " << std::endl;
871 std::cout << " Points : " << sc.points.size() << std::endl;
872 std::cout << " Lines : " << sc.lines.size() << std::endl;
873 std::cout << " Grid lines : " << sc.grid_lines.size()<< std::endl;
874 std::cout << " Guide lines : " << sc.guide_lines.size()<< std::endl;
875 std::cout << " Curves : " << sc.curves.size()<< std::endl;
876 */
878 // Store all snappoints
879 std::list<Inkscape::SnappedPoint> sp_list;
881 // search for the closest snapped point
882 Inkscape::SnappedPoint closestPoint;
883 if (getClosestSP(sc.points, closestPoint)) {
884 sp_list.push_back(closestPoint);
885 }
887 // search for the closest snapped curve
888 if (!noCurves) {
889 Inkscape::SnappedCurve closestCurve;
890 if (getClosestCurve(sc.curves, closestCurve)) {
891 sp_list.push_back(Inkscape::SnappedPoint(closestCurve));
892 }
893 }
895 if (snapprefs.getSnapIntersectionCS()) {
896 // search for the closest snapped intersection of curves
897 Inkscape::SnappedPoint closestCurvesIntersection;
898 if (getClosestIntersectionCS(sc.curves, p.getPoint(), closestCurvesIntersection, _desktop->dt2doc())) {
899 closestCurvesIntersection.setSource(p.getSourceType());
900 sp_list.push_back(closestCurvesIntersection);
901 }
902 }
904 // search for the closest snapped grid line
905 Inkscape::SnappedLine closestGridLine;
906 if (getClosestSL(sc.grid_lines, closestGridLine)) {
907 sp_list.push_back(Inkscape::SnappedPoint(closestGridLine));
908 }
910 // search for the closest snapped guide line
911 Inkscape::SnappedLine closestGuideLine;
912 if (getClosestSL(sc.guide_lines, closestGuideLine)) {
913 sp_list.push_back(Inkscape::SnappedPoint(closestGuideLine));
914 }
916 // When freely snapping to a grid/guide/path, only one degree of freedom is eliminated
917 // Therefore we will try get fully constrained by finding an intersection with another grid/guide/path
919 // When doing a constrained snap however, we're already at an intersection of the constrained line and
920 // the grid/guide/path we're snapping to. This snappoint is therefore fully constrained, so there's
921 // no need to look for additional intersections
922 if (!constrained) {
923 // search for the closest snapped intersection of grid lines
924 Inkscape::SnappedPoint closestGridPoint;
925 if (getClosestIntersectionSL(sc.grid_lines, closestGridPoint)) {
926 closestGridPoint.setSource(p.getSourceType());
927 closestGridPoint.setTarget(Inkscape::SNAPTARGET_GRID_INTERSECTION);
928 sp_list.push_back(closestGridPoint);
929 }
931 // search for the closest snapped intersection of guide lines
932 Inkscape::SnappedPoint closestGuidePoint;
933 if (getClosestIntersectionSL(sc.guide_lines, closestGuidePoint)) {
934 closestGuidePoint.setSource(p.getSourceType());
935 closestGuidePoint.setTarget(Inkscape::SNAPTARGET_GUIDE_INTERSECTION);
936 sp_list.push_back(closestGuidePoint);
937 }
939 // search for the closest snapped intersection of grid with guide lines
940 if (snapprefs.getSnapIntersectionGG()) {
941 Inkscape::SnappedPoint closestGridGuidePoint;
942 if (getClosestIntersectionSL(sc.grid_lines, sc.guide_lines, closestGridGuidePoint)) {
943 closestGridGuidePoint.setSource(p.getSourceType());
944 closestGridGuidePoint.setTarget(Inkscape::SNAPTARGET_GRID_GUIDE_INTERSECTION);
945 sp_list.push_back(closestGridGuidePoint);
946 }
947 }
948 }
950 // now let's see which snapped point gets a thumbs up
951 Inkscape::SnappedPoint bestSnappedPoint(p.getPoint());
952 // std::cout << "Finding the best snap..." << std::endl;
953 for (std::list<Inkscape::SnappedPoint>::const_iterator i = sp_list.begin(); i != sp_list.end(); i++) {
954 // first find out if this snapped point is within snapping range
955 // std::cout << "sp = " << (*i).getPoint() << " | source = " << (*i).getSource() << " | target = " << (*i).getTarget();
956 if ((*i).getSnapDistance() <= (*i).getTolerance()) {
957 // if it's the first point, or if it is closer than the best snapped point so far
958 if (i == sp_list.begin() || bestSnappedPoint.isOtherSnapBetter(*i, false)) {
959 // then prefer this point over the previous one
960 bestSnappedPoint = *i;
961 }
962 }
963 // std::cout << std::endl;
964 }
966 // Update the snap indicator, if requested
967 if (_snapindicator) {
968 if (bestSnappedPoint.getSnapped()) {
969 _desktop->snapindicator->set_new_snaptarget(bestSnappedPoint);
970 } else {
971 _desktop->snapindicator->remove_snaptarget();
972 }
973 }
975 // std::cout << "findBestSnap = " << bestSnappedPoint.getPoint() << " | dist = " << bestSnappedPoint.getSnapDistance() << std::endl;
976 return bestSnappedPoint;
977 }
979 /// Convenience shortcut when there is only one item to ignore
980 void SnapManager::setup(SPDesktop const *desktop,
981 bool snapindicator,
982 SPItem const *item_to_ignore,
983 std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,
984 SPGuide *guide_to_ignore)
985 {
986 g_assert(desktop != NULL);
987 _items_to_ignore.clear();
988 _items_to_ignore.push_back(item_to_ignore);
989 _desktop = desktop;
990 _snapindicator = snapindicator;
991 _unselected_nodes = unselected_nodes;
992 _guide_to_ignore = guide_to_ignore;
993 }
995 /**
996 * \brief Prepare the snap manager for the actual snapping, which includes building a list of snap targets
997 * to ignore and toggling the snap indicator
998 *
999 * There are two overloaded setup() methods, of which the other one only allows for a single item to be ignored
1000 * whereas this one will take a list of items to ignore
1001 *
1002 * \param desktop Reference to the desktop to which this snap manager is attached
1003 * \param snapindicator If true then a snap indicator will be displayed automatically (when enabled in the preferences)
1004 * \param items_to_ignore These items will not be snapped to, e.g. the items that are currently being dragged. This avoids "self-snapping"
1005 * \param unselected_nodes Stationary nodes of the path that is currently being edited in the node tool and
1006 * that can be snapped too. Nodes not in this list will not be snapped to, to avoid "self-snapping". Of each
1007 * unselected node both the position (Geom::Point) and the type (Inkscape::SnapTargetType) will be stored
1008 * \param guide_to_ignore Guide that is currently being dragged and should not be snapped to
1009 */
1011 void SnapManager::setup(SPDesktop const *desktop,
1012 bool snapindicator,
1013 std::vector<SPItem const *> &items_to_ignore,
1014 std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,
1015 SPGuide *guide_to_ignore)
1016 {
1017 g_assert(desktop != NULL);
1018 _items_to_ignore = items_to_ignore;
1019 _desktop = desktop;
1020 _snapindicator = snapindicator;
1021 _unselected_nodes = unselected_nodes;
1022 _guide_to_ignore = guide_to_ignore;
1023 }
1025 /// Setup, taking the list of items to ignore from the desktop's selection.
1026 void SnapManager::setupIgnoreSelection(SPDesktop const *desktop,
1027 bool snapindicator,
1028 std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,
1029 SPGuide *guide_to_ignore)
1030 {
1031 _desktop = desktop;
1032 _snapindicator = snapindicator;
1033 _unselected_nodes = unselected_nodes;
1034 _guide_to_ignore = guide_to_ignore;
1035 _items_to_ignore.clear();
1037 Inkscape::Selection *sel = _desktop->selection;
1038 GSList const *items = sel->itemList();
1039 for (GSList *i = const_cast<GSList*>(items); i; i = i->next) {
1040 _items_to_ignore.push_back(static_cast<SPItem const *>(i->data));
1041 }
1042 }
1044 SPDocument *SnapManager::getDocument() const
1045 {
1046 return _named_view->document;
1047 }
1049 /**
1050 * \brief Takes an untransformed point, applies the given transformation, and returns the transformed point. Eliminates lots of duplicated code
1051 *
1052 * \param p The untransformed position of the point, paired with an identifier of the type of the snap source.
1053 * \param transformation_type Type of transformation to apply.
1054 * \param transformation Mathematical description of the transformation; details depend on the type.
1055 * \param origin Origin of the transformation, if applicable.
1056 * \param dim Dimension to which the transformation applies, if applicable.
1057 * \param uniform true if the transformation should be uniform; only applicable for stretching and scaling.
1058 * \return The position of the point after transformation
1059 */
1061 Geom::Point SnapManager::_transformPoint(Inkscape::SnapCandidatePoint const &p,
1062 Transformation const transformation_type,
1063 Geom::Point const &transformation,
1064 Geom::Point const &origin,
1065 Geom::Dim2 const dim,
1066 bool const uniform) const
1067 {
1068 /* Work out the transformed version of this point */
1069 Geom::Point transformed;
1070 switch (transformation_type) {
1071 case TRANSLATION:
1072 transformed = p.getPoint() + transformation;
1073 break;
1074 case SCALE:
1075 transformed = (p.getPoint() - origin) * Geom::Scale(transformation[Geom::X], transformation[Geom::Y]) + origin;
1076 break;
1077 case STRETCH:
1078 {
1079 Geom::Scale s(1, 1);
1080 if (uniform)
1081 s[Geom::X] = s[Geom::Y] = transformation[dim];
1082 else {
1083 s[dim] = transformation[dim];
1084 s[1 - dim] = 1;
1085 }
1086 transformed = ((p.getPoint() - origin) * s) + origin;
1087 break;
1088 }
1089 case SKEW:
1090 // Apply the skew factor
1091 transformed[dim] = (p.getPoint())[dim] + transformation[0] * ((p.getPoint())[1 - dim] - origin[1 - dim]);
1092 // While skewing, mirroring and scaling (by integer multiples) in the opposite direction is also allowed.
1093 // Apply that scale factor here
1094 transformed[1-dim] = (p.getPoint() - origin)[1 - dim] * transformation[1] + origin[1 - dim];
1095 break;
1096 default:
1097 g_assert_not_reached();
1098 }
1100 return transformed;
1101 }
1103 /**
1104 * \brief Mark the location of the snap source (not the snap target!) on the canvas by drawing a symbol
1105 *
1106 * \param point_type Category of points to which the source point belongs: node, guide or bounding box
1107 * \param p The transformed position of the source point, paired with an identifier of the type of the snap source.
1108 */
1110 void SnapManager::_displaySnapsource(Inkscape::SnapCandidatePoint const &p) const {
1112 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1113 if (prefs->getBool("/options/snapclosestonly/value")) {
1114 bool p_is_a_node = p.getSourceType() & Inkscape::SNAPSOURCE_NODE_CATEGORY;
1115 bool p_is_a_bbox = p.getSourceType() & Inkscape::SNAPSOURCE_BBOX_CATEGORY;
1117 if (snapprefs.getSnapEnabledGlobally() && ((p_is_a_node && snapprefs.getSnapModeNode()) || (p_is_a_bbox && snapprefs.getSnapModeBBox()))) {
1118 _desktop->snapindicator->set_new_snapsource(p);
1119 } else {
1120 _desktop->snapindicator->remove_snapsource();
1121 }
1122 }
1123 }
1125 /*
1126 Local Variables:
1127 mode:c++
1128 c-file-style:"stroustrup"
1129 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1130 indent-tabs-mode:nil
1131 fill-column:99
1132 End:
1133 */
1134 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :