![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 0fbedc1)
raw | patch | inline | side by side (parent: 0fbedc1)
| author | dvlierop2 <dvlierop2@users.sourceforge.net> | |
| Sat, 3 Nov 2007 18:11:46 +0000 (18:11 +0000) | ||
| committer | dvlierop2 <dvlierop2@users.sourceforge.net> | |
| Sat, 3 Nov 2007 18:11:46 +0000 (18:11 +0000) |
16 files changed:
index 805bee60a08836f8d94daeb67f95fb92b0b81513..f39ff12740fd0cd79f22ce5f36659b48dc791a37 100644 (file)
#include "nr-arena-item.h"
struct SPCanvasArena {
- SPCanvasItem item;
+ SPCanvasItem item;
- guint cursor : 1;
- guint sticky : 1;
- NR::Point c; // what is this?
+ guint cursor : 1;
+ guint sticky : 1;
+ NR::Point c; // what is this?
- NRArena *arena;
- NRArenaItem *root;
- NRGC gc;
+ NRArena *arena;
+ NRArenaItem *root;
+ NRGC gc;
- NRArenaItem *active;
- /* fixme: */
- NRArenaItem *picked;
- gdouble delta;
+ NRArenaItem *active;
+ /* fixme: */
+ NRArenaItem *picked;
+ gdouble delta;
};
struct SPCanvasArenaClass {
- SPCanvasItemClass parent_class;
+ SPCanvasItemClass parent_class;
- gint (* arena_event) (SPCanvasArena *carena, NRArenaItem *item, GdkEvent *event);
+ gint (* arena_event) (SPCanvasArena *carena, NRArenaItem *item, GdkEvent *event);
};
GtkType sp_canvas_arena_get_type (void);
index 66c9cc1fac3a8b4858cdb6eb89bb196fdc1d17cc..32e08828f80e5168c095d8d2087f186ffd54ad56 100644 (file)
void CanvasAxonomGridSnapper::_addSnappedLine(SnappedConstraints &sc, NR::Point const snapped_point, NR::Coord const snapped_distance, NR::Point const normal_to_line, NR::Point const point_on_line) const
{
- SnappedInfiniteLine dummy = SnappedInfiniteLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
- sc.grid_lines.push_back(dummy);
+ SnappedInfiniteLine dummy = SnappedInfiniteLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
+ sc.grid_lines.push_back(dummy);
}
index 072fe1087ec0ac52a2f267dd9125f90bc772fba3..b9f8678459d679dd7499eb79a233674271f8e657 100644 (file)
/* stroke-linejoin */
typedef enum {
- SP_STROKE_LINEJOIN_MITER,
- SP_STROKE_LINEJOIN_ROUND,
- SP_STROKE_LINEJOIN_BEVEL
+ SP_STROKE_LINEJOIN_MITER,
+ SP_STROKE_LINEJOIN_ROUND,
+ SP_STROKE_LINEJOIN_BEVEL
} SPStrokeJoinType;
/* stroke-linecap */
typedef enum {
- SP_STROKE_LINECAP_BUTT,
- SP_STROKE_LINECAP_ROUND,
- SP_STROKE_LINECAP_SQUARE
+ SP_STROKE_LINECAP_BUTT,
+ SP_STROKE_LINECAP_ROUND,
+ SP_STROKE_LINECAP_SQUARE
} SPStrokeCapType;
/* clip-rule */
typedef enum {
- SP_WIND_RULE_NONZERO,
- SP_WIND_RULE_INTERSECT,
- SP_WIND_RULE_EVENODD,
- SP_WIND_RULE_POSITIVE
+ SP_WIND_RULE_NONZERO,
+ SP_WIND_RULE_INTERSECT,
+ SP_WIND_RULE_EVENODD,
+ SP_WIND_RULE_POSITIVE
} SPWindRule;
struct SPCanvasBPath {
- SPCanvasItem item;
+ SPCanvasItem item;
- /* Line def */
- SPCurve *curve;
+ /* Line def */
+ SPCurve *curve;
- /* Fill attributes */
- guint32 fill_rgba;
- SPWindRule fill_rule;
+ /* Fill attributes */
+ guint32 fill_rgba;
+ SPWindRule fill_rule;
- /* Line attributes */
- guint32 stroke_rgba;
- gdouble stroke_width;
- SPStrokeJoinType stroke_linejoin;
- SPStrokeCapType stroke_linecap;
- gdouble stroke_miterlimit;
+ /* Line attributes */
+ guint32 stroke_rgba;
+ gdouble stroke_width;
+ SPStrokeJoinType stroke_linejoin;
+ SPStrokeCapType stroke_linecap;
+ gdouble stroke_miterlimit;
- /* State */
- Shape *fill_shp;
- Shape *stroke_shp;
+ /* State */
+ Shape *fill_shp;
+ Shape *stroke_shp;
};
struct SPCanvasBPathClass {
- SPCanvasItemClass parent_class;
+ SPCanvasItemClass parent_class;
};
GtkType sp_canvas_bpath_get_type (void);
index d3cbf9153cc15a3ab689614ff22cf433028d41d3..5f68f58bd5d965f8fa7f30036cc29c7bf58ce178 100644 (file)
void CanvasXYGridSnapper::_addSnappedLine(SnappedConstraints &sc, NR::Point const snapped_point, NR::Coord const snapped_distance, NR::Point const normal_to_line, NR::Point const point_on_line) const
{
- SnappedInfiniteLine dummy = SnappedInfiniteLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
- sc.grid_lines.push_back(dummy);
+ SnappedInfiniteLine dummy = SnappedInfiniteLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
+ sc.grid_lines.push_back(dummy);
}
diff --git a/src/guide-snapper.cpp b/src/guide-snapper.cpp
index 51b5e7680542d9c61471cbb9fc2dea60b4f48fd1..984d646621b845cf84c3b197b3bdbc9d966cf65d 100644 (file)
--- a/src/guide-snapper.cpp
+++ b/src/guide-snapper.cpp
void Inkscape::GuideSnapper::_addSnappedLine(SnappedConstraints &sc, NR::Point const snapped_point, NR::Coord const snapped_distance, NR::Point const normal_to_line, NR::Point const point_on_line) const
{
- SnappedInfiniteLine dummy = SnappedInfiniteLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
- sc.guide_lines.push_back(dummy);
+ SnappedInfiniteLine dummy = SnappedInfiniteLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
+ sc.guide_lines.push_back(dummy);
}
/*
diff --git a/src/line-snapper.cpp b/src/line-snapper.cpp
index 3b91fb015df57c6b73d12eaf511c98e40972f668..f8efbed4952b1729739c461052a20b5c675d31ea 100644 (file)
--- a/src/line-snapper.cpp
+++ b/src/line-snapper.cpp
@@ -10,10 +10,10 @@ Inkscape::LineSnapper::LineSnapper(SPNamedView const *nv, NR::Coord const d) : S
}
void Inkscape::LineSnapper::_doFreeSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
- bool const &f,
- std::vector<NR::Point> &points_to_snap,
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
+ bool const &f,
+ std::vector<NR::Point> &points_to_snap,
std::list<SPItem const *> const &it) const
{
/* Snap along x (i.e. to vertical lines) */
}
void Inkscape::LineSnapper::_doConstrainedSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
bool const &f,
- std::vector<NR::Point> &points_to_snap,
- ConstraintLine const &c,
+ std::vector<NR::Point> &points_to_snap,
+ ConstraintLine const &c,
std::list<SPItem const *> const &it) const
{
/* Try to intersect this line with the target line */
NR::Point t = NR::Point(NR_HUGE, NR_HUGE);
IntersectorKind const k = intersector_line_intersection(n, q, component_vectors[i->first], i->second, t);
-
+
if (k == INTERSECTS) {
const NR::Coord dist = L2(t - p);
//Store any line that's within snapping range
diff --git a/src/line-snapper.h b/src/line-snapper.h
index a15e6ae2dc5ab6adbda34b69da1d1309d0f31ffd..8c307da53be9fdd7ba77dc1387fdaa9967cf0963 100644 (file)
--- a/src/line-snapper.h
+++ b/src/line-snapper.h
private:
void _doFreeSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
- bool const &first_point,
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
std::vector<NR::Point> &points_to_snap,
std::list<SPItem const *> const &it) const;
void _doConstrainedSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
- bool const &first_point,
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
std::vector<NR::Point> &points_to_snap,
ConstraintLine const &c,
- std::list<SPItem const *> const &it) const;
+ std::list<SPItem const *> const &it) const;
/**
* \param p Point that we are trying to snap.
diff --git a/src/object-snapper.cpp b/src/object-snapper.cpp
index 10f75e5c49758a19cb885a368fb8dc8542a67b1a..7739238b428fed733f0ef81a815f79f2e8f1a888 100644 (file)
--- a/src/object-snapper.cpp
+++ b/src/object-snapper.cpp
@@ -31,29 +31,29 @@ Inkscape::ObjectSnapper::ObjectSnapper(SPNamedView const *nv, NR::Coord const d)
_snap_to_bboxnode(true), _snap_to_bboxpath(true), _strict_snapping(true),
_include_item_center(false)
{
- _candidates = new std::vector<SPItem*>;
- _points_to_snap_to = new std::vector<NR::Point>;
- _paths_to_snap_to = new std::vector<Path*>;
+ _candidates = new std::vector<SPItem*>;
+ _points_to_snap_to = new std::vector<NR::Point>;
+ _paths_to_snap_to = new std::vector<Path*>;
}
Inkscape::ObjectSnapper::~ObjectSnapper()
{
- _candidates->clear(); //Don't delete the candidates themselves, as these are not ours!
- delete _candidates;
-
- _points_to_snap_to->clear();
- delete _points_to_snap_to;
-
- for (std::vector<Path*>::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); k++) {
- delete *k;
+ _candidates->clear(); //Don't delete the candidates themselves, as these are not ours!
+ delete _candidates;
+
+ _points_to_snap_to->clear();
+ delete _points_to_snap_to;
+
+ for (std::vector<Path*>::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); k++) {
+ delete *k;
}
_paths_to_snap_to->clear();
- delete _paths_to_snap_to;
+ delete _paths_to_snap_to;
}
/**
- * Find all items within snapping range.
- * \param r Pointer to the current document
+ * Find all items within snapping range.
+ * \param r Pointer to the current document
* \param it List of items to ignore
* \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
SPDesktop const *desktop = SP_ACTIVE_DESKTOP;
if (first_point) {
- _candidates->clear();
- }
+ _candidates->clear();
+ }
for (SPObject* o = sp_object_first_child(r); o != NULL; o = SP_OBJECT_NEXT(o)) {
if (SP_IS_ITEM(o) && !SP_ITEM(o)->isLocked() && !desktop->itemIsHidden(SP_ITEM(o))) {
i++;
}
- if (i == it.end()) {
+ if (i == it.end()) {
/* See if the item is within range */
if (SP_IS_GROUP(o)) {
_findCandidates(o, it, false, points_to_snap, snap_dim);
// snapping range of this object
NR::Maybe<NR::Rect> b = sp_item_bbox_desktop(SP_ITEM(o));
if (b) {
- for (std::vector<NR::Point>::const_iterator i = points_to_snap.begin(); i != points_to_snap.end(); i++) {
- NR::Point b_min = b->min();
- NR::Point b_max = b->max();
- double d = getDistance();
- bool withinX = ((*i)[NR::X] >= b_min[NR::X] - d) && ((*i)[NR::X] <= b_max[NR::X] + d);
- bool withinY = ((*i)[NR::Y] >= b_min[NR::Y] - d) && ((*i)[NR::Y] <= b_max[NR::Y] + d);
- if (snap_dim == SNAP_X && withinX || snap_dim == SNAP_Y && withinY || snap_dim == SNAP_XY && withinX && withinY) {
- //We've found a point that is within snapping range
- //of this object, so record it as a candidate
- _candidates->push_back(SP_ITEM(o));
- break;
- }
- }
+ for (std::vector<NR::Point>::const_iterator i = points_to_snap.begin(); i != points_to_snap.end(); i++) {
+ NR::Point b_min = b->min();
+ NR::Point b_max = b->max();
+ double d = getDistance();
+ bool withinX = ((*i)[NR::X] >= b_min[NR::X] - d) && ((*i)[NR::X] <= b_max[NR::X] + d);
+ bool withinY = ((*i)[NR::Y] >= b_min[NR::Y] - d) && ((*i)[NR::Y] <= b_max[NR::Y] + d);
+ if (snap_dim == SNAP_X && withinX || snap_dim == SNAP_Y && withinY || snap_dim == SNAP_XY && withinX && withinY) {
+ //We've found a point that is within snapping range
+ //of this object, so record it as a candidate
+ _candidates->push_back(SP_ITEM(o));
+ break;
+ }
+ }
}
}
}
bool Inkscape::ObjectSnapper::_snapNodes(Inkscape::Snapper::PointType const &t,
- Inkscape::SnappedPoint &s,
+ Inkscape::SnappedPoint &s,
NR::Point const &p,
bool const &first_point,
DimensionToSnap const snap_dim) const
@@ -123,70 +123,70 @@ bool Inkscape::ObjectSnapper::_snapNodes(Inkscape::Snapper::PointType const &t,
// Determine the type of bounding box we should snap to
SPItem::BBoxType bbox_type = SPItem::GEOMETRIC_BBOX;
- if (_snap_to_bboxnode) {
- gchar const *prefs_bbox = prefs_get_string_attribute("tools.select", "bounding_box");
- bbox_type = (prefs_bbox != NULL && strcmp(prefs_bbox, "geometric")==0)? SPItem::GEOMETRIC_BBOX : SPItem::APPROXIMATE_BBOX;
- }
-
- bool p_is_a_node = t & Inkscape::Snapper::SNAPPOINT_NODE;
- bool p_is_a_bbox = t & Inkscape::Snapper::SNAPPOINT_BBOX;
- bool p_is_a_guide = t & Inkscape::Snapper::SNAPPOINT_GUIDE;
-
- // A point considered for snapping should be either a node, a bbox corner or a guide. Pick only ONE!
- 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));
+ if (_snap_to_bboxnode) {
+ gchar const *prefs_bbox = prefs_get_string_attribute("tools.select", "bounding_box");
+ bbox_type = (prefs_bbox != NULL && strcmp(prefs_bbox, "geometric")==0)? SPItem::GEOMETRIC_BBOX : SPItem::APPROXIMATE_BBOX;
+ }
+
+ bool p_is_a_node = t & Inkscape::Snapper::SNAPPOINT_NODE;
+ bool p_is_a_bbox = t & Inkscape::Snapper::SNAPPOINT_BBOX;
+ bool p_is_a_guide = t & Inkscape::Snapper::SNAPPOINT_GUIDE;
+
+ // A point considered for snapping should be either a node, a bbox corner or a guide. Pick only ONE!
+ 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));
// Now, let's first collect all points to snap to. If we have a whole bunch of points to snap,
// e.g. when translating an item using the selector tool, then we will only do this for the
// first point and store the collection for later use. This dramatically improves the performance
- if (first_point) {
- _points_to_snap_to->clear();
- for (std::vector<SPItem*>::const_iterator i = _candidates->begin(); i != _candidates->end(); i++) {
-
- //NR::Matrix i2doc(NR::identity());
- SPItem *root_item = *i;
- if (SP_IS_USE(*i)) {
- root_item = sp_use_root(SP_USE(*i));
- }
-
- //Collect all nodes so we can snap to them
- if (_snap_to_itemnode) {
- if (!(_strict_snapping && !p_is_a_node) || p_is_a_guide) {
- sp_item_snappoints(root_item, _include_item_center, SnapPointsIter(*_points_to_snap_to));
- }
- }
-
- //Collect the bounding box's corners so we can snap to them
- if (_snap_to_bboxnode) {
- if (!(_strict_snapping && !p_is_a_bbox) || p_is_a_guide) {
- NR::Maybe<NR::Rect> b = sp_item_bbox_desktop(root_item, bbox_type);
- if (b) {
- for ( unsigned k = 0 ; k < 4 ; k++ ) {
- _points_to_snap_to->push_back(b->corner(k));
- }
- }
- }
- }
- }
- }
+ if (first_point) {
+ _points_to_snap_to->clear();
+ for (std::vector<SPItem*>::const_iterator i = _candidates->begin(); i != _candidates->end(); i++) {
+
+ //NR::Matrix i2doc(NR::identity());
+ SPItem *root_item = *i;
+ if (SP_IS_USE(*i)) {
+ root_item = sp_use_root(SP_USE(*i));
+ }
+
+ //Collect all nodes so we can snap to them
+ if (_snap_to_itemnode) {
+ if (!(_strict_snapping && !p_is_a_node) || p_is_a_guide) {
+ sp_item_snappoints(root_item, _include_item_center, SnapPointsIter(*_points_to_snap_to));
+ }
+ }
+
+ //Collect the bounding box's corners so we can snap to them
+ if (_snap_to_bboxnode) {
+ if (!(_strict_snapping && !p_is_a_bbox) || p_is_a_guide) {
+ NR::Maybe<NR::Rect> b = sp_item_bbox_desktop(root_item, bbox_type);
+ if (b) {
+ for ( unsigned k = 0 ; k < 4 ; k++ ) {
+ _points_to_snap_to->push_back(b->corner(k));
+ }
+ }
+ }
+ }
+ }
+ }
//Do the snapping, using all the nodes and corners collected above
for (std::vector<NR::Point>::const_iterator k = _points_to_snap_to->begin(); k != _points_to_snap_to->end(); k++) {
- /* Try to snap to this node of the path */
+ /* Try to snap to this node of the path */
NR::Coord dist = NR_HUGE;
NR::Point snapped_point;
switch (snap_dim) {
- case SNAP_X:
- dist = fabs((*k)[NR::X] - p[NR::X]);
- snapped_point = NR::Point((*k)[NR::X], p[NR::Y]);
- break;
- case SNAP_Y:
- dist = fabs((*k)[NR::Y] - p[NR::Y]);
- snapped_point = NR::Point(p[NR::X], (*k)[NR::Y]);
- break;
- case SNAP_XY:
- dist = NR::L2(*k - p);
- snapped_point = *k;
- break;
+ case SNAP_X:
+ dist = fabs((*k)[NR::X] - p[NR::X]);
+ snapped_point = NR::Point((*k)[NR::X], p[NR::Y]);
+ break;
+ case SNAP_Y:
+ dist = fabs((*k)[NR::Y] - p[NR::Y]);
+ snapped_point = NR::Point(p[NR::X], (*k)[NR::Y]);
+ break;
+ case SNAP_XY:
+ dist = NR::L2(*k - p);
+ snapped_point = *k;
+ break;
}
if (dist < getDistance() && dist < s.getDistance()) {
bool Inkscape::ObjectSnapper::_snapPaths(Inkscape::Snapper::PointType const &t,
- Inkscape::SnappedPoint &s,
+ Inkscape::SnappedPoint &s,
NR::Point const &p,
bool const &first_point) const
{
@@ -214,110 +214,110 @@ bool Inkscape::ObjectSnapper::_snapPaths(Inkscape::Snapper::PointType const &t,
// Determine the type of bounding box we should snap to
SPItem::BBoxType bbox_type = SPItem::GEOMETRIC_BBOX;
- if (_snap_to_bboxpath) {
- gchar const *prefs_bbox = prefs_get_string_attribute("tools.select", "bounding_box");
- bbox_type = (prefs_bbox != NULL && strcmp(prefs_bbox, "geometric")==0)? SPItem::GEOMETRIC_BBOX : SPItem::APPROXIMATE_BBOX;
- }
-
- bool p_is_a_node = t & Inkscape::Snapper::SNAPPOINT_NODE;
-
+ if (_snap_to_bboxpath) {
+ gchar const *prefs_bbox = prefs_get_string_attribute("tools.select", "bounding_box");
+ bbox_type = (prefs_bbox != NULL && strcmp(prefs_bbox, "geometric")==0)? SPItem::GEOMETRIC_BBOX : SPItem::APPROXIMATE_BBOX;
+ }
+
+ bool p_is_a_node = t & Inkscape::Snapper::SNAPPOINT_NODE;
+
// Now, let's first collect all paths to snap to. If we have a whole bunch of points to snap,
// e.g. when translating an item using the selector tool, then we will only do this for the
// first point and store the collection for later use. This dramatically improves the performance
- if (first_point) {
- for (std::vector<Path*>::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); k++) {
- delete *k;
- }
- _paths_to_snap_to->clear();
- for (std::vector<SPItem*>::const_iterator i = _candidates->begin(); i != _candidates->end(); i++) {
-
- /* Transform the requested snap point to this item's coordinates */
- NR::Matrix i2doc(NR::identity());
- SPItem *root_item = NULL;
- /* We might have a clone at hand, so make sure we get the root item */
- if (SP_IS_USE(*i)) {
- i2doc = sp_use_get_root_transform(SP_USE(*i));
- root_item = sp_use_root(SP_USE(*i));
- } else {
- i2doc = sp_item_i2doc_affine(*i);
- root_item = *i;
- }
-
- //Build a list of all paths considered for snapping to
-
- //Add the item's path to snap to
- if (_snap_to_itempath) {
- if (!(_strict_snapping && !p_is_a_node)) {
- // Snapping to the path of characters is very cool, but for a large
- // chunk of text this will take ages! So limit snapping to text paths
- // containing max. 240 characters. Snapping the bbox will not be affected
- bool very_lenghty_prose = false;
- if (SP_IS_TEXT(root_item) || SP_IS_FLOWTEXT(root_item)) {
- very_lenghty_prose = sp_text_get_length(SP_TEXT(root_item)) > 240;
- }
- // On my AMD 3000+, the snapping lag becomes annoying at approx. 240 chars
- // which corresponds to a lag of 500 msec. This is for snapping a rect
- // to a single line of text.
-
- // Snapping for example to a traced bitmap is also very stressing for
- // the CPU, so we'll only snap to paths having no more than 500 nodes
- // This also leads to a lag of approx. 500 msec (in my lousy test set-up).
- bool very_complex_path = false;
- if (SP_IS_PATH(root_item)) {
- very_complex_path = sp_nodes_in_path(SP_PATH(root_item)) > 500;
- }
-
- if (!very_lenghty_prose && !very_complex_path) {
- _paths_to_snap_to->push_back(Path_for_item(root_item, true, true));
- }
- }
- }
-
- //Add the item's bounding box to snap to
- if (_snap_to_bboxpath) {
- if (!(_strict_snapping && p_is_a_node)) {
- //This will get ugly... rect -> curve -> bpath
- NRRect rect;
- sp_item_invoke_bbox(root_item, &rect, i2doc, TRUE, bbox_type);
- NR::Maybe<NR::Rect> bbox = rect.upgrade();
- SPCurve *curve = sp_curve_new_from_rect(bbox);
- if (curve) {
- NArtBpath *bpath = SP_CURVE_BPATH(curve);
- if (bpath) {
- Path *path = bpath_to_Path(bpath);
- if (path) {
- _paths_to_snap_to->push_back(path);
- }
- delete bpath;
- }
- delete curve;
- }
- }
- }
- }
+ if (first_point) {
+ for (std::vector<Path*>::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); k++) {
+ delete *k;
+ }
+ _paths_to_snap_to->clear();
+ for (std::vector<SPItem*>::const_iterator i = _candidates->begin(); i != _candidates->end(); i++) {
+
+ /* Transform the requested snap point to this item's coordinates */
+ NR::Matrix i2doc(NR::identity());
+ SPItem *root_item = NULL;
+ /* We might have a clone at hand, so make sure we get the root item */
+ if (SP_IS_USE(*i)) {
+ i2doc = sp_use_get_root_transform(SP_USE(*i));
+ root_item = sp_use_root(SP_USE(*i));
+ } else {
+ i2doc = sp_item_i2doc_affine(*i);
+ root_item = *i;
+ }
+
+ //Build a list of all paths considered for snapping to
+
+ //Add the item's path to snap to
+ if (_snap_to_itempath) {
+ if (!(_strict_snapping && !p_is_a_node)) {
+ // Snapping to the path of characters is very cool, but for a large
+ // chunk of text this will take ages! So limit snapping to text paths
+ // containing max. 240 characters. Snapping the bbox will not be affected
+ bool very_lenghty_prose = false;
+ if (SP_IS_TEXT(root_item) || SP_IS_FLOWTEXT(root_item)) {
+ very_lenghty_prose = sp_text_get_length(SP_TEXT(root_item)) > 240;
+ }
+ // On my AMD 3000+, the snapping lag becomes annoying at approx. 240 chars
+ // which corresponds to a lag of 500 msec. This is for snapping a rect
+ // to a single line of text.
+
+ // Snapping for example to a traced bitmap is also very stressing for
+ // the CPU, so we'll only snap to paths having no more than 500 nodes
+ // This also leads to a lag of approx. 500 msec (in my lousy test set-up).
+ bool very_complex_path = false;
+ if (SP_IS_PATH(root_item)) {
+ very_complex_path = sp_nodes_in_path(SP_PATH(root_item)) > 500;
+ }
+
+ if (!very_lenghty_prose && !very_complex_path) {
+ _paths_to_snap_to->push_back(Path_for_item(root_item, true, true));
+ }
+ }
+ }
+
+ //Add the item's bounding box to snap to
+ if (_snap_to_bboxpath) {
+ if (!(_strict_snapping && p_is_a_node)) {
+ //This will get ugly... rect -> curve -> bpath
+ NRRect rect;
+ sp_item_invoke_bbox(root_item, &rect, i2doc, TRUE, bbox_type);
+ NR::Maybe<NR::Rect> bbox = rect.upgrade();
+ SPCurve *curve = sp_curve_new_from_rect(bbox);
+ if (curve) {
+ NArtBpath *bpath = SP_CURVE_BPATH(curve);
+ if (bpath) {
+ Path *path = bpath_to_Path(bpath);
+ if (path) {
+ _paths_to_snap_to->push_back(path);
+ }
+ delete bpath;
+ }
+ delete curve;
+ }
+ }
+ }
+ }
}
//Now we can finally do the real snapping, using the paths collected above
for (std::vector<Path*>::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); k++) {
if (*k) {
if (first_point) {
- (*k)->ConvertWithBackData(0.01); //This is extremely time consuming!
+ (*k)->ConvertWithBackData(0.01); //This is extremely time consuming!
+ }
+
+ /* Look for the nearest position on this SPItem to our snap point */
+ NR::Maybe<Path::cut_position> const o = get_nearest_position_on_Path(*k, p_doc);
+ if (o && o->t >= 0 && o->t <= 1) {
+
+ /* Convert the nearest point back to desktop coordinates */
+ NR::Point const o_it = get_point_on_Path(*k, o->piece, o->t);
+ NR::Point const o_dt = desktop->doc2dt(o_it);
+
+ NR::Coord const dist = NR::L2(o_dt - p);
+ if (dist < getDistance() && dist < s.getDistance()) {
+ s = SnappedPoint(o_dt, dist);
+ success = true;
+ }
}
-
- /* Look for the nearest position on this SPItem to our snap point */
- NR::Maybe<Path::cut_position> const o = get_nearest_position_on_Path(*k, p_doc);
- if (o && o->t >= 0 && o->t <= 1) {
-
- /* Convert the nearest point back to desktop coordinates */
- NR::Point const o_it = get_point_on_Path(*k, o->piece, o->t);
- NR::Point const o_dt = desktop->doc2dt(o_it);
-
- NR::Coord const dist = NR::L2(o_dt - p);
- if (dist < getDistance() && dist < s.getDistance()) {
- s = SnappedPoint(o_dt, dist);
- success = true;
- }
- }
}
}
@@ -326,24 +326,24 @@ bool Inkscape::ObjectSnapper::_snapPaths(Inkscape::Snapper::PointType const &t,
void Inkscape::ObjectSnapper::_doFreeSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::list<SPItem const *> const &it) const
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
+ std::vector<NR::Point> &points_to_snap,
+ std::list<SPItem const *> const &it) const
{
if ( NULL == _named_view ) {
return;
}
/* Get a list of all the SPItems that we will try to snap to */
- if (first_point) {
- _findCandidates(sp_document_root(_named_view->document), it, first_point, points_to_snap, SNAP_XY);
- }
+ if (first_point) {
+ _findCandidates(sp_document_root(_named_view->document), it, first_point, points_to_snap, SNAP_XY);
+ }
- SnappedPoint s(p, NR_HUGE);
- bool snapped_to_node = false;
- bool snapped_to_path = false;
+ SnappedPoint s(p, NR_HUGE);
+ bool snapped_to_node = false;
+ bool snapped_to_path = false;
if (_snap_to_itemnode || _snap_to_bboxnode) {
snapped_to_node = _snapNodes(t, s, p, first_point, SNAP_XY);
}
if (snapped_to_node || snapped_to_path) {
- sc.points.push_back(s);
+ sc.points.push_back(s);
}
}
void Inkscape::ObjectSnapper::_doConstrainedSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- ConstraintLine const &c,
- std::list<SPItem const *> const &it) const
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
+ std::vector<NR::Point> &points_to_snap,
+ ConstraintLine const &c,
+ std::list<SPItem const *> const &it) const
{
/* FIXME: this needs implementing properly; I think we have to do the
** intersection of c with the objects.
Inkscape::SnappedPoint Inkscape::ObjectSnapper::guideSnap(NR::Point const &p,
- DimensionToSnap const snap_dim) const
+ DimensionToSnap const snap_dim) const
{
if ( NULL == _named_view ) {
return SnappedPoint(p, NR_HUGE);
diff --git a/src/object-snapper.h b/src/object-snapper.h
index 5b2e6f37d0616bb0aecd49613d368bbec2839a45..d1a2c94ce30277772600d96544c359697c02f29b 100644 (file)
--- a/src/object-snapper.h
+++ b/src/object-snapper.h
}
void setStrictSnapping(bool enabled) {
- _strict_snapping = enabled;
+ _strict_snapping = enabled;
}
SnappedPoint guideSnap(NR::Point const &p,
- DimensionToSnap const snap_dim) const;
+ DimensionToSnap const snap_dim) const;
bool ThisSnapperMightSnap() const;
std::vector<NR::Point> *_points_to_snap_to;
std::vector<Path*> *_paths_to_snap_to;
void _doFreeSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
- bool const &first_point,
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
std::vector<NR::Point> &points_to_snap,
- std::list<SPItem const *> const &it) const;
+ std::list<SPItem const *> const &it) const;
void _doConstrainedSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- ConstraintLine const &c,
- std::list<SPItem const *> const &it) const;
-
+ Inkscape::Snapper::PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
+ std::vector<NR::Point> &points_to_snap,
+ ConstraintLine const &c,
+ std::list<SPItem const *> const &it) const;
+
void _findCandidates(SPObject* r,
- std::list<SPItem const *> const &it,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- DimensionToSnap const snap_dim) const;
+ std::list<SPItem const *> const &it,
+ bool const &first_point,
+ std::vector<NR::Point> &points_to_snap,
+ DimensionToSnap const snap_dim) const;
bool _snapNodes(Inkscape::Snapper::PointType const &t,
- Inkscape::SnappedPoint &s,
- NR::Point const &p,
- bool const &first_point,
- DimensionToSnap const snap_dim) const;
-
+ Inkscape::SnappedPoint &s,
+ NR::Point const &p,
+ bool const &first_point,
+ DimensionToSnap const snap_dim) const;
+
bool _snapPaths(Inkscape::Snapper::PointType const &t,
- Inkscape::SnappedPoint &s,
- NR::Point const &p,
- bool const &first_point) const;
+ Inkscape::SnappedPoint &s,
+ NR::Point const &p,
+ bool const &first_point) const;
bool _snap_to_itemnode;
bool _snap_to_itempath;
diff --git a/src/snap.cpp b/src/snap.cpp
index 486507ce67fdd6aae8cc0dd312ee0e61c60166b3..1a05bdaacf6234079fb148059900136c80e08c0c 100644 (file)
--- a/src/snap.cpp
+++ b/src/snap.cpp
_named_view(v),
_include_item_center(false)
{
-
+
}
/*
* The snappers have too many parameters to adjust individually. Therefore only
* two snapping modes are presented to the user: snapping bounding box corners (to
- * other bounding boxes, grids or guides), and/or snapping nodes (to other nodes,
+ * other bounding boxes, grids or guides), and/or snapping nodes (to other nodes,
* paths, grids or guides). To select either of these modes (or both), use the
* methods defined below: setSnapModeBBox() and setSnapModeNode().
*
void SnapManager::setSnapModeBBox(bool enabled)
{
- //The default values are being set in sp_namedview_set() (in sp-namedview.cpp)
- guide.setSnapFrom(Inkscape::Snapper::SNAPPOINT_BBOX, enabled);
-
- for ( GSList const *l = _named_view->grids; l != NULL; l = l->next) {
+ //The default values are being set in sp_namedview_set() (in sp-namedview.cpp)
+ guide.setSnapFrom(Inkscape::Snapper::SNAPPOINT_BBOX, enabled);
+
+ for ( GSList const *l = _named_view->grids; l != NULL; l = l->next) {
Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
grid->snapper->setSnapFrom(Inkscape::Snapper::SNAPPOINT_BBOX, enabled);
}
-
- object.setSnapFrom(Inkscape::Snapper::SNAPPOINT_BBOX, enabled);
- object.setSnapToBBoxNode(enabled);
- object.setSnapToBBoxPath(enabled);
- object.setStrictSnapping(true); //don't snap bboxes to nodes/paths and vice versa
+
+ object.setSnapFrom(Inkscape::Snapper::SNAPPOINT_BBOX, enabled);
+ object.setSnapToBBoxNode(enabled);
+ object.setSnapToBBoxPath(enabled);
+ object.setStrictSnapping(true); //don't snap bboxes to nodes/paths and vice versa
}
bool SnapManager::getSnapModeBBox() const
{
- return guide.getSnapFrom(Inkscape::Snapper::SNAPPOINT_BBOX);
+ return guide.getSnapFrom(Inkscape::Snapper::SNAPPOINT_BBOX);
}
void SnapManager::setSnapModeNode(bool enabled)
{
- guide.setSnapFrom(Inkscape::Snapper::SNAPPOINT_NODE, enabled);
-
- for ( GSList const *l = _named_view->grids; l != NULL; l = l->next) {
+ guide.setSnapFrom(Inkscape::Snapper::SNAPPOINT_NODE, enabled);
+
+ for ( GSList const *l = _named_view->grids; l != NULL; l = l->next) {
Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
grid->snapper->setSnapFrom(Inkscape::Snapper::SNAPPOINT_NODE, enabled);
}
-
- object.setSnapFrom(Inkscape::Snapper::SNAPPOINT_NODE, enabled);
- //object.setSnapToItemNode(enabled); // On second thought, these should be controlled
- //object.setSnapToItemPath(enabled); // separately by the snapping prefs dialog
- object.setStrictSnapping(true);
+
+ object.setSnapFrom(Inkscape::Snapper::SNAPPOINT_NODE, enabled);
+ //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
{
- return guide.getSnapFrom(Inkscape::Snapper::SNAPPOINT_NODE);
+ return guide.getSnapFrom(Inkscape::Snapper::SNAPPOINT_NODE);
}
void SnapManager::setSnapModeGuide(bool enabled)
{
- object.setSnapFrom(Inkscape::Snapper::SNAPPOINT_GUIDE, enabled);
+ object.setSnapFrom(Inkscape::Snapper::SNAPPOINT_GUIDE, enabled);
}
bool SnapManager::getSnapModeGuide() const
{
- return object.getSnapFrom(Inkscape::Snapper::SNAPPOINT_GUIDE);
+ return object.getSnapFrom(Inkscape::Snapper::SNAPPOINT_GUIDE);
}
/**
gdouble const curr_gridsnap = (*i)->getDistance();
const_cast<Inkscape::Snapper*> (*i)->setDistance(NR_HUGE);
std::vector<NR::Point> points_to_snap;
- points_to_snap.push_back(p);
+ points_to_snap.push_back(p);
(*i)->freeSnap(sc, t, p, true, points_to_snap, it);
const_cast<Inkscape::Snapper*> (*i)->setDistance(curr_gridsnap);
}
@@ -312,12 +312,12 @@ Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::Snapper::PointType
Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::Snapper::PointType t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
Inkscape::Snapper::ConstraintLine const &c,
std::list<SPItem const *> const &it) const
{
- SnappedConstraints sc;
+ SnappedConstraints sc;
SnapperList const snappers = getSnappers();
for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
@@ -328,19 +328,19 @@ Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::Snapper::PointType
}
Inkscape::SnappedPoint SnapManager::guideSnap(NR::Point const &p,
- NR::Point const &guide_normal) const
+ NR::Point const &guide_normal) const
{
- Inkscape::ObjectSnapper::DimensionToSnap snap_dim;
- if (guide_normal == component_vectors[NR::Y]) {
- snap_dim = Inkscape::ObjectSnapper::SNAP_Y;
- } else if (guide_normal == component_vectors[NR::X]) {
- snap_dim = Inkscape::ObjectSnapper::SNAP_X;
- } else {
- g_warning("WARNING: snapping of angled guides is not supported yet!");
- snap_dim = Inkscape::ObjectSnapper::SNAP_XY;
- }
-
- return object.guideSnap(p, snap_dim);
+ Inkscape::ObjectSnapper::DimensionToSnap snap_dim;
+ if (guide_normal == component_vectors[NR::Y]) {
+ snap_dim = Inkscape::ObjectSnapper::SNAP_Y;
+ } else if (guide_normal == component_vectors[NR::X]) {
+ snap_dim = Inkscape::ObjectSnapper::SNAP_X;
+ } else {
+ g_warning("WARNING: snapping of angled guides is not supported yet!");
+ snap_dim = Inkscape::ObjectSnapper::SNAP_XY;
+ }
+
+ return object.guideSnap(p, snap_dim);
}
*/
double best_metric = NR_HUGE;
- std::vector<NR::Point>::const_iterator j = transformed_points.begin();
+ std::vector<NR::Point>::const_iterator j = transformed_points.begin();
- for (std::vector<NR::Point>::const_iterator i = points.begin(); i != points.end(); i++) {
+ for (std::vector<NR::Point>::const_iterator i = points.begin(); i != points.end(); i++) {
/* Snap it */
Inkscape::SnappedPoint const snapped = constrained ?
@@ -656,78 +656,78 @@ std::pair<NR::Coord, bool> SnapManager::freeSnapSkew(Inkscape::Snapper::PointTyp
Inkscape::SnappedPoint SnapManager::findBestSnap(NR::Point const &p, SnappedConstraints &sc) const
{
- NR::Coord const guide_sens = guide.getDistance();
- NR::Coord grid_sens = 0;
-
- SnapManager::SnapperList const gs = getGridSnappers();
- SnapperList::const_iterator i = gs.begin();
- if (i != gs.end()) {
- grid_sens = (*i)->getDistance();
- }
-
- // Store all snappoints, optionally together with their specific snapping range
- std::list<std::pair<Inkscape::SnappedPoint, NR::Coord> > sp_list;
- // 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
- Inkscape::SnappedPoint closestPoint;
- if (getClosestSP(sc.points, closestPoint)) {
- sp_list.push_back(std::make_pair(closestPoint, NR_HUGE));
- }
-
- // search for the closest snapped grid line
- Inkscape::SnappedInfiniteLine closestGridLine;
- if (getClosestSIL(sc.grid_lines, closestGridLine)) {
- sp_list.push_back(std::make_pair(Inkscape::SnappedPoint(closestGridLine), NR_HUGE));
- }
-
- // search for the closest snapped guide line
- Inkscape::SnappedInfiniteLine closestGuideLine;
- if (getClosestSIL(sc.guide_lines, closestGuideLine)) {
- sp_list.push_back(std::make_pair(Inkscape::SnappedPoint(closestGuideLine), NR_HUGE));
- }
-
- // search for the closest snapped intersection of grid lines
- Inkscape::SnappedPoint closestGridPoint;
- if (getClosestIntersectionSIL(sc.grid_lines, closestGridPoint)) {
- sp_list.push_back(std::make_pair(closestGridPoint, NR_HUGE));
- }
-
- // search for the closest snapped intersection of guide lines
- Inkscape::SnappedPoint closestGuidePoint;
- if (getClosestIntersectionSIL(sc.guide_lines, closestGuidePoint)) {
- sp_list.push_back(std::make_pair(closestGuidePoint, NR_HUGE));
- }
-
- // search for the closest snapped intersection of grid with guide lines
- Inkscape::SnappedPoint closestGridGuidePoint;
- if (getClosestIntersectionSIL(sc.grid_lines, sc.guide_lines, closestGridGuidePoint)) {
- sp_list.push_back(std::make_pair(closestGridGuidePoint, std::min(guide_sens, grid_sens)));
- }
-
- // now let's see which snapped point gets a thumbs up
- Inkscape::SnappedPoint bestPoint(p, NR_HUGE);
- 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 ((*i).first.getDistance() <= (*i).second) {
- // if it's the first point
- bool c1 = (i == sp_list.begin());
- // or, if it's closer
- bool c2 = (*i).first.getDistance() < bestPoint.getDistance();
- // or, if it's just as close but at an intersection
- bool c3 = ((*i).first.getDistance() == bestPoint.getDistance()) && (*i).first.getAtIntersection();
- // then prefer this point over the previous one
- if (c1 || c2 || c3) {
- bestPoint = (*i).first;
- }
- }
- }
- return bestPoint;
+ NR::Coord const guide_sens = guide.getDistance();
+ NR::Coord grid_sens = 0;
+
+ SnapManager::SnapperList const gs = getGridSnappers();
+ SnapperList::const_iterator i = gs.begin();
+ if (i != gs.end()) {
+ grid_sens = (*i)->getDistance();
+ }
+
+ // Store all snappoints, optionally together with their specific snapping range
+ std::list<std::pair<Inkscape::SnappedPoint, NR::Coord> > sp_list;
+ // 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
+ Inkscape::SnappedPoint closestPoint;
+ if (getClosestSP(sc.points, closestPoint)) {
+ sp_list.push_back(std::make_pair(closestPoint, NR_HUGE));
+ }
+
+ // search for the closest snapped grid line
+ Inkscape::SnappedInfiniteLine closestGridLine;
+ if (getClosestSIL(sc.grid_lines, closestGridLine)) {
+ sp_list.push_back(std::make_pair(Inkscape::SnappedPoint(closestGridLine), NR_HUGE));
+ }
+
+ // search for the closest snapped guide line
+ Inkscape::SnappedInfiniteLine closestGuideLine;
+ if (getClosestSIL(sc.guide_lines, closestGuideLine)) {
+ sp_list.push_back(std::make_pair(Inkscape::SnappedPoint(closestGuideLine), NR_HUGE));
+ }
+
+ // search for the closest snapped intersection of grid lines
+ Inkscape::SnappedPoint closestGridPoint;
+ if (getClosestIntersectionSIL(sc.grid_lines, closestGridPoint)) {
+ sp_list.push_back(std::make_pair(closestGridPoint, NR_HUGE));
+ }
+
+ // search for the closest snapped intersection of guide lines
+ Inkscape::SnappedPoint closestGuidePoint;
+ if (getClosestIntersectionSIL(sc.guide_lines, closestGuidePoint)) {
+ sp_list.push_back(std::make_pair(closestGuidePoint, NR_HUGE));
+ }
+
+ // search for the closest snapped intersection of grid with guide lines
+ Inkscape::SnappedPoint closestGridGuidePoint;
+ if (getClosestIntersectionSIL(sc.grid_lines, sc.guide_lines, closestGridGuidePoint)) {
+ sp_list.push_back(std::make_pair(closestGridGuidePoint, std::min(guide_sens, grid_sens)));
+ }
+
+ // now let's see which snapped point gets a thumbs up
+ Inkscape::SnappedPoint bestPoint(p, NR_HUGE);
+ 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 ((*i).first.getDistance() <= (*i).second) {
+ // if it's the first point
+ bool c1 = (i == sp_list.begin());
+ // or, if it's closer
+ bool c2 = (*i).first.getDistance() < bestPoint.getDistance();
+ // or, if it's just as close but at an intersection
+ bool c3 = ((*i).first.getDistance() == bestPoint.getDistance()) && (*i).first.getAtIntersection();
+ // then prefer this point over the previous one
+ if (c1 || c2 || c3) {
+ bestPoint = (*i).first;
+ }
+ }
+ }
+ return bestPoint;
}
/*
Local Variables:
diff --git a/src/snap.h b/src/snap.h
index 29d22a1cd71dec5f3ae32883cf27f87fce3b5478..b7a6151ad96c8a0f5c0f8e54712c6c6c65726fb3 100644 (file)
--- a/src/snap.h
+++ b/src/snap.h
Inkscape::Snapper::ConstraintLine const &c,
std::list<SPItem const *> const &it) const;
- Inkscape::SnappedPoint guideSnap(NR::Point const &p,
- NR::Point const &guide_normal) const;
+ Inkscape::SnappedPoint guideSnap(NR::Point const &p,
+ NR::Point const &guide_normal) const;
std::pair<NR::Point, bool> freeSnapTranslation(Inkscape::Snapper::PointType t,
std::vector<NR::Point> const &p,
bool getSnapModeNode() const;
bool getSnapModeGuide() const;
- void setIncludeItemCenter(bool enabled) {
- _include_item_center = enabled;
- object.setIncludeItemCenter(enabled); //store a local copy in the object-snapper
- //instead of passing it through many functions
- }
-
- bool getIncludeItemCenter() const {
- return _include_item_center;
- }
-
+ void setIncludeItemCenter(bool enabled) {
+ _include_item_center = enabled;
+ object.setIncludeItemCenter(enabled); //store a local copy in the object-snapper
+ //instead of passing it through many functions
+ }
+
+ bool getIncludeItemCenter() const {
+ return _include_item_center;
+ }
+
protected:
SPNamedView const *_named_view;
NR::Dim2 dim,
bool uniform) const;
- Inkscape::SnappedPoint findBestSnap(NR::Point const &p, SnappedConstraints &sc) const;
+ Inkscape::SnappedPoint findBestSnap(NR::Point const &p, SnappedConstraints &sc) const;
};
#endif /* !SEEN_SNAP_H */
diff --git a/src/snapped-line.h b/src/snapped-line.h
index 0b8c9053f8548315ec1e21d05c5683cc113aed06..92f16d905041b299962cc32410bc16e41f142313 100644 (file)
--- a/src/snapped-line.h
+++ b/src/snapped-line.h
class SnappedLine : public SnappedPoint
{
public:
- SnappedLine();
+ SnappedLine();
SnappedLine(NR::Point snapped_point, NR::Coord snapped_distance, NR::Point start_point_of_line, NR::Point end_point_of_line);
~SnappedLine();
Inkscape::SnappedPoint intersect(SnappedLine const &line) const; //intersect with another SnappedLine
private:
- NR::Point _start_point_of_line;
- NR::Point _end_point_of_line;
+ NR::Point _start_point_of_line;
+ NR::Point _end_point_of_line;
};
class SnappedInfiniteLine : public SnappedPoint
{
public:
- SnappedInfiniteLine();
+ SnappedInfiniteLine();
SnappedInfiniteLine(NR::Point snapped_point, NR::Coord snapped_distance, NR::Point normal_to_line, NR::Point point_on_line);
~SnappedInfiniteLine();
Inkscape::SnappedPoint intersect(SnappedInfiniteLine const &line) const; //intersect with another SnappedInfiniteLine
// This line is described by this equation:
- // a*x + b*y = c <-> nx*px + ny+py = c <-> n.p = c
- NR::Point getNormal() const {return _normal_to_line;} // n = (nx, ny)
- NR::Point getPointOnLine() const {return _point_on_line;} // p = (px, py)
- NR::Coord getConstTerm() const {return dot(_normal_to_line, _point_on_line);} // c = n.p = nx*px + ny*py;
-
+ // a*x + b*y = c <-> nx*px + ny+py = c <-> n.p = c
+ NR::Point getNormal() const {return _normal_to_line;} // n = (nx, ny)
+ NR::Point getPointOnLine() const {return _point_on_line;} // p = (px, py)
+ NR::Coord getConstTerm() const {return dot(_normal_to_line, _point_on_line);} // c = n.p = nx*px + ny*py;
+
private:
- NR::Point _normal_to_line;
- NR::Point _point_on_line;
+ NR::Point _normal_to_line;
+ NR::Point _point_on_line;
};
}
diff --git a/src/snapped-point.cpp b/src/snapped-point.cpp
index 9df76b7047f362945101e5bed31ffa93a57f0c48..ed82c47c0e0570cc9f01d3038ac4efda621be108 100644 (file)
--- a/src/snapped-point.cpp
+++ b/src/snapped-point.cpp
Inkscape::SnappedPoint::SnappedPoint()
{
- _distance = NR_HUGE;
- _point = NR::Point(0,0);
- _at_intersection = false;
+ _distance = NR_HUGE;
+ _point = NR::Point(0,0);
+ _at_intersection = false;
}
// search for the closest snapped point
bool getClosestSP(std::list<Inkscape::SnappedPoint> &list, Inkscape::SnappedPoint &result)
{
- bool success = false;
-
- for (std::list<Inkscape::SnappedPoint>::const_iterator i = list.begin(); i != list.end(); i++) {
- if ((i == list.begin()) || (*i).getDistance() < result.getDistance()) {
- result = *i;
- success = true;
- }
- }
-
- return success;
+ bool success = false;
+
+ for (std::list<Inkscape::SnappedPoint>::const_iterator i = list.begin(); i != list.end(); i++) {
+ if ((i == list.begin()) || (*i).getDistance() < result.getDistance()) {
+ result = *i;
+ success = true;
+ }
+ }
+
+ return success;
}
/*
diff --git a/src/snapped-point.h b/src/snapped-point.h
index 147922b2f9933c43c32df86f1f28dd790115a87e..4d8751f5f18b7e13a8bc594945bf8a7dfba7e212 100644 (file)
--- a/src/snapped-point.h
+++ b/src/snapped-point.h
namespace Inkscape
{
-
+
/// Class describing the result of an attempt to snap.
class SnappedPoint
{
diff --git a/src/snapper.cpp b/src/snapper.cpp
index 5edde2405868b29fcfb04a5564a7ece96f6d5043..6eb4b5204e5b5f91f139445c22cfa152e3bc6191 100644 (file)
--- a/src/snapper.cpp
+++ b/src/snapper.cpp
*/
void Inkscape::Snapper::freeSnap(SnappedConstraints &sc,
-
- PointType const &t,
+
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
SPItem const *it) const
{
std::list<SPItem const *> lit;
*/
void Inkscape::Snapper::freeSnap(SnappedConstraints &sc,
-
- PointType const &t,
+
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
std::list<SPItem const *> const &it) const
{
if (_enabled == false || getSnapFrom(t) == false) {
*/
void Inkscape::Snapper::constrainedSnap(SnappedConstraints &sc,
-
- PointType const &t,
+
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
ConstraintLine const &c,
SPItem const *it) const
{
*/
void Inkscape::Snapper::constrainedSnap(SnappedConstraints &sc,
-
- PointType const &t,
+
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
ConstraintLine const &c,
std::list<SPItem const *> const &it) const
{
diff --git a/src/snapper.h b/src/snapper.h
index a122db72fa1efe428dfc90edf40eb14f7170c99d..64150be187de3f5cc34fd106d78ecf06d7d26c8c 100644 (file)
--- a/src/snapper.h
+++ b/src/snapper.h
#include "snapped-line.h"
struct SnappedConstraints {
- std::list<Inkscape::SnappedPoint> points;
- std::list<Inkscape::SnappedLine> lines;
- std::list<Inkscape::SnappedInfiniteLine> grid_lines;
- std::list<Inkscape::SnappedInfiniteLine> guide_lines;
+ std::list<Inkscape::SnappedPoint> points;
+ std::list<Inkscape::SnappedLine> lines;
+ std::list<Inkscape::SnappedInfiniteLine> grid_lines;
+ std::list<Inkscape::SnappedInfiniteLine> guide_lines;
};
struct SPNamedView;
void setEnabled(bool s);
void freeSnap(SnappedConstraints &sc,
- PointType const &t,
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
SPItem const *it) const;
void freeSnap(SnappedConstraints &sc,
- PointType const &t,
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
std::list<SPItem const *> const &it) const;
class ConstraintLine
};
void constrainedSnap(SnappedConstraints &sc,
- PointType const &t,
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
std::vector<NR::Point> &points_to_snap,
SPItem const *it) const;
void constrainedSnap(SnappedConstraints &sc,
- PointType const &t,
+ PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ std::vector<NR::Point> &points_to_snap,
ConstraintLine const &c,
std::list<SPItem const *> const &it) const;
* \return Snapped point.
*/
virtual void _doFreeSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
+ std::vector<NR::Point> &points_to_snap,
std::list<SPItem const *> const &it) const = 0;
/**
* \return Snapped point.
*/
virtual void _doConstrainedSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ PointType const &t,
+ NR::Point const &p,
+ bool const &first_point,
+ std::vector<NR::Point> &points_to_snap,
ConstraintLine const &c,
std::list<SPItem const *> const &it) const = 0;