trunk/src/object-snapper.cpp

   1 /**
   2  *  \file object-snapper.cpp
   3  *  \brief Snapping things to objects.
   4  *
   5  * Authors:
   6  *   Carl Hetherington <inkscape@carlh.net>
   7  *   Diederik van Lierop <mail@diedenrezi.nl>
   8  *
   9  * Copyright (C) 2005 - 2008 Authors
  10  *
  11  * Released under GNU GPL, read the file 'COPYING' for more information
  12  */
  13
  14 #include "svg/svg.h"
  15 #include "libnr/nr-rect-ops.h"
  16 #include "libnr/nr-point-fns.h"
  17 #include <2geom/path-intersection.h>
  18 #include <2geom/point.h>
  19 #include <2geom/rect.h>
  20 #include "document.h"
  21 #include "sp-namedview.h"
  22 #include "sp-image.h"
  23 #include "sp-item-group.h"
  24 #include "sp-item.h"
  25 #include "sp-use.h"
  26 #include "display/curve.h"
  27 #include "inkscape.h"
  28 #include "preferences.h"
  29 #include "sp-text.h"
  30 #include "sp-flowtext.h"
  31 #include "text-editing.h"
  32 #include "sp-clippath.h"
  33 #include "sp-mask.h"
  34 #include "helper/geom-curves.h"
  35 #include "desktop.h"
  36
  37 Inkscape::SnapCandidate::SnapCandidate(SPItem* item, bool clip_or_mask, Geom::Matrix additional_affine)
  38     : item(item), clip_or_mask(clip_or_mask), additional_affine(additional_affine)
  39 {
  40 }
  41
  42 Inkscape::SnapCandidate::~SnapCandidate()
  43 {
  44 }
  45
  46 Inkscape::ObjectSnapper::ObjectSnapper(SnapManager *sm, Geom::Coord const d)
  47     : Snapper(sm, d)
  48 {
  49     _candidates = new std::vector<SnapCandidate>;
  50     _points_to_snap_to = new std::vector<Geom::Point>;
  51     _paths_to_snap_to = new std::vector<std::pair<Geom::PathVector*, SnapTargetType> >;
  52 }
  53
  54 Inkscape::ObjectSnapper::~ObjectSnapper()
  55 {
  56     _candidates->clear();
  57     delete _candidates;
  58
  59     _points_to_snap_to->clear();
  60     delete _points_to_snap_to;
  61
  62     _clear_paths();
  63     delete _paths_to_snap_to;
  64 }
  65
  66 /**
  67  *  \return Snap tolerance (desktop coordinates); depends on current zoom so that it's always the same in screen pixels
  68  */
  69 Geom::Coord Inkscape::ObjectSnapper::getSnapperTolerance() const
  70 {
  71         SPDesktop const *dt = _snapmanager->getDesktop();
  72         double const zoom =  dt ? dt->current_zoom() : 1;
  73         return _snapmanager->snapprefs.getObjectTolerance() / zoom;
  74 }
  75
  76 bool Inkscape::ObjectSnapper::getSnapperAlwaysSnap() const
  77 {
  78     return _snapmanager->snapprefs.getObjectTolerance() == 10000; //TODO: Replace this threshold of 10000 by a constant; see also tolerance-slider.cpp
  79 }
  80
  81 /**
  82  *  Find all items within snapping range.
  83  *  \param parent Pointer to the document's root, or to a clipped path or mask object
  84  *  \param it List of items to ignore
  85  *  \param first_point If true then this point is the first one from a whole bunch of points
  86  *  \param bbox_to_snap Bounding box hulling the whole bunch of points, all from the same selection and having the same transformation
  87  *  \param DimensionToSnap Snap in X, Y, or both directions.
  88  */
  89
  90 void Inkscape::ObjectSnapper::_findCandidates(SPObject* parent,
  91                                               std::vector<SPItem const *> const *it,
  92                                               bool const &first_point,
  93                                               Geom::Rect const &bbox_to_snap,
  94                                               DimensionToSnap const snap_dim,
  95                                               bool const clip_or_mask,
  96                                               Geom::Matrix const additional_affine) const // transformation of the item being clipped / masked
  97 {
  98     bool const c1 = (snap_dim == TRANSL_SNAP_XY) && ThisSnapperMightSnap();
  99     bool const c2 = (snap_dim != TRANSL_SNAP_XY) && GuidesMightSnap();
 100
 101     if (!(c1 || c2)) {
 102         return;
 103     }
 104
 105     if (first_point) {
 106         _candidates->clear();
 107     }
 108
 109     Geom::Rect bbox_to_snap_incl = bbox_to_snap; // _incl means: will include the snapper tolerance
 110     bbox_to_snap_incl.expandBy(getSnapperTolerance()); // see?
 111
 112     for (SPObject* o = sp_object_first_child(parent); o != NULL; o = SP_OBJECT_NEXT(o)) {
 113         g_assert(_snapmanager->getDesktop() != NULL);
 114         if (SP_IS_ITEM(o) && !SP_ITEM(o)->isLocked() && !(_snapmanager->getDesktop()->itemIsHidden(SP_ITEM(o)) && !clip_or_mask)) {
 115             // Don't snap to locked items, and
 116             // don't snap to hidden objects, unless they're a clipped path or a mask
 117             /* See if this item is on the ignore list */
 118             std::vector<SPItem const *>::const_iterator i;
 119             if (it != NULL) {
 120                 i = it->begin();
 121                 while (i != it->end() && *i != o) {
 122                     i++;
 123                 }
 124             }
 125
 126             if (it == NULL || i == it->end()) {
 127                 SPItem *item = SP_ITEM(o);
 128                 if (item) {
 129                     SPObject *obj = NULL;
 130                     if (!clip_or_mask) { // cannot clip or mask more than once
 131                         // The current item is not a clipping path or a mask, but might
 132                         // still be the subject of clipping or masking itself ; if so, then
 133                         // we should also consider that path or mask for snapping to
 134                         obj = SP_OBJECT(item->clip_ref->getObject());
 135                         if (obj) {
 136                             _findCandidates(obj, it, false, bbox_to_snap, snap_dim, true, sp_item_i2doc_affine(item));
 137                         }
 138                         obj = SP_OBJECT(item->mask_ref->getObject());
 139                         if (obj) {
 140                             _findCandidates(obj, it, false, bbox_to_snap, snap_dim, true, sp_item_i2doc_affine(item));
 141                         }
 142                     }
 143                 }
 144
 145                 if (SP_IS_GROUP(o)) {
 146                     _findCandidates(o, it, false, bbox_to_snap, snap_dim, clip_or_mask, additional_affine);
 147                 } else {
 148                     Geom::OptRect bbox_of_item = Geom::Rect();
 149                     if (clip_or_mask) {
 150                         // Oh oh, this will get ugly. We cannot use sp_item_i2d_affine directly because we need to
 151                         // insert an additional transformation in document coordinates (code copied from sp_item_i2d_affine)
 152                         sp_item_invoke_bbox(item,
 153                             bbox_of_item,
 154                             sp_item_i2doc_affine(item) * additional_affine * _snapmanager->getDesktop()->doc2dt(),
 155                             true);
 156                     } else {
 157                         sp_item_invoke_bbox(item, bbox_of_item, sp_item_i2d_affine(item), true);
 158                     }
 159                     if (bbox_of_item) {
 160                         // See if the item is within range
 161                         if (bbox_to_snap_incl.intersects(*bbox_of_item)) {
 162                             // This item is within snapping range, so record it as a candidate
 163                             _candidates->push_back(SnapCandidate(item, clip_or_mask, additional_affine));
 164                         }
 165                     }
 166                 }
 167             }
 168         }
 169     }
 170 }
 171
 172
 173 void Inkscape::ObjectSnapper::_collectNodes(Inkscape::SnapPreferences::PointType const &t,
 174                                          bool const &first_point) const
 175 {
 176     // Now, let's first collect all points to snap to. If we have a whole bunch of points to snap,
 177     // e.g. when translating an item using the selector tool, then we will only do this for the
 178     // first point and store the collection for later use. This significantly improves the performance
 179     if (first_point) {
 180         _points_to_snap_to->clear();
 181
 182          // Determine the type of bounding box we should snap to
 183         SPItem::BBoxType bbox_type = SPItem::GEOMETRIC_BBOX;
 184
 185         bool p_is_a_node = t & Inkscape::SnapPreferences::SNAPPOINT_NODE;
 186         bool p_is_a_bbox = t & Inkscape::SnapPreferences::SNAPPOINT_BBOX;
 187         bool p_is_a_guide = t & Inkscape::SnapPreferences::SNAPPOINT_GUIDE;
 188
 189         // A point considered for snapping should be either a node, a bbox corner or a guide. Pick only ONE!
 190         g_assert(!((p_is_a_node && p_is_a_bbox) || (p_is_a_bbox && p_is_a_guide) || (p_is_a_node && p_is_a_guide)));
 191
 192         if (_snapmanager->snapprefs.getSnapToBBoxNode() || _snapmanager->snapprefs.getSnapBBoxEdgeMidpoints() || _snapmanager->snapprefs.getSnapBBoxMidpoints()) {
 193             Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 194             bool prefs_bbox = prefs->getBool("/tools/bounding_box");
 195             bbox_type = !prefs_bbox ?
 196                 SPItem::APPROXIMATE_BBOX : SPItem::GEOMETRIC_BBOX;
 197         }
 198
 199         // Consider the page border for snapping
 200         if (_snapmanager->snapprefs.getSnapToPageBorder()) {
 201             _getBorderNodes(_points_to_snap_to);
 202         }
 203
 204         for (std::vector<SnapCandidate>::const_iterator i = _candidates->begin(); i != _candidates->end(); i++) {
 205             //Geom::Matrix i2doc(Geom::identity());
 206             SPItem *root_item = (*i).item;
 207             if (SP_IS_USE((*i).item)) {
 208                 root_item = sp_use_root(SP_USE((*i).item));
 209             }
 210             g_return_if_fail(root_item);
 211
 212             //Collect all nodes so we can snap to them
 213                         if (p_is_a_node || !(_snapmanager->snapprefs.getStrictSnapping() && !p_is_a_node) || p_is_a_guide) {
 214                                 // Note: there are two ways in which intersections are considered:
 215                                 // Method 1: Intersections are calculated for each shape individually, for both the
 216                                 //           snap source and snap target (see sp_shape_snappoints)
 217                                 // Method 2: Intersections are calculated for each curve or line that we've snapped to, i.e. only for
 218                                 //           the target (see the intersect() method in the SnappedCurve and SnappedLine classes)
 219                                 // Some differences:
 220                                 // - Method 1 doesn't find intersections within a set of multiple objects
 221                                 // - Method 2 only works for targets
 222                                 // When considering intersections as snap targets:
 223                                 // - Method 1 only works when snapping to nodes, whereas
 224                                 // - Method 2 only works when snapping to paths
 225                                 // - There will be performance differences too!
 226                                 // If both methods are being used simultaneously, then this might lead to duplicate targets!
 227
 228                                 // Well, here we will be looking for snap TARGETS. Both methods can therefore be used.
 229                                 // When snapping to paths, we will get a collection of snapped lines and snapped curves. findBestSnap() will
 230                                 // go hunting for intersections (but only when asked to in the prefs of course). In that case we can just
 231                                 // temporarily block the intersections in sp_item_snappoints, we don't need duplicates. If we're not snapping to
 232                                 // paths though but only to item nodes then we should still look for the intersections in sp_item_snappoints()
 233                                 bool old_pref = _snapmanager->snapprefs.getSnapIntersectionCS();
 234                                 if (_snapmanager->snapprefs.getSnapToItemPath()) {
 235                                         _snapmanager->snapprefs.setSnapIntersectionCS(false);
 236                                 }
 237
 238                                 sp_item_snappoints(root_item, SnapPointsIter(*_points_to_snap_to), &_snapmanager->snapprefs);
 239
 240                                 if (_snapmanager->snapprefs.getSnapToItemPath()) {
 241                                         _snapmanager->snapprefs.setSnapIntersectionCS(old_pref);
 242                                 }
 243                         }
 244
 245             //Collect the bounding box's corners so we can snap to them
 246                         if (p_is_a_bbox || !(_snapmanager->snapprefs.getStrictSnapping() && !p_is_a_bbox) || p_is_a_guide) {
 247                                 // Discard the bbox of a clipped path / mask, because we don't want to snap to both the bbox
 248                                 // of the item AND the bbox of the clipping path at the same time
 249                                 if (!(*i).clip_or_mask) {
 250                                         Geom::OptRect b = sp_item_bbox_desktop(root_item, bbox_type);
 251                                         getBBoxPoints(b, _points_to_snap_to, _snapmanager->snapprefs.getSnapToBBoxNode(), _snapmanager->snapprefs.getSnapBBoxEdgeMidpoints(), _snapmanager->snapprefs.getSnapBBoxMidpoints());
 252                                 }
 253                         }
 254         }
 255     }
 256 }
 257
 258 void Inkscape::ObjectSnapper::_snapNodes(SnappedConstraints &sc,
 259                                          Inkscape::SnapPreferences::PointType const &t,
 260                                          Geom::Point const &p,
 261                                          bool const &first_point,
 262                                          std::vector<Geom::Point> *unselected_nodes) const
 263 {
 264     // Iterate through all nodes, find out which one is the closest to p, and snap to it!
 265
 266     _collectNodes(t, first_point);
 267
 268     if (unselected_nodes != NULL) {
 269         _points_to_snap_to->insert(_points_to_snap_to->end(), unselected_nodes->begin(), unselected_nodes->end());
 270     }
 271
 272     SnappedPoint s;
 273     bool success = false;
 274
 275     for (std::vector<Geom::Point>::const_iterator k = _points_to_snap_to->begin(); k != _points_to_snap_to->end(); k++) {
 276         Geom::Coord dist = Geom::L2(*k - p);
 277         if (dist < getSnapperTolerance() && dist < s.getSnapDistance()) {
 278             s = SnappedPoint(*k, SNAPTARGET_NODE, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), true);
 279             success = true;
 280         }
 281     }
 282
 283     if (success) {
 284         sc.points.push_back(s);
 285     }
 286 }
 287
 288 void Inkscape::ObjectSnapper::_snapTranslatingGuideToNodes(SnappedConstraints &sc,
 289                                          Inkscape::SnapPreferences::PointType const &t,
 290                                          Geom::Point const &p,
 291                                          Geom::Point const &guide_normal) const
 292 {
 293     // Iterate through all nodes, find out which one is the closest to this guide, and snap to it!
 294     _collectNodes(t, true);
 295
 296     SnappedPoint s;
 297     bool success = false;
 298
 299     Geom::Coord tol = getSnapperTolerance();
 300
 301     for (std::vector<Geom::Point>::const_iterator k = _points_to_snap_to->begin(); k != _points_to_snap_to->end(); k++) {
 302         // Project each node (*k) on the guide line (running through point p)
 303         Geom::Point p_proj = project_on_linesegment(*k, p, p + Geom::rot90(guide_normal));
 304         Geom::Coord dist = Geom::L2(*k - p_proj); // distance from node to the guide
 305         Geom::Coord dist2 = Geom::L2(p - p_proj); // distance from projection of node on the guide, to the mouse location
 306         if ((dist < tol && dist2 < tol) || (getSnapperAlwaysSnap() && dist < s.getSnapDistance())) {
 307             s = SnappedPoint(*k, SNAPTARGET_NODE, dist, tol, getSnapperAlwaysSnap(), true);
 308             success = true;
 309         }
 310     }
 311
 312     if (success) {
 313         sc.points.push_back(s);
 314     }
 315 }
 316
 317
 318 /**
 319  * Returns index of first NR_END bpath in array.
 320  */
 321
 322 void Inkscape::ObjectSnapper::_collectPaths(Inkscape::SnapPreferences::PointType const &t,
 323                                          bool const &first_point) const
 324 {
 325     // Now, let's first collect all paths to snap to. If we have a whole bunch of points to snap,
 326     // e.g. when translating an item using the selector tool, then we will only do this for the
 327     // first point and store the collection for later use. This significantly improves the performance
 328     if (first_point) {
 329         _clear_paths();
 330
 331         // Determine the type of bounding box we should snap to
 332         SPItem::BBoxType bbox_type = SPItem::GEOMETRIC_BBOX;
 333
 334         bool p_is_a_node = t & Inkscape::SnapPreferences::SNAPPOINT_NODE;
 335
 336         if (_snapmanager->snapprefs.getSnapToBBoxPath()) {
 337             Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 338             int prefs_bbox = prefs->getBool("/tools/bounding_box", 0);
 339             bbox_type = !prefs_bbox ?
 340                 SPItem::APPROXIMATE_BBOX : SPItem::GEOMETRIC_BBOX;
 341         }
 342
 343         // Consider the page border for snapping
 344         if (_snapmanager->snapprefs.getSnapToPageBorder()) {
 345             Geom::PathVector *border_path = _getBorderPathv();
 346             if (border_path != NULL) {
 347                 _paths_to_snap_to->push_back(std::make_pair<Geom::PathVector*, SnapTargetType>(border_path, SNAPTARGET_PAGE_BORDER));
 348             }
 349         }
 350
 351         for (std::vector<SnapCandidate>::const_iterator i = _candidates->begin(); i != _candidates->end(); i++) {
 352
 353             /* Transform the requested snap point to this item's coordinates */
 354             Geom::Matrix i2doc(Geom::identity());
 355             SPItem *root_item = NULL;
 356             /* We might have a clone at hand, so make sure we get the root item */
 357             if (SP_IS_USE((*i).item)) {
 358                 i2doc = sp_use_get_root_transform(SP_USE((*i).item));
 359                 root_item = sp_use_root(SP_USE((*i).item));
 360                 g_return_if_fail(root_item);
 361             } else {
 362                 i2doc = sp_item_i2doc_affine((*i).item);
 363                 root_item = (*i).item;
 364             }
 365
 366             //Build a list of all paths considered for snapping to
 367
 368             //Add the item's path to snap to
 369             if (_snapmanager->snapprefs.getSnapToItemPath()) {
 370                 if (!(_snapmanager->snapprefs.getStrictSnapping() && !p_is_a_node)) {
 371                     // Snapping to the path of characters is very cool, but for a large
 372                     // chunk of text this will take ages! So limit snapping to text paths
 373                     // containing max. 240 characters. Snapping the bbox will not be affected
 374                     bool very_lenghty_prose = false;
 375                     if (SP_IS_TEXT(root_item) || SP_IS_FLOWTEXT(root_item)) {
 376                         very_lenghty_prose =  sp_text_get_length(SP_TEXT(root_item)) > 240;
 377                     }
 378                     // On my AMD 3000+, the snapping lag becomes annoying at approx. 240 chars
 379                     // which corresponds to a lag of 500 msec. This is for snapping a rect
 380                     // to a single line of text.
 381
 382                     // Snapping for example to a traced bitmap is also very stressing for
 383                     // the CPU, so we'll only snap to paths having no more than 500 nodes
 384                     // This also leads to a lag of approx. 500 msec (in my lousy test set-up).
 385                     bool very_complex_path = false;
 386                     if (SP_IS_PATH(root_item)) {
 387                         very_complex_path = sp_nodes_in_path(SP_PATH(root_item)) > 500;
 388                     }
 389
 390                     if (!very_lenghty_prose && !very_complex_path) {
 391                         SPCurve *curve = curve_for_item(root_item);
 392                         if (curve) {
 393                             // We will get our own copy of the path, which must be freed at some point
 394                             Geom::PathVector *borderpathv = pathvector_for_curve(root_item, curve, true, true, Geom::identity(), (*i).additional_affine);
 395                             _paths_to_snap_to->push_back(std::make_pair<Geom::PathVector*, SnapTargetType>(borderpathv, SNAPTARGET_PATH)); // Perhaps for speed, get a reference to the Geom::pathvector, and store the transformation besides it.
 396                             curve->unref();
 397                         }
 398                     }
 399                 }
 400             }
 401
 402             //Add the item's bounding box to snap to
 403             if (_snapmanager->snapprefs.getSnapToBBoxPath()) {
 404                 if (!(_snapmanager->snapprefs.getStrictSnapping() && p_is_a_node)) {
 405                     // Discard the bbox of a clipped path / mask, because we don't want to snap to both the bbox
 406                     // of the item AND the bbox of the clipping path at the same time
 407                     if (!(*i).clip_or_mask) {
 408                         Geom::OptRect rect;
 409                         sp_item_invoke_bbox(root_item, rect, i2doc, TRUE, bbox_type);
 410                         if (rect) {
 411                             Geom::PathVector *path = _getPathvFromRect(*rect);
 412                             _paths_to_snap_to->push_back(std::make_pair<Geom::PathVector*, SnapTargetType>(path, SNAPTARGET_BBOX_EDGE));
 413                         }
 414                     }
 415                 }
 416             }
 417         }
 418     }
 419 }
 420
 421 void Inkscape::ObjectSnapper::_snapPaths(SnappedConstraints &sc,
 422                                      Inkscape::SnapPreferences::PointType const &t,
 423                                      Geom::Point const &p,
 424                                      bool const &first_point,
 425                                      std::vector<Geom::Point> *unselected_nodes,
 426                                      SPPath const *selected_path) const
 427 {
 428     _collectPaths(t, first_point);
 429     // Now we can finally do the real snapping, using the paths collected above
 430
 431     g_assert(_snapmanager->getDesktop() != NULL);
 432     Geom::Point const p_doc = _snapmanager->getDesktop()->dt2doc(p);
 433
 434     bool const node_tool_active = _snapmanager->snapprefs.getSnapToItemPath() && selected_path != NULL;
 435
 436     if (first_point) {
 437         /* findCandidates() is used for snapping to both paths and nodes. It ignores the path that is
 438          * currently being edited, because that path requires special care: when snapping to nodes
 439          * only the unselected nodes of that path should be considered, and these will be passed on separately.
 440          * This path must not be ignored however when snapping to the paths, so we add it here
 441          * manually when applicable.
 442          *
 443          * Note that this path must be the last in line!
 444          * */
 445         if (node_tool_active) {
 446             SPCurve *curve = curve_for_item(SP_ITEM(selected_path));
 447             if (curve) {
 448                 Geom::PathVector *pathv = pathvector_for_curve(SP_ITEM(selected_path), curve, true, true, Geom::identity(), Geom::identity()); // We will get our own copy of the path, which must be freed at some point
 449                 _paths_to_snap_to->push_back(std::make_pair<Geom::PathVector*, SnapTargetType>(pathv, SNAPTARGET_PATH));
 450                 curve->unref();
 451             }
 452         }
 453     }
 454
 455     for (std::vector<std::pair<Geom::PathVector*, SnapTargetType> >::const_iterator it_p = _paths_to_snap_to->begin(); it_p != _paths_to_snap_to->end(); it_p++) {
 456         bool const being_edited = (node_tool_active && (*it_p) == _paths_to_snap_to->back());
 457         //if true then this pathvector it_pv is currently being edited in the node tool
 458
 459         // char * svgd = sp_svg_write_path(**it_p->first);
 460         // std::cout << "Dumping the pathvector: " << svgd << std::endl;
 461
 462         for(Geom::PathVector::iterator it_pv = (it_p->first)->begin(); it_pv != (it_p->first)->end(); ++it_pv) {
 463             // Find a nearest point for each curve within this path
 464             // n curves will return n time values with 0 <= t <= 1
 465             std::vector<double> anp = (*it_pv).nearestPointPerCurve(p_doc);
 466
 467             std::vector<double>::const_iterator np = anp.begin();
 468             unsigned int index = 0;
 469             for (; np != anp.end(); np++, index++) {
 470                 Geom::Curve const *curve = &((*it_pv).at_index(index));
 471                 Geom::Point const sp_doc = curve->pointAt(*np);
 472
 473                 bool c1 = true;
 474                 bool c2 = true;
 475                 if (being_edited) {
 476                     /* If the path is being edited, then we should only snap though to stationary pieces of the path
 477                      * and not to the pieces that are being dragged around. This way we avoid
 478                      * self-snapping. For this we check whether the nodes at both ends of the current
 479                      * piece are unselected; if they are then this piece must be stationary
 480                      */
 481                     g_assert(unselected_nodes != NULL);
 482                     Geom::Point start_pt = _snapmanager->getDesktop()->doc2dt(curve->pointAt(0));
 483                     Geom::Point end_pt = _snapmanager->getDesktop()->doc2dt(curve->pointAt(1));
 484                     c1 = isUnselectedNode(start_pt, unselected_nodes);
 485                     c2 = isUnselectedNode(end_pt, unselected_nodes);
 486                     /* Unfortunately, this might yield false positives for coincident nodes. Inkscape might therefore mistakenly
 487                      * snap to path segments that are not stationary. There are at least two possible ways to overcome this:
 488                      * - Linking the individual nodes of the SPPath we have here, to the nodes of the NodePath::SubPath class as being
 489                      *   used in sp_nodepath_selected_nodes_move. This class has a member variable called "selected". For this the nodes
 490                      *   should be in the exact same order for both classes, so we can index them
 491                      * - Replacing the SPPath being used here by the the NodePath::SubPath class; but how?
 492                      */
 493                 }
 494
 495                 Geom::Point const sp_dt = _snapmanager->getDesktop()->doc2dt(sp_doc);
 496                 if (!being_edited || (c1 && c2)) {
 497                     Geom::Coord const dist = Geom::distance(sp_doc, p_doc);
 498                     if (dist < getSnapperTolerance()) {
 499                         sc.curves.push_back(Inkscape::SnappedCurve(sp_dt, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), false, curve, it_p->second));
 500                     }
 501                 }
 502             }
 503         } // End of: for (Geom::PathVector::iterator ....)
 504     }
 505 }
 506
 507 /* Returns true if point is coincident with one of the unselected nodes */
 508 bool Inkscape::ObjectSnapper::isUnselectedNode(Geom::Point const &point, std::vector<Geom::Point> const *unselected_nodes) const
 509 {
 510     if (unselected_nodes == NULL) {
 511         return false;
 512     }
 513
 514     if (unselected_nodes->size() == 0) {
 515         return false;
 516     }
 517
 518     for (std::vector<Geom::Point>::const_iterator i = unselected_nodes->begin(); i != unselected_nodes->end(); i++) {
 519         if (Geom::L2(point - *i) < 1e-4) {
 520             return true;
 521         }
 522     }
 523
 524     return false;
 525 }
 526
 527 void Inkscape::ObjectSnapper::_snapPathsConstrained(SnappedConstraints &sc,
 528                                      Inkscape::SnapPreferences::PointType const &t,
 529                                      Geom::Point const &p,
 530                                      bool const &first_point,
 531                                      ConstraintLine const &c) const
 532 {
 533
 534     _collectPaths(t, first_point);
 535
 536     // Now we can finally do the real snapping, using the paths collected above
 537
 538     g_assert(_snapmanager->getDesktop() != NULL);
 539     Geom::Point const p_doc = _snapmanager->getDesktop()->dt2doc(p);
 540
 541     Geom::Point direction_vector = c.getDirection();
 542     if (!is_zero(direction_vector)) {
 543         direction_vector = Geom::unit_vector(direction_vector);
 544     }
 545
 546     Geom::Point const p1_on_cl = c.hasPoint() ? c.getPoint() : p;
 547     Geom::Point const p2_on_cl = p1_on_cl + direction_vector;
 548
 549     // The intersection point of the constraint line with any path,
 550     // must lie within two points on the constraintline: p_min_on_cl and p_max_on_cl
 551     // The distance between those points is twice the snapping tolerance
 552     Geom::Point const p_proj_on_cl = project_on_linesegment(p, p1_on_cl, p2_on_cl);
 553     Geom::Point const p_min_on_cl = _snapmanager->getDesktop()->dt2doc(p_proj_on_cl - getSnapperTolerance() * direction_vector);
 554     Geom::Point const p_max_on_cl = _snapmanager->getDesktop()->dt2doc(p_proj_on_cl + getSnapperTolerance() * direction_vector);
 555
 556     Geom::Path cl;
 557     std::vector<Geom::Path> clv;
 558     cl.start(p_min_on_cl);
 559     cl.appendNew<Geom::LineSegment>(p_max_on_cl);
 560     clv.push_back(cl);
 561
 562     for (std::vector<std::pair<Geom::PathVector*, SnapTargetType> >::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); k++) {
 563         if (k->first) {
 564             Geom::CrossingSet cs = Geom::crossings(clv, *(k->first));
 565             if (cs.size() > 0) {
 566                 // We need only the first element of cs, because cl is only a single straight linesegment
 567                 // This first element contains a vector filled with crossings of cl with k->first
 568                 for (std::vector<Geom::Crossing>::const_iterator m = cs[0].begin(); m != cs[0].end(); m++) {
 569                     if ((*m).ta >= 0 && (*m).ta <= 1 ) {
 570                         // Reconstruct the point of intersection
 571                         Geom::Point p_inters = p_min_on_cl + ((*m).ta) * (p_max_on_cl - p_min_on_cl);
 572                         // When it's within snapping range, then return it
 573                         // (within snapping range == between p_min_on_cl and p_max_on_cl == 0 < ta < 1)
 574                         Geom::Coord dist = Geom::L2(_snapmanager->getDesktop()->dt2doc(p_proj_on_cl) - p_inters);
 575                         SnappedPoint s(_snapmanager->getDesktop()->doc2dt(p_inters), k->second, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), true);
 576                         sc.points.push_back(s);
 577                     }
 578                 }
 579             }
 580         }
 581     }
 582 }
 583
 584
 585 void Inkscape::ObjectSnapper::freeSnap(SnappedConstraints &sc,
 586                                             Inkscape::SnapPreferences::PointType const &t,
 587                                             Geom::Point const &p,
 588                                             bool const &first_point,
 589                                             Geom::OptRect const &bbox_to_snap,
 590                                             std::vector<SPItem const *> const *it,
 591                                             std::vector<Geom::Point> *unselected_nodes) const
 592 {
 593     if (_snap_enabled == false || _snapmanager->snapprefs.getSnapFrom(t) == false ) {
 594         return;
 595     }
 596
 597     /* Get a list of all the SPItems that we will try to snap to */
 598     if (first_point) {
 599         Geom::Rect const local_bbox_to_snap = bbox_to_snap ? *bbox_to_snap : Geom::Rect(p, p);
 600         _findCandidates(sp_document_root(_snapmanager->getDocument()), it, first_point, local_bbox_to_snap, TRANSL_SNAP_XY, false, Geom::identity());
 601     }
 602
 603     if (_snapmanager->snapprefs.getSnapToItemNode() || _snapmanager->snapprefs.getSnapSmoothNodes()
 604         || _snapmanager->snapprefs.getSnapToBBoxNode() || _snapmanager->snapprefs.getSnapToPageBorder()
 605                 || _snapmanager->snapprefs.getSnapLineMidpoints() || _snapmanager->snapprefs.getSnapObjectMidpoints()
 606                 || _snapmanager->snapprefs.getSnapBBoxEdgeMidpoints() || _snapmanager->snapprefs.getSnapBBoxMidpoints()
 607                 || _snapmanager->snapprefs.getIncludeItemCenter()) {
 608         _snapNodes(sc, t, p, first_point, unselected_nodes);
 609     }
 610
 611     if (_snapmanager->snapprefs.getSnapToItemPath() || _snapmanager->snapprefs.getSnapToBBoxPath() || _snapmanager->snapprefs.getSnapToPageBorder()) {
 612         unsigned n = (unselected_nodes == NULL) ? 0 : unselected_nodes->size();
 613         if (n > 0) {
 614             /* While editing a path in the node tool, findCandidates must ignore that path because
 615              * of the node snapping requirements (i.e. only unselected nodes must be snapable).
 616              * That path must not be ignored however when snapping to the paths, so we add it here
 617              * manually when applicable
 618              */
 619             SPPath *path = NULL;
 620             if (it != NULL) {
 621                 g_assert(SP_IS_PATH(*it->begin()));
 622                 g_assert(it->size() == 1);
 623                 path = SP_PATH(*it->begin());
 624             }
 625             _snapPaths(sc, t, p, first_point, unselected_nodes, path);
 626         } else {
 627             _snapPaths(sc, t, p, first_point, NULL, NULL);
 628         }
 629     }
 630 }
 631
 632 void Inkscape::ObjectSnapper::constrainedSnap( SnappedConstraints &sc,
 633                                                   Inkscape::SnapPreferences::PointType const &t,
 634                                                   Geom::Point const &p,
 635                                                   bool const &first_point,
 636                                                   Geom::OptRect const &bbox_to_snap,
 637                                                   ConstraintLine const &c,
 638                                                   std::vector<SPItem const *> const *it) const
 639 {
 640     if (_snap_enabled == false || _snapmanager->snapprefs.getSnapFrom(t) == false) {
 641         return;
 642     }
 643
 644     /* Get a list of all the SPItems that we will try to snap to */
 645     if (first_point) {
 646         Geom::Rect const local_bbox_to_snap = bbox_to_snap ? *bbox_to_snap : Geom::Rect(p, p);
 647         _findCandidates(sp_document_root(_snapmanager->getDocument()), it, first_point, local_bbox_to_snap, TRANSL_SNAP_XY, false, Geom::identity());
 648     }
 649
 650     // A constrained snap, is a snap in only one degree of freedom (specified by the constraint line).
 651     // This is usefull for example when scaling an object while maintaining a fixed aspect ratio. It's
 652     // nodes are only allowed to move in one direction (i.e. in one degree of freedom).
 653
 654     // When snapping to objects, we either snap to their nodes or their paths. It is however very
 655     // unlikely that any node will be exactly at the constrained line, so for a constrained snap
 656     // to objects we will only consider the object's paths. Beside, the nodes will be at these paths,
 657     // so we will more or less snap to them anyhow.
 658
 659     if (_snapmanager->snapprefs.getSnapToItemPath() || _snapmanager->snapprefs.getSnapToBBoxPath() || _snapmanager->snapprefs.getSnapToPageBorder()) {
 660         _snapPathsConstrained(sc, t, p, first_point, c);
 661     }
 662 }
 663
 664
 665 // This method is used to snap a guide to nodes, while dragging the guide around
 666 void Inkscape::ObjectSnapper::guideSnap(SnappedConstraints &sc,
 667                                         Geom::Point const &p,
 668                                         Geom::Point const &guide_normal) const
 669 {
 670     /* Get a list of all the SPItems that we will try to snap to */
 671     std::vector<SPItem*> cand;
 672     std::vector<SPItem const *> const it; //just an empty list
 673
 674     DimensionToSnap snap_dim;
 675     if (guide_normal == to_2geom(component_vectors[Geom::Y])) {
 676         snap_dim = GUIDE_TRANSL_SNAP_Y;
 677     } else if (guide_normal == to_2geom(component_vectors[Geom::X])) {
 678         snap_dim = GUIDE_TRANSL_SNAP_X;
 679     } else {
 680         snap_dim = ANGLED_GUIDE_TRANSL_SNAP;
 681     }
 682
 683     // We don't support ANGLED_GUIDE_ROT_SNAP yet.
 684
 685     // It would be cool to allow the user to rotate a guide by dragging it, instead of
 686     // only translating it. (For example when CTRL is pressed). We will need an UI part
 687     // for that first; and some important usability choices need to be made:
 688     // E.g. which point should be used for pivoting? A previously snapped point,
 689     // or a transformation center (which can be moved after clicking for the
 690     // second time on an object; but should this point then be constrained to the
 691     // line, or can it be located anywhere?)
 692
 693     _findCandidates(sp_document_root(_snapmanager->getDocument()), &it, true, Geom::Rect(p, p), snap_dim, false, Geom::identity());
 694     _snapTranslatingGuideToNodes(sc, Inkscape::SnapPreferences::SNAPPOINT_GUIDE, p, guide_normal);
 695     // _snapRotatingGuideToNodes has not been implemented yet.
 696 }
 697
 698 /**
 699  *  \return true if this Snapper will snap at least one kind of point.
 700  */
 701 bool Inkscape::ObjectSnapper::ThisSnapperMightSnap() const
 702 {
 703     bool snap_to_something = _snapmanager->snapprefs.getSnapToItemPath()
 704                                                 || _snapmanager->snapprefs.getSnapToItemNode()
 705                                                 || _snapmanager->snapprefs.getSnapToBBoxPath()
 706                                                 || _snapmanager->snapprefs.getSnapToBBoxNode()
 707                                                 || _snapmanager->snapprefs.getSnapToPageBorder()
 708                                                 || _snapmanager->snapprefs.getSnapLineMidpoints() || _snapmanager->snapprefs.getSnapObjectMidpoints()
 709                                                 || _snapmanager->snapprefs.getSnapBBoxEdgeMidpoints() || _snapmanager->snapprefs.getSnapBBoxMidpoints()
 710                                                 || _snapmanager->snapprefs.getIncludeItemCenter();
 711
 712     return (_snap_enabled && _snapmanager->snapprefs.getSnapModeBBoxOrNodes() && snap_to_something);
 713 }
 714
 715 bool Inkscape::ObjectSnapper::GuidesMightSnap() const
 716 {
 717     bool snap_to_something = _snapmanager->snapprefs.getSnapToItemNode() || _snapmanager->snapprefs.getSnapToBBoxNode();
 718     return (_snap_enabled && _snapmanager->snapprefs.getSnapModeGuide() && snap_to_something);
 719 }
 720
 721 void Inkscape::ObjectSnapper::_clear_paths() const
 722 {
 723     for (std::vector<std::pair<Geom::PathVector*, SnapTargetType> >::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); k++) {
 724         g_free(k->first);
 725     }
 726     _paths_to_snap_to->clear();
 727 }
 728
 729 Geom::PathVector* Inkscape::ObjectSnapper::_getBorderPathv() const
 730 {
 731     Geom::Rect const border_rect = Geom::Rect(Geom::Point(0,0), Geom::Point(sp_document_width(_snapmanager->getDocument()),sp_document_height(_snapmanager->getDocument())));
 732     return _getPathvFromRect(border_rect);
 733 }
 734
 735 Geom::PathVector* Inkscape::ObjectSnapper::_getPathvFromRect(Geom::Rect const rect) const
 736 {
 737     SPCurve const *border_curve = SPCurve::new_from_rect(rect);
 738     if (border_curve) {
 739         Geom::PathVector *dummy = new Geom::PathVector(border_curve->get_pathvector());
 740         return dummy;
 741     } else {
 742         return NULL;
 743     }
 744 }
 745
 746 void Inkscape::ObjectSnapper::_getBorderNodes(std::vector<Geom::Point> *points) const
 747 {
 748     Geom::Coord w = sp_document_width(_snapmanager->getDocument());
 749     Geom::Coord h = sp_document_height(_snapmanager->getDocument());
 750     points->push_back(Geom::Point(0,0));
 751     points->push_back(Geom::Point(0,h));
 752     points->push_back(Geom::Point(w,h));
 753     points->push_back(Geom::Point(w,0));
 754 }
 755
 756 void Inkscape::getBBoxPoints(Geom::OptRect const bbox, std::vector<Geom::Point> *points, bool const includeCorners, bool const includeLineMidpoints, bool const includeObjectMidpoints)
 757 {
 758         if (bbox) {
 759                 // collect the corners of the bounding box
 760                 for ( unsigned k = 0 ; k < 4 ; k++ ) {
 761                         if (includeCorners) {
 762                                 points->push_back(bbox->corner(k));
 763                         }
 764                         // optionally, collect the midpoints of the bounding box's edges too
 765                         if (includeLineMidpoints) {
 766                                 points->push_back((bbox->corner(k) + bbox->corner((k+1) % 4))/2);
 767                         }
 768                 }
 769                 if (includeObjectMidpoints) {
 770                         points->push_back(bbox->midpoint());
 771                 }
 772         }
 773 }
 774
 775 /*
 776   Local Variables:
 777   mode:c++
 778   c-file-style:"stroustrup"
 779   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 780   indent-tabs-mode:nil
 781   fill-column:99
 782   End:
 783 */
 784 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :