f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#define __SP_DESKTOP_SNAP_C__

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

6656f193fdace606d1b162d6dea0223bc295f0a6cilix

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include <utility>

77a4a003111bd5cfb771d4849801c898aeb889b0cilix

77a4a003111bd5cfb771d4849801c898aeb889b0cilix#include "sp-namedview.h"

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix#include "snap.h"

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix#include "snapped-line.h"

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix#include "snapped-curve.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include "display/canvas-grid.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include "display/snap-indicator.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

d9c673867f424647c1586c356cc0ac1d34d0a98ajohanengelen#include "inkscape.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include "desktop.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include "selection.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include "sp-guide.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include "preferences.h"

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm#include "event-context.h"

ddc251b3cf95b0097b6a5ee39ea132bd4d7d5cbcjohanengelen#include "util/mathfns.h"

ddc251b3cf95b0097b6a5ee39ea132bd4d7d5cbcjohanengelenusing std::vector;

ddc251b3cf95b0097b6a5ee39ea132bd4d7d5cbcjohanengelen

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraudSnapManager::SnapManager(SPNamedView const *v) :

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm guide(this, 0),

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm object(this, 0),

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm snapprefs(),

8d9f5d586a04809427ce1df284a5720112177991cilix _named_view(v),

70eb1fc448cb08acf3468f80fa2296c03b32afd2cilix _rotation_center_source_items(NULL),

c169f6cddd2da06cfb761339f445bbd8866f72a8buliabyak _guide_to_ignore(NULL),

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelen _desktop(NULL),

0cc5b8d2f7b87c4222ee3662071bef1cb1f22b06bgk _unselected_nodes(NULL)

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelen{

f4db63be4e929f4706410914295deccaceea19cdcilix}

ab99111a42436818e6902e044c8f3af2b724263bcilix

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrmSnapManager::SnapperList

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrmSnapManager::getSnappers() const

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm{

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm SnapManager::SnapperList s;

072916d0ef7dccd696b59381f50bcf776abccefbjohanengelen s.push_back(&guide);

8c39cbeab9949a0a7d6ae66b768a7352019e42f8johanengelen s.push_back(&object);

29f9623ba77fc735b89765ae3a13e0c06aabafcecilix

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud SnapManager::SnapperList gs = getGridSnappers();

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud s.splice(s.begin(), gs);

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm return s;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm}

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

76db360f5f052775326e6d406b9e1e9e2966e11acilixSnapManager::SnapperList

3d0482af18ffb591c1d8ddecf516629e1bcd2ae4cilixSnapManager::getGridSnappers() const

