snap.cpp revision c3f8f7b6159bd60ff55de3a86cb3016e2b3dca9f
#define __SP_DESKTOP_SNAP_C__
/**
* \file snap.cpp
* \brief SnapManager class.
*
* Authors:
* Lauris Kaplinski <lauris@kaplinski.com>
* Frank Felfe <innerspace@iname.com>
* Nathan Hurst <njh@njhurst.com>
* Carl Hetherington <inkscape@carlh.net>
*
* Copyright (C) 2006-2007 Johan Engelen <johan@shouraizou.nl>
* Copyrigth (C) 2004 Nathan Hurst
* Copyright (C) 1999-2002 Authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
#include <utility>
#include "sp-namedview.h"
#include "snap.h"
#include "snapped-line.h"
#include <libnr/nr-point-fns.h>
#include <libnr/nr-scale-ops.h>
#include <libnr/nr-values.h>
#include "display/canvas-grid.h"
#include "inkscape.h"
#include "desktop.h"
#include "sp-guide.h"
/**
* Construct a SnapManager for a SPNamedView.
*
* \param v `Owning' SPNamedView.
*/
guide(v, 0),
object(v, 0),
_named_view(v),
_include_item_center(false)
{
}
/**
* \return List of snappers that we use.
*/
SnapManager::getSnappers() const
{
return s;
}
/**
* \return List of gridsnappers that we use.
*/
SnapManager::getGridSnappers() const
{
SnapperList s;
//FIXME: this code should actually do this: add new grid snappers that are active for this desktop. now it just adds all gridsnappers
}
}
return s;
}
/**
* \return true if one of the snappers will try to snap something.
*/
bool SnapManager::SomeSnapperMightSnap() const
{
SnapperList const s = getSnappers();
while (i != s.end() && (*i)->ThisSnapperMightSnap() == false) {
i++;
}
return (i != s.end());
}
/*
* The snappers have too many parameters to adjust individually. Therefore only
* two snapping modes are presented to the user: snapping bounding box corners (to
* paths, grids or guides). To select either of these modes (or both), use the
* methods defined below: setSnapModeBBox() and setSnapModeNode().
*
* */
{
//The default values are being set in sp_namedview_set() (in sp-namedview.cpp)
}
//object.setSnapToBBoxNode(enabled); // On second thought, these should be controlled
//object.setSnapToBBoxPath(enabled); // separately by the snapping prefs dialog
}
bool SnapManager::getSnapModeBBox() const
{
}
{
}
//object.setSnapToItemNode(enabled); // On second thought, these should be controlled
//object.setSnapToItemPath(enabled); // separately by the snapping prefs dialog
object.setStrictSnapping(true);
}
bool SnapManager::getSnapModeNode() const
{
}
{
}
bool SnapManager::getSnapModeGuide() const
{
}
/**
* Try to snap a point to any interested snappers.
*
* \param t Type of point.
* \param p Point.
* \param it Item to ignore when snapping.
* \return Snapped point.
*/
{
}
/**
* Try to snap a point to any of the specified snappers.
*
* \param t Type of point.
* \param p Point.
* \param first_point If true then this point is the first one from a whole bunch of points
* \param points_to_snap The whole bunch of points, all from the same selection and having the same transformation
* \param it List of items to ignore when snapping.
* \param snappers List of snappers to try to snap to
* \return Snapped point.
*/
bool const &first_point,
{
}
return findBestSnap(p, sc);
}
/**
* Try to snap a point to any of the specified snappers. Snap always, ignoring the snap-distance
*
* \param t Type of point.
* \param p Point.
* \param it Item to ignore when snapping.
* \param snappers List of snappers to try to snap to
* \return Snapped point.
*/
{
}
/**
* Try to snap a point to any of the specified snappers. Snap always, ignoring the snap-distance
*
* \param t Type of point.
* \param p Point.
* \param it List of items to ignore when snapping.
* \param snappers List of snappers to try to snap to
* \return Snapped point.
*/
{
}
return findBestSnap(p, sc);
}
/**
* Try to snap a point to any interested snappers. A snap will only occur along
* a line described by a Inkscape::Snapper::ConstraintLine.
*
* \param t Type of point.
* \param p Point.
* \param c Constraint line.
* \param it Item to ignore when snapping.
* \return Snapped point.
*/
{
}
/**
* Try to snap a point to any interested snappers. A snap will only occur along
* a line described by a Inkscape::Snapper::ConstraintLine.
*
* \param t Type of point.
* \param p Point.
* \param first_point If true then this point is the first one from a whole bunch of points
* \param points_to_snap The whole bunch of points, all from the same selection and having the same transformation
* \param c Constraint line.
* \param it List of items to ignore when snapping.
* \return Snapped point.
*/
bool const &first_point,
{
}
return findBestSnap(p, sc);
}
{
} else {
g_warning("WARNING: snapping of angled guides is not supported yet!");
}
}
/**
* Main internal snapping method, which is called by the other, friendlier, public
* methods. It's a bit hairy as it has lots of parameters, but it saves on a lot
* of duplicated code.
*
* \param type Type of points being snapped.
* \param points List of points to snap.
* \param ignore List of items to ignore while snapping.
* \param constrained true if the snap is constrained.
* \param constraint Constraint line to use, if `constrained' is true, otherwise undefined.
* \param transformation_type Type of transformation to apply to points before trying to snap them.
* \param transformation Description of the transformation; details depend on the type.
* \param origin Origin of the transformation, if applicable.
* \param dim Dimension of the transformation, if applicable.
* \param uniform true if the transformation should be uniform, if applicable.
*/
bool constrained,
bool uniform) const
{
/* We have a list of points, which we are proposing to transform in some way. We need to see
** if any of these points, when transformed, snap to anything. If they do, we return the
** appropriate transformation with `true'; otherwise we return the original scale with `false'.
*/
/* Quick check to see if we have any snappers that are enabled */
if (SomeSnapperMightSnap() == false) {
}
/* Work out the transformed version of this point */
switch (transformation_type) {
case TRANSLATION:
transformed = *i + transformation;
break;
case SCALE:
break;
case STRETCH:
{
if (uniform)
else {
}
break;
}
case SKEW:
transformed = *i;
break;
default:
}
// add the current transformed point to the box hulling all transformed points
}
/* The current best transformation */
/* The current best metric for the best transformation; lower is better, NR_HUGE
** means that we haven't snapped anything.
*/
double best_metric = NR_HUGE;
// std::cout << std::endl;
/* Snap it */
constrainedSnap(type, *j, i == points.begin(), transformed_points, constraint, ignore) : freeSnap(type, *j, i == points.begin(), transformed_points, ignore);
/* We snapped. Find the transformation that describes where the snapped point has
** ended up, and also the metric for this transformation.
*/
switch (transformation_type) {
case TRANSLATION:
/* Consider the case in which a box is almost aligned with a grid in both
* horizontal and vertical directions. The distance to the intersection of
* the grid lines will always be larger then the distance to a single grid
* line. If we prefer snapping to an intersection instead of to a single
* grid line, then we cannot use "metric = NR::L2(result)". Therefore the
* snapped distance will be used as a metric. Please note that the snapped
* distance is defined as the distance to the nearest line of the intersection,
* and not to the intersection itself!
*/
break;
case SCALE:
{
break;
}
case STRETCH:
{
for (int a = 0; a < 2; a++) {
} else {
result[a] = 1;
}
}
break;
}
case SKEW:
break;
default:
}
/* Note it if it's the best so far */
// std::cout << "SEL ";;
} //else { std::cout << " ";}
}
// std::cout << "P_orig = " << (*i) << " | metric = " << metric << " | distance = " << snapped.getDistance() << " | P_snap = " << snapped.getPoint() << std::endl;
j++;
}
// Using " < 1e6" instead of " < NR::HUGE" for catching some rounding errors
// These rounding errors might be caused by NRRects, see bug #1584301
}
/**
* Try to snap a list of points to any interested snappers after they have undergone
* a translation.
*
* \param t Type of points.
* \param p Points.
* \param it List of items to ignore when snapping.
* \param tr Proposed translation.
* \return Snapped translation, if a snap occurred, and a flag indicating whether a snap occurred.
*/
{
return _snapTransformed(
);
}
/**
* Try to snap a list of points to any interested snappers after they have undergone a
* translation. A snap will only occur along a line described by a
* Inkscape::Snapper::ConstraintLine.
*
* \param t Type of points.
* \param p Points.
* \param it List of items to ignore when snapping.
* \param c Constraint line.
* \param tr Proposed translation.
* \return Snapped translation, if a snap occurred, and a flag indicating whether a snap occurred.
*/
{
return _snapTransformed(
);
}
/**
* Try to snap a list of points to any interested snappers after they have undergone
* a scale.
*
* \param t Type of points.
* \param p Points.
* \param it List of items to ignore when snapping.
* \param s Proposed scale.
* \param o Origin of proposed scale.
* \return Snapped scale, if a snap occurred, and a flag indicating whether a snap occurred.
*/
{
return _snapTransformed(
);
}
/**
* Try to snap a list of points to any interested snappers after they have undergone
* a scale. A snap will only occur along a line described by a
* Inkscape::Snapper::ConstraintLine.
*
* \param t Type of points.
* \param p Points.
* \param it List of items to ignore when snapping.
* \param s Proposed scale.
* \param o Origin of proposed scale.
* \return Snapped scale, if a snap occurred, and a flag indicating whether a snap occurred.
*/
{
return _snapTransformed(
);
}
/**
* Try to snap a list of points to any interested snappers after they have undergone
* a stretch.
*
* \param t Type of points.
* \param p Points.
* \param it List of items to ignore when snapping.
* \param s Proposed stretch.
* \param o Origin of proposed stretch.
* \param d Dimension in which to apply proposed stretch.
* \param u true if the stretch should be uniform (ie to be applied equally in both dimensions)
* \return Snapped stretch, if a snap occurred, and a flag indicating whether a snap occurred.
*/
bool u) const
{
);
}
/**
* Try to snap a list of points to any interested snappers after they have undergone
* a skew.
*
* \param t Type of points.
* \param p Points.
* \param it List of items to ignore when snapping.
* \param s Proposed skew.
* \param o Origin of proposed skew.
* \param d Dimension in which to apply proposed skew.
* \return Snapped skew, if a snap occurred, and a flag indicating whether a snap occurred.
*/
{
);
}
{
grid_sens = (*i)->getDistance();
}
// Store all snappoints, optionally together with their specific snapping range
// Most of these snapped points are already within the snapping range, because
// they have already been filtered by their respective snappers. In that case
// we can set the snapping range to NR_HUGE here. If however we're looking at
// intersections of e.g. a grid and guide line, then we'll have to determine
// once again whether we're within snapping range. In this case we will set
// the snapping range to e.g. min(guide_sens, grid_sens)
// search for the closest snapped point
}
// search for the closest snapped grid line
}
// search for the closest snapped guide line
}
// search for the closest snapped intersection of grid lines
}
// search for the closest snapped intersection of guide lines
}
// search for the closest snapped intersection of grid with guide lines
}
// now let's see which snapped point gets a thumbs up
for (std::list<std::pair<Inkscape::SnappedPoint, NR::Coord> >::const_iterator i = sp_list.begin(); i != sp_list.end(); i++) {
// first find out if this snapped point is within snapping range
// if it's the first point
// or, if it's closer
// or, if it's just as close but at an intersection
// then prefer this point over the previous one
}
}
}
return bestPoint;
}
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
indent-tabs-mode:nil
fill-column:99
End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :