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