64aee804a6a47424f7994e60558351b8cf2ea4dbcilix{

b320a8d186114a5122ddc3afbe95110eb6cb10cecilix SnapperList s;

044d712d4d03f8354962d54e47cfac2346a69ccccilix

61cfd957cd023c4f432ea0c7307784a56bf978e9cilix if (_desktop && _desktop->gridsEnabled() && snapprefs.getSnapToGrids()) {

2f5c0701b333a695eedb1680beb1adf95c0723dacilix for ( GSList const *l = _named_view->grids; l != NULL; l = l->next) {

add2ffae3c4686b50d888775bbdf083a4726a210johanengelen Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm s.push_back(grid->snapper);

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm return s;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm}

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud

92fe3142613d000eff89db8a983b3b18b14eee79johanengelenbool SnapManager::someSnapperMightSnap() const

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud{

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud if ( !snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally() ) {

92fe3142613d000eff89db8a983b3b18b14eee79johanengelen return false;

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud }

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud

92fe3142613d000eff89db8a983b3b18b14eee79johanengelen SnapperList const s = getSnappers();

dc98accfae7a38326b92d74fa4330ac8ccb5b778jfbarraud SnapperList::const_iterator i = s.begin();

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm while (i != s.end() && (*i)->ThisSnapperMightSnap() == false) {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm i++;

92fe3142613d000eff89db8a983b3b18b14eee79johanengelen }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm return (i != s.end());

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm}

92fe3142613d000eff89db8a983b3b18b14eee79johanengelen

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelenbool SnapManager::gridSnapperMightSnap() const

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelen{

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelen if ( !snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally() ) {

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelen return false;

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelen }

0563fd55cbad59e8a878e6d4cbbdd8e47f74488djohanengelen

8d9f5d586a04809427ce1df284a5720112177991cilix SnapperList const s = getGridSnappers();

92fe3142613d000eff89db8a983b3b18b14eee79johanengelen SnapperList::const_iterator i = s.begin();

8d9f5d586a04809427ce1df284a5720112177991cilix while (i != s.end() && (*i)->ThisSnapperMightSnap() == false) {

70eb1fc448cb08acf3468f80fa2296c03b32afd2cilix i++;

92fe3142613d000eff89db8a983b3b18b14eee79johanengelen }

70eb1fc448cb08acf3468f80fa2296c03b32afd2cilix

c169f6cddd2da06cfb761339f445bbd8866f72a8buliabyak return (i != s.end());

c169f6cddd2da06cfb761339f445bbd8866f72a8buliabyak}

c169f6cddd2da06cfb761339f445bbd8866f72a8buliabyak

61cfd957cd023c4f432ea0c7307784a56bf978e9cilix

61cfd957cd023c4f432ea0c7307784a56bf978e9cilixvoid SnapManager::freeSnapReturnByRef(Geom::Point &p,

61cfd957cd023c4f432ea0c7307784a56bf978e9cilix Inkscape::SnapSourceType const source_type,

2f5c0701b333a695eedb1680beb1adf95c0723dacilix Geom::OptRect const &bbox_to_snap) const

2f5c0701b333a695eedb1680beb1adf95c0723dacilix{

2f5c0701b333a695eedb1680beb1adf95c0723dacilix Inkscape::SnappedPoint const s = freeSnap(Inkscape::SnapCandidatePoint(p, source_type), bbox_to_snap);

add2ffae3c4686b50d888775bbdf083a4726a210johanengelen s.getPointIfSnapped(p);

add2ffae3c4686b50d888775bbdf083a4726a210johanengelen}

add2ffae3c4686b50d888775bbdf083a4726a210johanengelen

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

6656f193fdace606d1b162d6dea0223bc295f0a6cilix

6656f193fdace606d1b162d6dea0223bc295f0a6cilix

6656f193fdace606d1b162d6dea0223bc295f0a6cilixInkscape::SnappedPoint SnapManager::freeSnap(Inkscape::SnapCandidatePoint const &p,

6656f193fdace606d1b162d6dea0223bc295f0a6cilix Geom::OptRect const &bbox_to_snap) const

6656f193fdace606d1b162d6dea0223bc295f0a6cilix{

6656f193fdace606d1b162d6dea0223bc295f0a6cilix if (!someSnapperMightSnap()) {

6656f193fdace606d1b162d6dea0223bc295f0a6cilix return Inkscape::SnappedPoint(p, Inkscape::SNAPTARGET_UNDEFINED, NR_HUGE, 0, false, false, false);

6656f193fdace606d1b162d6dea0223bc295f0a6cilix }

6656f193fdace606d1b162d6dea0223bc295f0a6cilix

6656f193fdace606d1b162d6dea0223bc295f0a6cilix SnappedConstraints sc;

6656f193fdace606d1b162d6dea0223bc295f0a6cilix SnapperList const snappers = getSnappers();

6656f193fdace606d1b162d6dea0223bc295f0a6cilix

6656f193fdace606d1b162d6dea0223bc295f0a6cilix for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {

6656f193fdace606d1b162d6dea0223bc295f0a6cilix (*i)->freeSnap(sc, p, bbox_to_snap, &_items_to_ignore, _unselected_nodes);

6656f193fdace606d1b162d6dea0223bc295f0a6cilix }

6656f193fdace606d1b162d6dea0223bc295f0a6cilix

6656f193fdace606d1b162d6dea0223bc295f0a6cilix return findBestSnap(p, sc, false);

6656f193fdace606d1b162d6dea0223bc295f0a6cilix}

6656f193fdace606d1b162d6dea0223bc295f0a6cilix

6656f193fdace606d1b162d6dea0223bc295f0a6cilixvoid SnapManager::preSnap(Inkscape::SnapCandidatePoint const &p)

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm{

fbb4eb8b63e74d9441220a73a8ca858425be4bd4johanengelen // setup() must have been called before calling this method!

71146abe8aba032d73788a625fee5769a581bd3ccilix

77a4a003111bd5cfb771d4849801c898aeb889b0cilix if (_snapindicator) {

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix _snapindicator = false; // prevent other methods from drawing a snap indicator; we want to control this here

fbb4eb8b63e74d9441220a73a8ca858425be4bd4johanengelen Inkscape::SnappedPoint s = freeSnap(p);

9ce14357bb94b9dd92ad40bf43ef435a257b355acilix g_assert(_desktop != NULL);

9ce14357bb94b9dd92ad40bf43ef435a257b355acilix if (s.getSnapped()) {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm _desktop->snapindicator->set_new_snaptarget(s, true);

71146abe8aba032d73788a625fee5769a581bd3ccilix } else {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm _desktop->snapindicator->remove_snaptarget(true);

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm _snapindicator = true; // restore the original value

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm}

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

262d0c3f05130d86368d95f110aa8ccab5f83e5ccilix

262d0c3f05130d86368d95f110aa8ccab5f83e5ccilixGeom::Point SnapManager::multipleOfGridPitch(Geom::Point const &t, Geom::Point const &origin)

262d0c3f05130d86368d95f110aa8ccab5f83e5ccilix{

262d0c3f05130d86368d95f110aa8ccab5f83e5ccilix if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally())

77a4a003111bd5cfb771d4849801c898aeb889b0cilix return t;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix

77a4a003111bd5cfb771d4849801c898aeb889b0cilix if (_desktop && _desktop->gridsEnabled()) {

23d859f2ce09c04ed802cb4912cc9c50f512f0a2bgk bool success = false;

2d107ef9730aff3f4d776ae0c2f7d983e289ce02joncruz Geom::Point nearest_multiple;

23d859f2ce09c04ed802cb4912cc9c50f512f0a2bgk Geom::Coord nearest_distance = NR_HUGE;

23d859f2ce09c04ed802cb4912cc9c50f512f0a2bgk Inkscape::SnappedPoint bestSnappedPoint(t);

23d859f2ce09c04ed802cb4912cc9c50f512f0a2bgk

23d859f2ce09c04ed802cb4912cc9c50f512f0a2bgk // It will snap to the grid for which we find the closest snap. This might be a different

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // grid than to which the objects were initially aligned. I don't see an easy way to fix

147c8e03bb214f85cd5906ddc6413c4293c4baa9cilix // this, so when using multiple grids one can get unexpected results

147c8e03bb214f85cd5906ddc6413c4293c4baa9cilix

147c8e03bb214f85cd5906ddc6413c4293c4baa9cilix // Cannot use getGridSnappers() because we need both the grids AND their snappers

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // Therefore we iterate through all grids manually

77a4a003111bd5cfb771d4849801c898aeb889b0cilix for (GSList const *l = _named_view->grids; l != NULL; l = l->next) {

77a4a003111bd5cfb771d4849801c898aeb889b0cilix Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix const Inkscape::Snapper* snapper = grid->snapper;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix if (snapper && snapper->ThisSnapperMightSnap()) {

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // To find the nearest multiple of the grid pitch for a given translation t, we

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // will use the grid snapper. Simply snapping the value t to the grid will do, but

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // only if the origin of the grid is at (0,0). If it's not then compensate for this

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // in the translation t

77a4a003111bd5cfb771d4849801c898aeb889b0cilix Geom::Point const t_offset = t + grid->origin;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix SnappedConstraints sc;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // Only the first three parameters are being used for grid snappers

77a4a003111bd5cfb771d4849801c898aeb889b0cilix snapper->freeSnap(sc, Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_GRID_PITCH),Geom::OptRect(), NULL, NULL);

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // Find the best snap for this grid, including intersections of the grid-lines

77a4a003111bd5cfb771d4849801c898aeb889b0cilix bool old_val = _snapindicator;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix _snapindicator = false;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix Inkscape::SnappedPoint s = findBestSnap(Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_GRID_PITCH), sc, false, false, true);

77a4a003111bd5cfb771d4849801c898aeb889b0cilix _snapindicator = old_val;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix if (s.getSnapped() && (s.getSnapDistance() < nearest_distance)) {

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // use getSnapDistance() instead of getWeightedDistance() here because the pointer's position

77a4a003111bd5cfb771d4849801c898aeb889b0cilix // doesn't tell us anything about which node to snap

23d859f2ce09c04ed802cb4912cc9c50f512f0a2bgk success = true;

97a20864afec63a0b7bb757b628ee2ae596cf648cilix nearest_multiple = s.getPoint() - to_2geom(grid->origin);

97a20864afec63a0b7bb757b628ee2ae596cf648cilix nearest_distance = s.getSnapDistance();

97a20864afec63a0b7bb757b628ee2ae596cf648cilix bestSnappedPoint = s;

97a20864afec63a0b7bb757b628ee2ae596cf648cilix }

97a20864afec63a0b7bb757b628ee2ae596cf648cilix }

97a20864afec63a0b7bb757b628ee2ae596cf648cilix }

97a20864afec63a0b7bb757b628ee2ae596cf648cilix

97a20864afec63a0b7bb757b628ee2ae596cf648cilix if (success) {

77a4a003111bd5cfb771d4849801c898aeb889b0cilix bestSnappedPoint.setPoint(origin + nearest_multiple);

77a4a003111bd5cfb771d4849801c898aeb889b0cilix _desktop->snapindicator->set_new_snaptarget(bestSnappedPoint);

77a4a003111bd5cfb771d4849801c898aeb889b0cilix return nearest_multiple;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix }

77a4a003111bd5cfb771d4849801c898aeb889b0cilix }

77a4a003111bd5cfb771d4849801c898aeb889b0cilix

2d2706a9d621c0da51b7c4178fd5c7c5e4765122joncruz return t;

77a4a003111bd5cfb771d4849801c898aeb889b0cilix}

77a4a003111bd5cfb771d4849801c898aeb889b0cilix

46c4893a7458eda6edcd064121bc000634af7a09johanengelen

46c4893a7458eda6edcd064121bc000634af7a09johanengelenvoid SnapManager::constrainedSnapReturnByRef(Geom::Point &p,

46c4893a7458eda6edcd064121bc000634af7a09johanengelen Inkscape::SnapSourceType const source_type,

46c4893a7458eda6edcd064121bc000634af7a09johanengelen Inkscape::Snapper::SnapConstraint const &constraint,

46c4893a7458eda6edcd064121bc000634af7a09johanengelen Geom::OptRect const &bbox_to_snap) const

46c4893a7458eda6edcd064121bc000634af7a09johanengelen{

46c4893a7458eda6edcd064121bc000634af7a09johanengelen Inkscape::SnappedPoint const s = constrainedSnap(Inkscape::SnapCandidatePoint(p, source_type), constraint, bbox_to_snap);

46c4893a7458eda6edcd064121bc000634af7a09johanengelen p = s.getPoint(); // If we didn't snap, then we will return the point projected onto the constraint

46c4893a7458eda6edcd064121bc000634af7a09johanengelen}

46c4893a7458eda6edcd064121bc000634af7a09johanengelen

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelenInkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::SnapCandidatePoint const &p,

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen Inkscape::Snapper::SnapConstraint const &constraint,

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen Geom::OptRect const &bbox_to_snap) const

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm{

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen // First project the mouse pointer onto the constraint

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen Geom::Point pp = constraint.projection(p.getPoint());

2d107ef9730aff3f4d776ae0c2f7d983e289ce02joncruz

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(pp, p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, NR_HUGE, 0, false, true, false);

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen if (!someSnapperMightSnap()) {

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen // Always return point on constraint

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen return no_snap;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm Inkscape::SnappedPoint result = no_snap;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm Inkscape::Preferences *prefs = Inkscape::Preferences::get();

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm if ((prefs->getBool("/options/snapmousepointer/value", false)) && p.isSingleHandle()) {

0fc5ce7045233dae7e15fdc86774370f1b1d73cbjohanengelen // Snapping the mouse pointer instead of the constrained position of the knot allows

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm // to snap to things which don't intersect with the constraint line; this is basically

0fc5ce7045233dae7e15fdc86774370f1b1d73cbjohanengelen // then just a freesnap with the constraint applied afterwards

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm // We'll only to this if we're dragging a single handle, and for example not when transforming an object in the selector tool

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen result = freeSnap(p, bbox_to_snap);

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen if (result.getSnapped()) {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm // only change the snap indicator if we really snapped to something

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen if (_snapindicator && _desktop) {

2d107ef9730aff3f4d776ae0c2f7d983e289ce02joncruz _desktop->snapindicator->set_new_snaptarget(result);

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm // Apply the constraint

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm result.setPoint(constraint.projection(result.getPoint()));

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm return result;

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm return no_snap;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm SnappedConstraints sc;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm SnapperList const snappers = getSnappers();

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm (*i)->constrainedSnap(sc, p, bbox_to_snap, constraint, &_items_to_ignore, _unselected_nodes);

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm result = findBestSnap(p, sc, true);

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix

73d455c08e8062e257dd052d2d690b9300434351cilix if (result.getSnapped()) {

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix // only change the snap indicator if we really snapped to something

73d455c08e8062e257dd052d2d690b9300434351cilix if (_snapindicator && _desktop) {

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix _desktop->snapindicator->set_new_snaptarget(result);

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix }

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix return result;

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix }

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix return no_snap;

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix}

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix

5be124ad592f5c71eca838ad2eaac9ffa953605fcilix

73d455c08e8062e257dd052d2d690b9300434351cilixInkscape::SnappedPoint SnapManager::multipleConstrainedSnaps(Inkscape::SnapCandidatePoint const &p,

73d455c08e8062e257dd052d2d690b9300434351cilix std::vector<Inkscape::Snapper::SnapConstraint> const &constraints,

73d455c08e8062e257dd052d2d690b9300434351cilix Geom::OptRect const &bbox_to_snap) const

1e944d29efb206f5d0b5d1069cb098e22169d548cilix{

79d46cc367c4181803d9a7a327b163643f23e8a7cilix

1e944d29efb206f5d0b5d1069cb098e22169d548cilix Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(p.getPoint(), p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, NR_HUGE, 0, false, true, false);

79d46cc367c4181803d9a7a327b163643f23e8a7cilix if (constraints.size() == 0) {

79d46cc367c4181803d9a7a327b163643f23e8a7cilix return no_snap;

1e944d29efb206f5d0b5d1069cb098e22169d548cilix }

5ce8d034d9fe78f969629cfe65d1a2518f173ba9cilix

5ce8d034d9fe78f969629cfe65d1a2518f173ba9cilix SnappedConstraints sc;

1e944d29efb206f5d0b5d1069cb098e22169d548cilix SnapperList const snappers = getSnappers();

1e944d29efb206f5d0b5d1069cb098e22169d548cilix std::vector<Geom::Point> projections;

73d455c08e8062e257dd052d2d690b9300434351cilix bool snapping_is_futile = !someSnapperMightSnap();

73d455c08e8062e257dd052d2d690b9300434351cilix

73d455c08e8062e257dd052d2d690b9300434351cilix Inkscape::SnappedPoint result = no_snap;

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix Inkscape::Preferences *prefs = Inkscape::Preferences::get();

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix bool snap_mouse = prefs->getBool("/options/snapmousepointer/value", false);

147c8e03bb214f85cd5906ddc6413c4293c4baa9cilix

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); c++) {

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix // Project the mouse pointer onto the constraint; In case we don't snap then we will

bb78cf2c3a2ee8ea2c98433128556847f03f5799cilix // return the projection onto the constraint, such that the constraint is always enforced

bb78cf2c3a2ee8ea2c98433128556847f03f5799cilix Geom::Point pp = (*c).projection(p.getPoint());

147c8e03bb214f85cd5906ddc6413c4293c4baa9cilix projections.push_back(pp);

bb78cf2c3a2ee8ea2c98433128556847f03f5799cilix }

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix if (snap_mouse && p.isSingleHandle()) {

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix // Snapping the mouse pointer instead of the constrained position of the knot allows

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix // to snap to things which don't intersect with the constraint line; this is basically

bb78cf2c3a2ee8ea2c98433128556847f03f5799cilix // then just a freesnap with the constraint applied afterwards

732fb09f9c502000068a77667c3356cbbd5d39d5cilix // We'll only to this if we're dragging a single handle, and for example not when transforming an object in the selector tool

732fb09f9c502000068a77667c3356cbbd5d39d5cilix result = freeSnap(p, bbox_to_snap);

732fb09f9c502000068a77667c3356cbbd5d39d5cilix } else {

732fb09f9c502000068a77667c3356cbbd5d39d5cilix // Iterate over the constraints

732fb09f9c502000068a77667c3356cbbd5d39d5cilix for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); c++) {

732fb09f9c502000068a77667c3356cbbd5d39d5cilix // Try to snap to the constraint

732fb09f9c502000068a77667c3356cbbd5d39d5cilix if (!snapping_is_futile) {

732fb09f9c502000068a77667c3356cbbd5d39d5cilix for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {

732fb09f9c502000068a77667c3356cbbd5d39d5cilix (*i)->constrainedSnap(sc, p, bbox_to_snap, *c, &_items_to_ignore,_unselected_nodes);

732fb09f9c502000068a77667c3356cbbd5d39d5cilix }

732fb09f9c502000068a77667c3356cbbd5d39d5cilix }

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix }

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix result = findBestSnap(p, sc, true);

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix }

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix

2d2706a9d621c0da51b7c4178fd5c7c5e4765122joncruz if (result.getSnapped()) {

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix if (snap_mouse) {

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix // If "snap_mouse" then we still have to apply the constraint, because so far we only tried a freeSnap

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix Geom::Point result_closest;

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); c++) {

04c99c338ffdc6e10cb6f5c18f6f06b3f555e8ebcilix // Project the mouse pointer onto the constraint; In case we don't snap then we will

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen // return the projection onto the constraint, such that the constraint is always enforced

73d455c08e8062e257dd052d2d690b9300434351cilix Geom::Point result_p = (*c).projection(result.getPoint());

73d455c08e8062e257dd052d2d690b9300434351cilix if (c == constraints.begin() || (Geom::L2(result_p - p.getPoint()) < Geom::L2(result_closest - p.getPoint()))) {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm result_closest = result_p;

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen result.setPoint(result_closest);

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen }

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen return result;

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen // So we didn't snap, but we still need to return a point on one of the constraints

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen // Find out which of the constraints yielded the closest projection of point p

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen for (std::vector<Geom::Point>::iterator pp = projections.begin(); pp != projections.end(); pp++) {

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen if (pp != projections.begin()) {

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen if (Geom::L2(*pp - p.getPoint()) < Geom::L2(no_snap.getPoint() - p.getPoint())) {

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen no_snap.setPoint(*pp);

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen }

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen } else {

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen no_snap.setPoint(projections.front());

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen

c0cd5511d3b975ebe07d019c1f5528108725e438johanengelen return no_snap;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm}

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrmInkscape::SnappedPoint SnapManager::constrainedAngularSnap(Inkscape::SnapCandidatePoint const &p,

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm boost::optional<Geom::Point> const &p_ref,

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm Geom::Point const &o,

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm unsigned const snaps) const

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen{

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen Inkscape::SnappedPoint sp;

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen if (snaps > 0) { // 0 means no angular snapping

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen // p is at an arbitrary angle. Now we should snap this angle to specific increments.

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen // For this we'll calculate the closest two angles, one at each side of the current angle

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen Geom::Line y_axis(Geom::Point(0, 0), Geom::Point(0, 1));

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen Geom::Line p_line(o, p.getPoint());

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen double angle = Geom::angle_between(y_axis, p_line);

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen double angle_incr = M_PI / snaps;

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen double angle_offset = 0;

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen if (p_ref) {

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen Geom::Line p_line_ref(o, *p_ref);

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen angle_offset = Geom::angle_between(y_axis, p_line_ref);

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen }

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen double angle_ceil = round_to_upper_multiple_plus(angle, angle_incr, angle_offset);

93bb287e28a818fd5ba61b99d012e0500a49ccf6johanengelen double angle_floor = round_to_lower_multiple_plus(angle, angle_incr, angle_offset);

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen // We have two angles now. The constrained snapper will try each of them and return the closest

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen // Now do the snapping...

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen std::vector<Inkscape::Snapper::SnapConstraint> constraints;

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen constraints.push_back(Inkscape::Snapper::SnapConstraint(Geom::Line(o, angle_ceil - M_PI/2)));

af8d25189f88abf89cdbe0e180e271c94079624fbuliabyak constraints.push_back(Inkscape::Snapper::SnapConstraint(Geom::Line(o, angle_floor - M_PI/2)));

af8d25189f88abf89cdbe0e180e271c94079624fbuliabyak sp = multipleConstrainedSnaps(p, constraints); // Constraints will always be applied, even if we didn't snap

af8d25189f88abf89cdbe0e180e271c94079624fbuliabyak if (!sp.getSnapped()) { // If we haven't snapped then we only had the constraint applied;

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen sp.setTarget(Inkscape::SNAPTARGET_CONSTRAINED_ANGLE);

af8d25189f88abf89cdbe0e180e271c94079624fbuliabyak }

a0334366488989ef25fb812d7030d298c0917c96johanengelen } else {

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen sp = freeSnap(p);

a0334366488989ef25fb812d7030d298c0917c96johanengelen }

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen return sp;

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen}

a0334366488989ef25fb812d7030d298c0917c96johanengelen

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelenvoid SnapManager::guideFreeSnap(Geom::Point &p, Geom::Point const &guide_normal, SPGuideDragType drag_type) const

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen{

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally()) {

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen return;

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen }

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen if (!(object.ThisSnapperMightSnap() || snapprefs.getSnapToGuides())) {

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen return;

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen }

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen Inkscape::SnapCandidatePoint candidate(p, Inkscape::SNAPSOURCE_GUIDE_ORIGIN);

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen if (drag_type == SP_DRAG_ROTATE) {

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen candidate = Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_GUIDE);

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen }

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen // Snap to nodes

fb5a72174252e0e79107dcad3bf5a2bbd73e349cjohanengelen SnappedConstraints sc;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm if (object.ThisSnapperMightSnap()) {

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen object.guideFreeSnap(sc, p, guide_normal);

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen }

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen // Snap to guides & grid lines

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen SnapperList snappers = getGridSnappers();

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen snappers.push_back(&guide);

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen (*i)->freeSnap(sc, candidate, Geom::OptRect(), NULL, NULL);

42e99769805c14a5cc01c805faa3c3b03f9dd1c0johanengelen }

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen

a797dcb8e284cab19f60b3eff93a53a62abda263johanengelen Inkscape::SnappedPoint const s = findBestSnap(candidate, sc, false, false);

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen s.getPointIfSnapped(p);

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen}

