From: dvlierop2 Date: Sat, 3 Nov 2007 18:11:46 +0000 (+0000) Subject: Oops, don't use tabs! (replace tabs by 4 spaces) X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=ce5ed3e99d287e1df46a818cd31753d8cbb301f0;p=inkscape.git Oops, don't use tabs! (replace tabs by 4 spaces) --- diff --git a/src/display/canvas-arena.h b/src/display/canvas-arena.h index 805bee60a..f39ff1274 100644 --- a/src/display/canvas-arena.h +++ b/src/display/canvas-arena.h @@ -26,26 +26,26 @@ struct SPCanvasArenaClass; #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); diff --git a/src/display/canvas-axonomgrid.cpp b/src/display/canvas-axonomgrid.cpp index 66c9cc1fa..32e08828f 100644 --- a/src/display/canvas-axonomgrid.cpp +++ b/src/display/canvas-axonomgrid.cpp @@ -652,8 +652,8 @@ CanvasAxonomGridSnapper::_getSnapLines(NR::Point const &p) const 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); } diff --git a/src/display/canvas-bpath.h b/src/display/canvas-bpath.h index 072fe1087..b9f867845 100644 --- a/src/display/canvas-bpath.h +++ b/src/display/canvas-bpath.h @@ -34,17 +34,17 @@ class Shape; /* 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; @@ -52,37 +52,37 @@ typedef enum { /* 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); diff --git a/src/display/canvas-grid.cpp b/src/display/canvas-grid.cpp index d3cbf9153..5f68f58bd 100644 --- a/src/display/canvas-grid.cpp +++ b/src/display/canvas-grid.cpp @@ -852,8 +852,8 @@ CanvasXYGridSnapper::_getSnapLines(NR::Point const &p) const 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 51b5e7680..984d64662 100644 --- a/src/guide-snapper.cpp +++ b/src/guide-snapper.cpp @@ -54,8 +54,8 @@ bool Inkscape::GuideSnapper::ThisSnapperMightSnap() const 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 3b91fb015..f8efbed49 100644 --- 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 &points_to_snap, + Inkscape::Snapper::PointType const &t, + NR::Point const &p, + bool const &f, + std::vector &points_to_snap, std::list const &it) const { /* Snap along x (i.e. to vertical lines) */ @@ -24,11 +24,11 @@ void Inkscape::LineSnapper::_doFreeSnap(SnappedConstraints &sc, } 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 &points_to_snap, - ConstraintLine const &c, + std::vector &points_to_snap, + ConstraintLine const &c, std::list const &it) const { @@ -50,7 +50,7 @@ void Inkscape::LineSnapper::_doConstrainedSnap(SnappedConstraints &sc, /* 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 a15e6ae2d..8c307da53 100644 --- a/src/line-snapper.h +++ b/src/line-snapper.h @@ -26,19 +26,19 @@ protected: 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 &points_to_snap, std::list 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 &points_to_snap, ConstraintLine const &c, - std::list const &it) const; + std::list 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 10f75e5c4..7739238b4 100644 --- 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; - _points_to_snap_to = new std::vector; - _paths_to_snap_to = new std::vector; + _candidates = new std::vector; + _points_to_snap_to = new std::vector; + _paths_to_snap_to = new std::vector; } 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::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::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 @@ -70,8 +70,8 @@ void Inkscape::ObjectSnapper::_findCandidates(SPObject* r, 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))) { @@ -82,7 +82,7 @@ void Inkscape::ObjectSnapper::_findCandidates(SPObject* r, 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); @@ -91,19 +91,19 @@ void Inkscape::ObjectSnapper::_findCandidates(SPObject* r, // snapping range of this object NR::Maybe b = sp_item_bbox_desktop(SP_ITEM(o)); if (b) { - for (std::vector::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::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; + } + } } } } @@ -114,7 +114,7 @@ void Inkscape::ObjectSnapper::_findCandidates(SPObject* r, 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::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 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::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 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::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()) { @@ -200,7 +200,7 @@ bool Inkscape::ObjectSnapper::_snapNodes(Inkscape::Snapper::PointType const &t, 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::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::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 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::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::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 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::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 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 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 &points_to_snap, - std::list const &it) const + Inkscape::Snapper::PointType const &t, + NR::Point const &p, + bool const &first_point, + std::vector &points_to_snap, + std::list 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); @@ -353,19 +353,19 @@ void Inkscape::ObjectSnapper::_doFreeSnap(SnappedConstraints &sc, } 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 &points_to_snap, - ConstraintLine const &c, - std::list const &it) const + Inkscape::Snapper::PointType const &t, + NR::Point const &p, + bool const &first_point, + std::vector &points_to_snap, + ConstraintLine const &c, + std::list const &it) const { /* FIXME: this needs implementing properly; I think we have to do the ** intersection of c with the objects. @@ -376,7 +376,7 @@ void Inkscape::ObjectSnapper::_doConstrainedSnap(SnappedConstraints &sc, 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 5b2e6f37d..d1a2c94ce 100644 --- a/src/object-snapper.h +++ b/src/object-snapper.h @@ -74,11 +74,11 @@ public: } 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; @@ -88,36 +88,36 @@ private: std::vector *_points_to_snap_to; std::vector *_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 &points_to_snap, - std::list const &it) const; + std::list const &it) const; void _doConstrainedSnap(SnappedConstraints &sc, - Inkscape::Snapper::PointType const &t, - NR::Point const &p, - bool const &first_point, - std::vector &points_to_snap, - ConstraintLine const &c, - std::list const &it) const; - + Inkscape::Snapper::PointType const &t, + NR::Point const &p, + bool const &first_point, + std::vector &points_to_snap, + ConstraintLine const &c, + std::list const &it) const; + void _findCandidates(SPObject* r, - std::list const &it, - bool const &first_point, - std::vector &points_to_snap, - DimensionToSnap const snap_dim) const; + std::list const &it, + bool const &first_point, + std::vector &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 486507ce6..1a05bdaac 100644 --- a/src/snap.cpp +++ b/src/snap.cpp @@ -46,7 +46,7 @@ SnapManager::SnapManager(SPNamedView const *v) : _named_view(v), _include_item_center(false) { - + } @@ -104,7 +104,7 @@ bool SnapManager::SomeSnapperMightSnap() const /* * 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(). * @@ -113,53 +113,53 @@ bool SnapManager::SomeSnapperMightSnap() const 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); } /** @@ -259,7 +259,7 @@ SnapManager::freeSnapAlways( Inkscape::Snapper::PointType t, gdouble const curr_gridsnap = (*i)->getDistance(); const_cast (*i)->setDistance(NR_HUGE); std::vector 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 (*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 &points_to_snap, + std::vector &points_to_snap, Inkscape::Snapper::ConstraintLine const &c, std::list 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); } @@ -428,9 +428,9 @@ std::pair SnapManager::_snapTransformed( */ double best_metric = NR_HUGE; - std::vector::const_iterator j = transformed_points.begin(); + std::vector::const_iterator j = transformed_points.begin(); - for (std::vector::const_iterator i = points.begin(); i != points.end(); i++) { + for (std::vector::const_iterator i = points.begin(); i != points.end(); i++) { /* Snap it */ Inkscape::SnappedPoint const snapped = constrained ? @@ -656,78 +656,78 @@ std::pair 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 > 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 >::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 > 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 >::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 29d22a1cd..b7a6151ad 100644 --- a/src/snap.h +++ b/src/snap.h @@ -77,8 +77,8 @@ public: Inkscape::Snapper::ConstraintLine const &c, std::list 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 freeSnapTranslation(Inkscape::Snapper::PointType t, std::vector const &p, @@ -132,16 +132,16 @@ public: 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; @@ -167,7 +167,7 @@ private: 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 0b8c9053f..92f16d905 100644 --- a/src/snapped-line.h +++ b/src/snapped-line.h @@ -25,14 +25,14 @@ namespace Inkscape 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; }; @@ -40,19 +40,19 @@ private: 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 9df76b704..ed82c47c0 100644 --- a/src/snapped-point.cpp +++ b/src/snapped-point.cpp @@ -18,9 +18,9 @@ Inkscape::SnappedPoint::SnappedPoint(NR::Point p, NR::Coord d, bool at_intersect 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; } @@ -42,16 +42,16 @@ NR::Point Inkscape::SnappedPoint::getPoint() const // search for the closest snapped point bool getClosestSP(std::list &list, Inkscape::SnappedPoint &result) { - bool success = false; - - for (std::list::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::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 147922b2f..4d8751f5f 100644 --- a/src/snapped-point.h +++ b/src/snapped-point.h @@ -18,7 +18,7 @@ namespace Inkscape { - + /// Class describing the result of an attempt to snap. class SnappedPoint { diff --git a/src/snapper.cpp b/src/snapper.cpp index 5edde2405..6eb4b5204 100644 --- a/src/snapper.cpp +++ b/src/snapper.cpp @@ -92,11 +92,11 @@ void Inkscape::Snapper::setEnabled(bool s) */ void Inkscape::Snapper::freeSnap(SnappedConstraints &sc, - - PointType const &t, + + PointType const &t, NR::Point const &p, bool const &first_point, - std::vector &points_to_snap, + std::vector &points_to_snap, SPItem const *it) const { std::list lit; @@ -117,11 +117,11 @@ void Inkscape::Snapper::freeSnap(SnappedConstraints &sc, */ void Inkscape::Snapper::freeSnap(SnappedConstraints &sc, - - PointType const &t, + + PointType const &t, NR::Point const &p, bool const &first_point, - std::vector &points_to_snap, + std::vector &points_to_snap, std::list const &it) const { if (_enabled == false || getSnapFrom(t) == false) { @@ -146,11 +146,11 @@ void Inkscape::Snapper::freeSnap(SnappedConstraints &sc, */ void Inkscape::Snapper::constrainedSnap(SnappedConstraints &sc, - - PointType const &t, + + PointType const &t, NR::Point const &p, bool const &first_point, - std::vector &points_to_snap, + std::vector &points_to_snap, ConstraintLine const &c, SPItem const *it) const { @@ -172,11 +172,11 @@ void Inkscape::Snapper::constrainedSnap(SnappedConstraints &sc, */ void Inkscape::Snapper::constrainedSnap(SnappedConstraints &sc, - - PointType const &t, + + PointType const &t, NR::Point const &p, bool const &first_point, - std::vector &points_to_snap, + std::vector &points_to_snap, ConstraintLine const &c, std::list const &it) const { diff --git a/src/snapper.h b/src/snapper.h index a122db72f..64150be18 100644 --- a/src/snapper.h +++ b/src/snapper.h @@ -20,10 +20,10 @@ #include "snapped-line.h" struct SnappedConstraints { - std::list points; - std::list lines; - std::list grid_lines; - std::list guide_lines; + std::list points; + std::list lines; + std::list grid_lines; + std::list guide_lines; }; struct SPNamedView; @@ -60,17 +60,17 @@ public: void setEnabled(bool s); void freeSnap(SnappedConstraints &sc, - PointType const &t, + PointType const &t, NR::Point const &p, bool const &first_point, - std::vector &points_to_snap, + std::vector &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 &points_to_snap, + std::vector &points_to_snap, std::list const &it) const; class ConstraintLine @@ -99,7 +99,7 @@ public: }; void constrainedSnap(SnappedConstraints &sc, - PointType const &t, + PointType const &t, NR::Point const &p, bool const &first_point, std::vector &points_to_snap, @@ -107,10 +107,10 @@ public: SPItem const *it) const; void constrainedSnap(SnappedConstraints &sc, - PointType const &t, + PointType const &t, NR::Point const &p, bool const &first_point, - std::vector &points_to_snap, + std::vector &points_to_snap, ConstraintLine const &c, std::list const &it) const; @@ -131,10 +131,10 @@ private: * \return Snapped point. */ virtual void _doFreeSnap(SnappedConstraints &sc, - PointType const &t, - NR::Point const &p, - bool const &first_point, - std::vector &points_to_snap, + PointType const &t, + NR::Point const &p, + bool const &first_point, + std::vector &points_to_snap, std::list const &it) const = 0; /** @@ -148,10 +148,10 @@ private: * \return Snapped point. */ virtual void _doConstrainedSnap(SnappedConstraints &sc, - PointType const &t, - NR::Point const &p, - bool const &first_point, - std::vector &points_to_snap, + PointType const &t, + NR::Point const &p, + bool const &first_point, + std::vector &points_to_snap, ConstraintLine const &c, std::list const &it) const = 0;