56542e2b97ec8826cc692153b0e2d4f5ac8ef913johanengelen

42ba1b712b7b430669fc49aa9facb439181081becilix

42ba1b712b7b430669fc49aa9facb439181081becilixvoid SnapManager::guideConstrainedSnap(Geom::Point &p, SPGuide const &guideline) const

42ba1b712b7b430669fc49aa9facb439181081becilix{

42ba1b712b7b430669fc49aa9facb439181081becilix if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally()) {

42ba1b712b7b430669fc49aa9facb439181081becilix return;

42ba1b712b7b430669fc49aa9facb439181081becilix }

42ba1b712b7b430669fc49aa9facb439181081becilix

42ba1b712b7b430669fc49aa9facb439181081becilix if (!(object.ThisSnapperMightSnap() || snapprefs.getSnapToGuides())) {

42ba1b712b7b430669fc49aa9facb439181081becilix return;

42ba1b712b7b430669fc49aa9facb439181081becilix }

42ba1b712b7b430669fc49aa9facb439181081becilix

42ba1b712b7b430669fc49aa9facb439181081becilix Inkscape::SnapCandidatePoint candidate(p, Inkscape::SNAPSOURCE_GUIDE_ORIGIN, Inkscape::SNAPTARGET_UNDEFINED);

42ba1b712b7b430669fc49aa9facb439181081becilix

42ba1b712b7b430669fc49aa9facb439181081becilix // Snap to nodes or paths

42ba1b712b7b430669fc49aa9facb439181081becilix SnappedConstraints sc;

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm Inkscape::Snapper::SnapConstraint cl(guideline.point_on_line, Geom::rot90(guideline.normal_to_line));

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm if (object.ThisSnapperMightSnap()) {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm object.constrainedSnap(sc, candidate, Geom::OptRect(), cl, NULL, NULL);

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm // Snap to guides & grid lines

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm SnapperList snappers = getGridSnappers();

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm snappers.push_back(&guide);

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm (*i)->constrainedSnap(sc, candidate, Geom::OptRect(), cl, NULL, NULL);

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm }

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm Inkscape::SnappedPoint const s = findBestSnap(candidate, sc, false);

f07bfd5a05d43a6d11f7cd442f085149092dea88pjrm s.getPointIfSnapped(p);

}

Inkscape::SnappedPoint SnapManager::_snapTransformed(

std::vector<Inkscape::SnapCandidatePoint> const &points,

Geom::Point const &pointer,

bool constrained,

Inkscape::Snapper::SnapConstraint const &constraint,

Transformation transformation_type,

Geom::Point const &transformation,

Geom::Point const &origin,

Geom::Dim2 dim,

bool uniform) const

{

/* We have a list of points, which we are proposing to transform in some way. We need to see

/* Quick check to see if we have any snappers that are enabled

if (someSnapperMightSnap() == false || points.size() == 0) {

return Inkscape::SnappedPoint(pointer);

}

std::vector<Inkscape::SnapCandidatePoint> transformed_points;

Geom::Rect bbox;

long source_num = 0;

for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); i++) {

/* Work out the transformed version of this point */

Geom::Point transformed = _transformPoint(*i, transformation_type, transformation, origin, dim, uniform);

// add the current transformed point to the box hulling all transformed points

if (i == points.begin()) {

bbox = Geom::Rect(transformed, transformed);

} else {

bbox.expandTo(transformed);

}

transformed_points.push_back(Inkscape::SnapCandidatePoint(transformed, (*i).getSourceType(), source_num, Inkscape::SNAPTARGET_UNDEFINED, Geom::OptRect()));

source_num++;

}

/* The current best transformation */

Geom::Point best_transformation = transformation;

/* The current best metric for the best transformation; lower is better, NR_HUGE

Geom::Point best_scale_metric(NR_HUGE, NR_HUGE);

Inkscape::SnappedPoint best_snapped_point;

g_assert(best_snapped_point.getAlwaysSnap() == false); // Check initialization of snapped point

g_assert(best_snapped_point.getAtIntersection() == false);

// Warnings for the devs

if (constrained && transformation_type == SCALE && !uniform) {

g_warning("Non-uniform constrained scaling is not supported!");

}

if (!constrained && transformation_type == ROTATE) {

// We do not yet allow for simultaneous rotation and scaling

g_warning("Unconstrained rotation is not supported!");

}

std::vector<Inkscape::SnapCandidatePoint>::iterator j = transformed_points.begin();

// std::cout << std::endl;

bool first_free_snap = true;

for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); i++) {

/* Snap it */

Inkscape::SnappedPoint snapped_point;

Inkscape::Snapper::SnapConstraint dedicated_constraint = constraint;

Geom::Point const b = ((*i).getPoint() - origin); // vector to original point (not the transformed point! required for rotations!)

if (constrained) {

if (((transformation_type == SCALE || transformation_type == STRETCH) && uniform)) {

// When uniformly scaling, each point will have its own unique constraint line,

// running from the scaling origin to the original untransformed point. We will

// calculate that line here

dedicated_constraint = Inkscape::Snapper::SnapConstraint(origin, b);

} else if (transformation_type == ROTATE) {

Geom::Coord r = Geom::L2(b); // the radius of the circular constraint

if (r < 1e-9) { // points too close to the rotation center will not move. Don't try to snap these

// as they will always yield a perfect snap result if they're already snapped beforehand (e.g.

// when the transformation center has been snapped to a grid intersection in the selector tool)

continue; // skip this SnapCandidate and continue with the next one

// PS1: Apparently we don't have to do this for skewing, but why?

// PS2: We cannot easily filter these points upstream, e.g. in the grab() method (seltrans.cpp)

// because the rotation center will change when pressing shift, and grab() won't be recalled.

// Filtering could be done in handleRequest() (again in seltrans.cpp), by iterating through

// the snap candidates. But hey, we're iterating here anyway.

}

dedicated_constraint = Inkscape::Snapper::SnapConstraint(origin, b, r);

} else if (transformation_type == STRETCH) { // when non-uniform stretching {

dedicated_constraint = Inkscape::Snapper::SnapConstraint((*i).getPoint(), component_vectors[dim]);

} else if (transformation_type == TRANSLATE) {

// When doing a constrained translation, all points will move in the same direction, i.e.

// either horizontally or vertically. The lines along which they move are therefore all

// parallel, but might not be colinear. Therefore we will have to specify the point through

// which the constraint-line runs here, for each point individually. (we could also have done this

// earlier on, e.g. in seltrans.cpp but we're being lazy there and don't want to add an iteration loop)

dedicated_constraint = Inkscape::Snapper::SnapConstraint((*i).getPoint(), constraint.getDirection());

} // else: leave the original constraint, e.g. for skewing

snapped_point = constrainedSnap(*j, dedicated_constraint, bbox);

} else {

bool const c1 = fabs(b[Geom::X]) < 1e-6;

bool const c2 = fabs(b[Geom::Y]) < 1e-6;

if (transformation_type == SCALE && (c1 || c2) && !(c1 && c2)) {

// When scaling, a point aligned either horizontally or vertically with the origin can only

// move in that specific direction; therefore it should only snap in that direction, otherwise

// we will get snapped points with an invalid transformation

dedicated_constraint = Inkscape::Snapper::SnapConstraint(origin, component_vectors[c1]);

snapped_point = constrainedSnap(*j, dedicated_constraint, bbox);

} else {

// If we have a collection of SnapCandidatePoints, with mixed constrained snapping and free snapping

// requirements, then freeSnap might never see the SnapCandidatePoint with source_num == 0. The freeSnap()

// method in the object snapper depends on this, because only for source-num == 0 the target nodes will

// be collected. Therefore we enforce that the first SnapCandidatePoint that is to be freeSnapped always

// has source_num == 0;

// TODO: This is a bit ugly so fix this; do we need sourcenum for anything else? if we don't then get rid

// of it and explicitely communicate to the object snapper that this is a first point

if (first_free_snap) {

(*j).setSourceNum(0);

first_free_snap = false;

}

snapped_point = freeSnap(*j, bbox);

}

}

// std::cout << "dist = " << snapped_point.getSnapDistance() << std::endl;

snapped_point.setPointerDistance(Geom::L2(pointer - (*i).getPoint()));

Geom::Point result;

if (snapped_point.getSnapped()) {

/* We snapped. Find the transformation that describes where the snapped point has

Geom::Point const a = snapped_point.getPoint() - origin; // vector to snapped point

//Geom::Point const b = (*i - origin); // vector to original point

switch (transformation_type) {

case TRANSLATE:

result = snapped_point.getPoint() - (*i).getPoint();

/* Consider the case in which a box is almost aligned with a grid in both

// Only for translations, the relevant metric will be the real snapped distance,

// so we don't have to do anything special here

break;

case SCALE:

{

result = Geom::Point(NR_HUGE, NR_HUGE);

// If this point *i is horizontally or vertically aligned with

// the origin of the scaling, then it will scale purely in X or Y

// We can therefore only calculate the scaling in this direction

// and the scaling factor for the other direction should remain

// untouched (unless scaling is uniform of course)

for (int index = 0; index < 2; index++) {

if (fabs(b[index]) > 1e-6) { // if SCALING CAN occur in this direction

if (fabs(fabs(a[index]/b[index]) - fabs(transformation[index])) > 1e-12) { // if SNAPPING DID occur in this direction

result[index] = a[index] / b[index]; // then calculate it!

}

// we might leave result[1-index] = NR_HUGE

// if scaling didn't occur in the other direction

}

}

if (uniform) {

if (fabs(result[0]) < fabs(result[1])) {

result[1] = result[0];

} else {

result[0] = result[1];

}

}

// Compare the resulting scaling with the desired scaling

Geom::Point scale_metric = Geom::abs(result - transformation); // One or both of its components might be NR_HUGE

snapped_point.setSnapDistance(std::min(scale_metric[0], scale_metric[1]));

snapped_point.setSecondSnapDistance(std::max(scale_metric[0], scale_metric[1]));

break;

}

case STRETCH:

result = Geom::Point(NR_HUGE, NR_HUGE);

if (fabs(b[dim]) > 1e-6) { // if STRETCHING will occur for this point

result[dim] = a[dim] / b[dim];

result[1-dim] = uniform ? result[dim] : 1;

} else { // STRETCHING might occur for this point, but only when the stretching is uniform

if (uniform && fabs(b[1-dim]) > 1e-6) {

result[1-dim] = a[1-dim] / b[1-dim];

result[dim] = result[1-dim];

}

}

// Store the metric for this transformation as a virtual distance

snapped_point.setSnapDistance(std::abs(result[dim] - transformation[dim]));

snapped_point.setSecondSnapDistance(NR_HUGE);

break;

case SKEW:

result[0] = (snapped_point.getPoint()[dim] - ((*i).getPoint())[dim]) / b[1 - dim]; // skew factor

result[1] = transformation[1]; // scale factor

// Store the metric for this transformation as a virtual distance

snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));

snapped_point.setSecondSnapDistance(NR_HUGE);

break;

case ROTATE:

// a is vector to snapped point; b is vector to original point; now lets calculate angle between a and b

result[0] = atan2(Geom::dot(Geom::rot90(b), a), Geom::dot(b, a));

result[1] = result[1]; // how else should we store an angle in a point ;-)

// Store the metric for this transformation as a virtual distance (we're storing an angle)

snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));

snapped_point.setSecondSnapDistance(NR_HUGE);

break;

default:

g_assert_not_reached();

}

if (best_snapped_point.isOtherSnapBetter(snapped_point, true)) {

best_transformation = result;

best_snapped_point = snapped_point;

}

}

j++;

}

Geom::Coord best_metric;

if (transformation_type == SCALE) {

// When scaling, don't ever exit with one of scaling components set to NR_HUGE

for (int index = 0; index < 2; index++) {

if (best_transformation[index] == NR_HUGE) {

if (uniform && best_transformation[1-index] < NR_HUGE) {

best_transformation[index] = best_transformation[1-index];

} else {

best_transformation[index] = transformation[index];

}

}

}

}

best_metric = best_snapped_point.getSnapDistance();

best_snapped_point.setTransformation(best_transformation);

// Using " < 1e6" instead of " < NR_HUGE" for catching some rounding errors

// These rounding errors might be caused by NRRects, see bug #1584301

best_snapped_point.setSnapDistance(best_metric < 1e6 ? best_metric : NR_HUGE);

return best_snapped_point;

}

Inkscape::SnappedPoint SnapManager::freeSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,

Geom::Point const &pointer,

Geom::Point const &tr) const

{

if (p.size() == 1) {

Geom::Point pt = _transformPoint(p.at(0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);

_displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));

}

return _snapTransformed(p, pointer, false, Geom::Point(0,0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);

}

Inkscape::SnappedPoint SnapManager::constrainedSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,

Geom::Point const &pointer,

Inkscape::Snapper::SnapConstraint const &constraint,

Geom::Point const &tr) const

{

if (p.size() == 1) {

Geom::Point pt = _transformPoint(p.at(0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);

_displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));

}

return _snapTransformed(p, pointer, true, constraint, TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);

}

Inkscape::SnappedPoint SnapManager::freeSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,

Geom::Point const &pointer,

Geom::Scale const &s,

Geom::Point const &o) const

{

if (p.size() == 1) {

Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);

_displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));

}

return _snapTransformed(p, pointer, false, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);

}

Inkscape::SnappedPoint SnapManager::constrainedSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,

Geom::Point const &pointer,

Geom::Scale const &s,

Geom::Point const &o) const

{

// When constrained scaling, only uniform scaling is supported.

if (p.size() == 1) {

Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);

_displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));

}

return _snapTransformed(p, pointer, true, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);

}

Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(std::vector<Inkscape::SnapCandidatePoint> const &p,

Geom::Point const &pointer,

Geom::Coord const &s,

Geom::Point const &o,

Geom::Dim2 d,

bool u) const

{

if (p.size() == 1) {

Geom::Point pt = _transformPoint(p.at(0), STRETCH, Geom::Point(s, s), o, d, u);

_displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));

}

return _snapTransformed(p, pointer, true, Geom::Point(0,0), STRETCH, Geom::Point(s, s), o, d, u);

}

Inkscape::SnappedPoint SnapManager::constrainedSnapSkew(std::vector<Inkscape::SnapCandidatePoint> const &p,

Geom::Point const &pointer,

Inkscape::Snapper::SnapConstraint const &constraint,

Geom::Point const &s,

Geom::Point const &o,

Geom::Dim2 d) const

{

// "s" contains skew factor in s[0], and scale factor in s[1]

// Snapping the nodes of the bounding box of a selection that is being transformed, will only work if

// the transformation of the bounding box is equal to the transformation of the individual nodes. This is

// NOT the case for example when rotating or skewing. The bounding box itself cannot possibly rotate or skew,

// so it's corners have a different transformation. The snappers cannot handle this, therefore snapping

// of bounding boxes is not allowed here.

if (p.size() > 0) {

g_assert(!(p.at(0).getSourceType() & Inkscape::SNAPSOURCE_BBOX_CATEGORY));

}

if (p.size() == 1) {

Geom::Point pt = _transformPoint(p.at(0), SKEW, s, o, d, false);

_displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));

}

return _snapTransformed(p, pointer, true, constraint, SKEW, s, o, d, false);

}

Inkscape::SnappedPoint SnapManager::constrainedSnapRotate(std::vector<Inkscape::SnapCandidatePoint> const &p,

Geom::Point const &pointer,

Geom::Coord const &angle,

Geom::Point const &o) const

{

// Snapping the nodes of the bounding box of a selection that is being transformed, will only work if

// the transformation of the bounding box is equal to the transformation of the individual nodes. This is

// NOT the case for example when rotating or skewing. The bounding box itself cannot possibly rotate or skew,

// so it's corners have a different transformation. The snappers cannot handle this, therefore snapping

// of bounding boxes is not allowed here.

if (p.size() == 1) {

Geom::Point pt = _transformPoint(p.at(0), ROTATE, Geom::Point(angle, angle), o, Geom::X, false);

_displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));

}

return _snapTransformed(p, pointer, true, Geom::Point(0,0), ROTATE, Geom::Point(angle, angle), o, Geom::X, false);

}

Inkscape::SnappedPoint SnapManager::findBestSnap(Inkscape::SnapCandidatePoint const &p,

SnappedConstraints const &sc,

bool constrained,

bool noCurves,

bool allowOffScreen) const

{

g_assert(_desktop != NULL);

/*

// Store all snappoints

std::list<Inkscape::SnappedPoint> sp_list;

// search for the closest snapped point

Inkscape::SnappedPoint closestPoint;

if (getClosestSP(sc.points, closestPoint)) {

sp_list.push_back(closestPoint);

}

// search for the closest snapped curve

if (!noCurves) {

Inkscape::SnappedCurve closestCurve;

if (getClosestCurve(sc.curves, closestCurve)) {

sp_list.push_back(Inkscape::SnappedPoint(closestCurve));

}

}

if (snapprefs.getSnapIntersectionCS()) {

// search for the closest snapped intersection of curves

Inkscape::SnappedPoint closestCurvesIntersection;

if (getClosestIntersectionCS(sc.curves, p.getPoint(), closestCurvesIntersection, _desktop->dt2doc())) {

closestCurvesIntersection.setSource(p.getSourceType());

sp_list.push_back(closestCurvesIntersection);

}

}

// search for the closest snapped grid line

Inkscape::SnappedLine closestGridLine;

if (getClosestSL(sc.grid_lines, closestGridLine)) {

sp_list.push_back(Inkscape::SnappedPoint(closestGridLine));

}

// search for the closest snapped guide line

Inkscape::SnappedLine closestGuideLine;

if (getClosestSL(sc.guide_lines, closestGuideLine)) {

sp_list.push_back(Inkscape::SnappedPoint(closestGuideLine));

}

// When freely snapping to a grid/guide/path, only one degree of freedom is eliminated

// Therefore we will try get fully constrained by finding an intersection with another grid/guide/path

// When doing a constrained snap however, we're already at an intersection of the constrained line and

// the grid/guide/path we're snapping to. This snappoint is therefore fully constrained, so there's

// no need to look for additional intersections

if (!constrained) {

// search for the closest snapped intersection of grid lines

Inkscape::SnappedPoint closestGridPoint;

if (getClosestIntersectionSL(sc.grid_lines, closestGridPoint)) {

closestGridPoint.setSource(p.getSourceType());

closestGridPoint.setTarget(Inkscape::SNAPTARGET_GRID_INTERSECTION);

sp_list.push_back(closestGridPoint);

}

// search for the closest snapped intersection of guide lines

Inkscape::SnappedPoint closestGuidePoint;

if (getClosestIntersectionSL(sc.guide_lines, closestGuidePoint)) {

closestGuidePoint.setSource(p.getSourceType());

closestGuidePoint.setTarget(Inkscape::SNAPTARGET_GUIDE_INTERSECTION);

sp_list.push_back(closestGuidePoint);

}

// search for the closest snapped intersection of grid with guide lines

if (snapprefs.getSnapIntersectionGG()) {

Inkscape::SnappedPoint closestGridGuidePoint;

if (getClosestIntersectionSL(sc.grid_lines, sc.guide_lines, closestGridGuidePoint)) {

closestGridGuidePoint.setSource(p.getSourceType());

closestGridGuidePoint.setTarget(Inkscape::SNAPTARGET_GRID_GUIDE_INTERSECTION);

sp_list.push_back(closestGridGuidePoint);

}

}

}

// now let's see which snapped point gets a thumbs up

Inkscape::SnappedPoint bestSnappedPoint(p.getPoint());

// std::cout << "Finding the best snap..." << std::endl;

for (std::list<Inkscape::SnappedPoint>::const_iterator i = sp_list.begin(); i != sp_list.end(); i++) {

// std::cout << "sp = " << (*i).getPoint() << " | source = " << (*i).getSource() << " | target = " << (*i).getTarget();

bool onScreen = _desktop->get_display_area().contains((*i).getPoint());

if (onScreen || allowOffScreen) { // Only snap to points which are not off the screen

if ((*i).getSnapDistance() <= (*i).getTolerance()) { // Only snap to points within snapping range

// if it's the first point, or if it is closer than the best snapped point so far

if (i == sp_list.begin() || bestSnappedPoint.isOtherSnapBetter(*i, false)) {

// then prefer this point over the previous one

bestSnappedPoint = *i;

}

}

}

// std::cout << std::endl;

}

// Update the snap indicator, if requested

if (_snapindicator) {

if (bestSnappedPoint.getSnapped()) {

_desktop->snapindicator->set_new_snaptarget(bestSnappedPoint);

} else {

_desktop->snapindicator->remove_snaptarget();

}

}

// std::cout << "findBestSnap = " << bestSnappedPoint.getPoint() << " | dist = " << bestSnappedPoint.getSnapDistance() << std::endl;

return bestSnappedPoint;

}

void SnapManager::setup(SPDesktop const *desktop,

bool snapindicator,

SPItem const *item_to_ignore,

std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,

SPGuide *guide_to_ignore)

{

g_assert(desktop != NULL);

if (_desktop != NULL) {

g_warning("The snapmanager has been set up before, but unSetup() hasn't been called afterwards. It possibly held invalid pointers");

}

_items_to_ignore.clear();

_items_to_ignore.push_back(item_to_ignore);

_desktop = desktop;

_snapindicator = snapindicator;

_unselected_nodes = unselected_nodes;

_guide_to_ignore = guide_to_ignore;

_rotation_center_source_items = NULL;

}

void SnapManager::setup(SPDesktop const *desktop,

bool snapindicator,

std::vector<SPItem const *> &items_to_ignore,

std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,

SPGuide *guide_to_ignore)

{

g_assert(desktop != NULL);

if (_desktop != NULL) {

g_warning("The snapmanager has been set up before, but unSetup() hasn't been called afterwards. It possibly held invalid pointers");

}

_items_to_ignore = items_to_ignore;

_desktop = desktop;

_snapindicator = snapindicator;

_unselected_nodes = unselected_nodes;

_guide_to_ignore = guide_to_ignore;

_rotation_center_source_items = NULL;

}

void SnapManager::setupIgnoreSelection(SPDesktop const *desktop,

bool snapindicator,

std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes,

SPGuide *guide_to_ignore)

{

g_assert(desktop != NULL);

if (_desktop != NULL) {

// Someone has been naughty here! This is dangerous

g_warning("The snapmanager has been set up before, but unSetup() hasn't been called afterwards. It possibly held invalid pointers");

}

_desktop = desktop;