![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 0035021)
raw | patch | inline | side by side (parent: 0035021)
| author | dvlierop2 <dvlierop2@users.sourceforge.net> | |
| Wed, 30 Apr 2008 07:32:12 +0000 (07:32 +0000) | ||
| committer | dvlierop2 <dvlierop2@users.sourceforge.net> | |
| Wed, 30 Apr 2008 07:32:12 +0000 (07:32 +0000) |
- Enabling snap indicator for all remaining tools
26 files changed:
diff --git a/src/arc-context.cpp b/src/arc-context.cpp
index 82c00fd05f05fe7ea2d028af895076ff6cefdfa0..07f5f4826ad306e559722819d7bd252eee732b83 100644 (file)
--- a/src/arc-context.cpp
+++ b/src/arc-context.cpp
dragging = true;
ac->center = Inkscape::setup_for_drag_start(desktop, event_context, event);
- SnapManager const &m = desktop->namedview->snap_manager;
- ac->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, ac->center, ac->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, ac->item);
+ ac->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, ac->center).getPoint();
sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
GDK_KEY_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
NR::Point const motion_w(event->motion.x, event->motion.y);
NR::Point motion_dt(desktop->w2d(motion_w));
- SnapManager const &m = desktop->namedview->snap_manager;
- motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt, ac->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, ac->item);
+ motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt).getPoint();
sp_arc_drag(ac, motion_dt, event->motion.state);
diff --git a/src/box3d-context.cpp b/src/box3d-context.cpp
index 7414fcd770e406977c1b858096008c7649023c35..ca6822dda66b4fa6e4050dfa3f1dc1b77123cf3c 100644 (file)
--- a/src/box3d-context.cpp
+++ b/src/box3d-context.cpp
@@ -330,9 +330,9 @@ static gint sp_box3d_context_root_handler(SPEventContext *event_context, GdkEven
bc->drag_ptC_proj[Proj::Z] = 0.25;
/* Snap center */
- SnapManager const &m = desktop->namedview->snap_manager;
- bc->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE,
- button_dt, bc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, bc->item);
+ bc->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, button_dt).getPoint();
sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
( GDK_KEY_PRESS_MASK |
@@ -361,8 +361,9 @@ static gint sp_box3d_context_root_handler(SPEventContext *event_context, GdkEven
event->motion.y);
NR::Point motion_dt(desktop->w2d(motion_w));
- SnapManager const &m = desktop->namedview->snap_manager;
- motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt, bc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, bc->item);
+ motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt).getPoint();
bc->ctrl_dragged = event->motion.state & GDK_CONTROL_MASK;
@@ -395,7 +396,7 @@ static gint sp_box3d_context_root_handler(SPEventContext *event_context, GdkEven
bc->drag_ptB_proj.normalize();
bc->drag_ptC_proj = cur_persp->tmat.preimage (motion_dt, bc->drag_ptB_proj[Proj::X], Proj::X);
}
- bc->drag_ptC = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, bc->drag_ptC, bc->item).getPoint();
+ bc->drag_ptC = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, bc->drag_ptC).getPoint();
}
sp_box3d_drag(*bc, event->motion.state);
index 6da465f2a48691557a97d0ffb71f5bbd95bc4030..d311cfabde9c6abbafa36ecfdef065724d6cc2ed 100644 (file)
@@ -530,9 +530,9 @@ connector_handle_button_press(SPConnectorContext *const cc, GdkEventButton const
if (!cc->sid) {
// This is the first point, so just snap it to the grid
// as there's no other points to go off.
- SnapManager const &m = cc->desktop->namedview->snap_manager;
- p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE,
- p, NULL).getPoint();
+ SnapManager &m = cc->desktop->namedview->snap_manager;
+ m.setup(cc->desktop);
+ p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p).getPoint();
}
spcc_connector_set_initial_point(cc, p);
diff --git a/src/context-fns.cpp b/src/context-fns.cpp
index d7333adbe18097520b16106508e2a912fc81b948..83048af40ac3901285dab35ce4c07a359532dac9 100644 (file)
--- a/src/context-fns.cpp
+++ b/src/context-fns.cpp
bool const shift = state & GDK_SHIFT_MASK;
bool const control = state & GDK_CONTROL_MASK;
- SnapManager const &m = desktop->namedview->snap_manager;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, item);
Inkscape::SnappedPoint snappoint;
if (control) {
@@ -132,11 +133,11 @@ NR::Rect Inkscape::snap_rectangular_box(SPDesktop const *desktop, SPItem *item,
/* Try to snap p[0] (the opposite corner) along the constraint vector */
s[0] = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, p[0],
- Inkscape::Snapper::ConstraintLine(p[0] - p[1]), item);
+ Inkscape::Snapper::ConstraintLine(p[0] - p[1]));
/* Try to snap p[1] (the dragged corner) along the constraint vector */
s[1] = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, p[1],
- Inkscape::Snapper::ConstraintLine(p[1] - p[0]), item);
+ Inkscape::Snapper::ConstraintLine(p[1] - p[0]));
/* Choose the best snap and update points accordingly */
if (s[0].getDistance() < s[1].getDistance()) {
@@ -148,13 +149,14 @@ NR::Rect Inkscape::snap_rectangular_box(SPDesktop const *desktop, SPItem *item,
p[1] = s[1].getPoint();
snappoint = s[1];
}
+ desktop->snapindicator->set_new_snappoint(snappoint);
} else {
/* Our origin is the opposite corner. Snap the drag point along the constraint vector */
p[0] = center;
snappoint = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, p[1],
- Inkscape::Snapper::ConstraintLine(p[1] - p[0]), item);
+ Inkscape::Snapper::ConstraintLine(p[1] - p[0]));
p[1] = snappoint.getPoint();
}
Inkscape::SnappedPoint s[2];
- s[0] = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p[0], item);
- s[1] = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p[1], item);
+ s[0] = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p[0]);
+ s[1] = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p[1]);
if (s[0].getDistance() < s[1].getDistance()) {
p[0] = s[0].getPoint();
/* There's no constraint on the corner point, so just snap it to anything */
p[0] = center;
- snappoint = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, pt, item);
+ snappoint = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, pt);
p[1] = snappoint.getPoint();
}
diff --git a/src/desktop-events.cpp b/src/desktop-events.cpp
index d2b21294c6bd419d12f3cd441171cb598d2f9639..29734f45979fe7cf0ba20fd0eb01f3f86288c465 100644 (file)
--- a/src/desktop-events.cpp
+++ b/src/desktop-events.cpp
@@ -142,19 +142,14 @@ static gint sp_dt_ruler_event(GtkWidget *widget, GdkEvent *event, SPDesktopWidge
NR::Point const event_w(sp_canvas_window_to_world(dtw->canvas, event_win));
NR::Point event_dt(desktop->w2d(event_w));
- SnapManager const &m = desktop->namedview->snap_manager;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
Inkscape::SnappedPoint snappoint = m.guideSnap(event_dt, normal);
event_dt = snappoint.getPoint();
sp_guideline_set_position(SP_GUIDELINE(guide), event_dt.to_2geom());
desktop->set_coordinate_status(event_dt);
- desktop->setPosition (event_dt);
-
- if (snappoint.getSnapped()) {
- desktop->snapindicator->set_new_snappoint(snappoint);
- } else {
- desktop->snapindicator->remove_snappoint();
- }
+ desktop->setPosition (event_dt);
}
break;
case GDK_BUTTON_RELEASE:
@@ -163,7 +158,8 @@ static gint sp_dt_ruler_event(GtkWidget *widget, GdkEvent *event, SPDesktopWidge
NR::Point const event_w(sp_canvas_window_to_world(dtw->canvas, event_win));
NR::Point event_dt(desktop->w2d(event_w));
- SnapManager const &m = desktop->namedview->snap_manager;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
event_dt = m.guideSnap(event_dt, normal).getPoint();
dragging = false;
// This is for snapping while dragging existing guidelines. New guidelines,
// which are dragged off the ruler, are being snapped in sp_dt_ruler_event
- SnapManager const &m = desktop->namedview->snap_manager;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
Inkscape::SnappedPoint snappoint = m.guideSnap(motion_dt, guide->normal_to_line);
motion_dt = snappoint.getPoint();
desktop->set_coordinate_status(motion_dt);
desktop->setPosition (motion_dt);
- if (snappoint.getSnapped()) {
- desktop->snapindicator->set_new_snappoint(snappoint);
- } else {
- desktop->snapindicator->remove_snappoint();
- }
-
ret = TRUE;
}
break;
event->button.y);
NR::Point event_dt(desktop->w2d(event_w));
- SnapManager const &m = desktop->namedview->snap_manager;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
event_dt = m.guideSnap(event_dt, guide->normal_to_line).getPoint();
if (sp_canvas_world_pt_inside_window(item->canvas, event_w)) {
diff --git a/src/desktop.h b/src/desktop.h
index 7653f0857bd38844c33b3b2a06230155bb6d5f73..df9848282b42ce571122ff7c0896bdd6f2fae008 100644 (file)
--- a/src/desktop.h
+++ b/src/desktop.h
#include "ui/view/edit-widget-interface.h"
#include "display/rendermode.h"
+#include "display/snap-indicator.h"
class NRRect;
class SPCSSAttr;
namespace Display {
class TemporaryItemList;
class TemporaryItem;
- class SnapIndicator;
+ //class SnapIndicator;
}
}
index 03fcad484027eab5b54da16e0376ace969282b39..3ee00c9d1067a54fb04f3665deb2717ac6d47ba8 100644 (file)
*
* Authors:
* Johan Engelen
+ * Diederik van Lierop
*
* Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ * Copyright (C) Diederik van Lierop 2008 <mail@diedenrezi.nl>
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
index c17de0494a5409e97e7f57e1780f6dc67d61d9e5..1e93e36df090671d2de1dc5c878e173a3dd72f65 100644 (file)
*
* Authors:
* Johan Engelen
+ * Diederik van Lierop
*
* Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ * Copyright (C) Diederik van Lierop 2008 <mail@diedenrezi.nl>
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
diff --git a/src/draw-context.cpp b/src/draw-context.cpp
index 42555f8d299a7bf139a83514adfb765a782e1f31..05045e96993652859384e96c0af7f25457f990fd 100644 (file)
--- a/src/draw-context.cpp
+++ b/src/draw-context.cpp
#include "snap.h"
#include "sp-path.h"
#include "sp-namedview.h"
-#include "display/snap-indicator.h"
static void sp_draw_context_class_init(SPDrawContextClass *klass);
static void sp_draw_context_init(SPDrawContext *dc);
@@ -354,13 +353,11 @@ void spdc_endpoint_snap_rotation(SPEventContext const *const ec, NR::Point &p, N
p = o + bdot * best;
/* Snap it along best vector */
- SnapManager const &m = SP_EVENT_CONTEXT_DESKTOP(ec)->namedview->snap_manager;
+ SnapManager &m = SP_EVENT_CONTEXT_DESKTOP(ec)->namedview->snap_manager;
+ m.setup(SP_EVENT_CONTEXT_DESKTOP(ec), NULL);
Inkscape::SnappedPoint const s = m.constrainedSnap( Inkscape::Snapper::SNAPPOINT_NODE,
- p, Inkscape::Snapper::ConstraintLine(best), NULL );
+ p, Inkscape::Snapper::ConstraintLine(best));
p = s.getPoint();
- if (s.getSnapped()) {
- SP_EVENT_CONTEXT_DESKTOP(ec)->snapindicator->set_new_snappoint(s);
- }
}
}
@@ -372,12 +369,10 @@ void spdc_endpoint_snap_free(SPEventContext const * const ec, NR::Point& p, guin
return;
}
- SnapManager const &m = SP_EVENT_CONTEXT_DESKTOP(ec)->namedview->snap_manager;
- Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p, NULL);
+ SnapManager &m = SP_EVENT_CONTEXT_DESKTOP(ec)->namedview->snap_manager;
+ m.setup(SP_EVENT_CONTEXT_DESKTOP(ec), NULL);
+ Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p);
p = s.getPoint();
- if (s.getSnapped()) {
- SP_EVENT_CONTEXT_DESKTOP(ec)->snapindicator->set_new_snappoint(s);
- }
}
static SPCurve *
index 230072e645b5624b35f54946395c280cdfe64a14..86bce50b95c9d2ddac2ff742b68d2c6671b24874 100644 (file)
--- a/src/gradient-context.cpp
+++ b/src/gradient-context.cpp
@@ -552,8 +552,9 @@ sp_gradient_context_root_handler(SPEventContext *event_context, GdkEvent *event)
event_context->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, TRUE);
/* Snap center to nearest magnetic point */
- SnapManager const &m = desktop->namedview->snap_manager;
- rc->origin = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, button_dt, NULL).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
+ rc->origin = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, button_dt).getPoint();
}
ret = TRUE;
diff --git a/src/gradient-drag.cpp b/src/gradient-drag.cpp
index 7a7957856c8096f496bc2db5aa57e7ae88ec503d..ee9ff657b53247ee38e2c8c85dc072f41ef6ae33 100644 (file)
--- a/src/gradient-drag.cpp
+++ b/src/gradient-drag.cpp
#include "snap.h"
#include "sp-namedview.h"
#include "selection-chemistry.h"
-#include "display/snap-indicator.h"
-
#define GR_KNOT_COLOR_NORMAL 0xffffff00
#define GR_KNOT_COLOR_MOUSEOVER 0xff000000
@@ -529,8 +527,6 @@ gr_knot_moved_handler(SPKnot *knot, NR::Point const *ppointer, guint state, gpoi
// FIXME: take from prefs
double snap_dist = SNAP_DIST / dragger->parent->desktop->current_zoom();
- dragger->parent->desktop->snapindicator->remove_snappoint();
-
if (state & GDK_SHIFT_MASK) {
// with Shift; unsnap if we carry more than one draggable
if (dragger->draggables && dragger->draggables->next) {
@@ -582,12 +578,13 @@ gr_knot_moved_handler(SPKnot *knot, NR::Point const *ppointer, guint state, gpoi
if (!((state & GDK_SHIFT_MASK) || ((state & GDK_CONTROL_MASK) && (state & GDK_MOD1_MASK)))) {
// Try snapping to the grid or guides
- SnapManager const &m = dragger->parent->desktop->namedview->snap_manager;
- Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p, NULL);
+ SPDesktop *desktop = dragger->parent->desktop;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
+ Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p);
if (s.getSnapped()) {
p = s.getPoint();
sp_knot_moveto (knot, &p);
- dragger->parent->desktop->snapindicator->set_new_snappoint(s);
} else {
bool was_snapped = false;
double dist = NR_HUGE;
@@ -611,7 +608,7 @@ gr_knot_moved_handler(SPKnot *knot, NR::Point const *ppointer, guint state, gpoi
}
}
if (was_snapped) {
- dragger->parent->desktop->snapindicator->set_new_snappoint(s);
+ desktop->snapindicator->set_new_snappoint(s);
}
}
}
diff --git a/src/line-snapper.cpp b/src/line-snapper.cpp
index b9974c2c04cafdbde915fe954c3a85716ab3b914..efa6762b2a3d659c2d8740f9c518c3dd2135ea68 100644 (file)
--- a/src/line-snapper.cpp
+++ b/src/line-snapper.cpp
@@ -23,14 +23,18 @@ Inkscape::LineSnapper::LineSnapper(SPNamedView const *nv, NR::Coord const d) : S
}
-void Inkscape::LineSnapper::_doFreeSnap(SnappedConstraints &sc,
+void Inkscape::LineSnapper::freeSnap(SnappedConstraints &sc,
Inkscape::Snapper::PointType const &t,
NR::Point const &p,
- bool const &f,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
- std::vector<NR::Point> *unselected_nodes) const
+ bool const &/*f*/,
+ NR::Maybe<NR::Rect> const &/*bbox_to_snap*/,
+ std::vector<SPItem const *> const */*it*/,
+ std::vector<NR::Point> */*unselected_nodes*/) const
{
+ if (_snap_enabled == false || getSnapFrom(t) == false) {
+ return;
+ }
+
/* Get the lines that we will try to snap to */
const LineList lines = _getSnapLines(p);
}
}
-void Inkscape::LineSnapper::_doConstrainedSnap(SnappedConstraints &sc,
- Inkscape::Snapper::PointType const &/*t*/,
+void Inkscape::LineSnapper::constrainedSnap(SnappedConstraints &sc,
+ Inkscape::Snapper::PointType const &t,
NR::Point const &p,
bool const &/*f*/,
- std::vector<NR::Point> &/*points_to_snap*/,
+ NR::Maybe<NR::Rect> const &/*bbox_to_snap*/,
ConstraintLine const &c,
- std::vector<SPItem const *> const &/*it*/) const
+ std::vector<SPItem const *> const */*it*/) const
{
+ if (_snap_enabled == false || getSnapFrom(t) == false) {
+ return;
+ }
+
/* Get the lines that we will try to snap to */
const LineList lines = _getSnapLines(p);
diff --git a/src/line-snapper.h b/src/line-snapper.h
index 39df820571cedae35a5cd5498b6ef077241697f5..e5fc95dcba82c4950744dbd9832fd915bc54b021 100644 (file)
--- a/src/line-snapper.h
+++ b/src/line-snapper.h
public:
LineSnapper(SPNamedView const *nv, NR::Coord const d);
-protected:
- typedef std::list<std::pair<NR::Point, NR::Point> > LineList;
- //first point is a vector normal to the line
- //second point is a point on the line
-
-private:
- void _doFreeSnap(SnappedConstraints &sc,
+ void freeSnap(SnappedConstraints &sc,
Inkscape::Snapper::PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
+ std::vector<SPItem const *> const *it,
std::vector<NR::Point> *unselected_nodes) const;
- void _doConstrainedSnap(SnappedConstraints &sc,
+ void constrainedSnap(SnappedConstraints &sc,
Inkscape::Snapper::PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const;
-
+ std::vector<SPItem const *> const *it) const;
+
+protected:
+ typedef std::list<std::pair<NR::Point, NR::Point> > LineList;
+ //first point is a vector normal to the line
+ //second point is a point on the line
+
+private:
/**
* \param p Point that we are trying to snap.
* \return List of lines that we should try snapping to.
diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index a9886046c67c4ea7ab22f6781b3042ad6783f840..6b1c540574fe79251b327cc7d4f2104d674fd628 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
@@ -1233,7 +1233,8 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
- Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, SP_PATH(n->subpath->nodepath->item), &unselected_nodes);
+ m.setup(nodepath->desktop, SP_PATH(n->subpath->nodepath->item), &unselected_nodes);
+ Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta);
if (s.getDistance() < best) {
best = s.getDistance();
best_abs = s;
@@ -3659,7 +3660,9 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint /*state*/,
g_assert_not_reached();
}
- SnapManager const &m = n->subpath->nodepath->desktop->namedview->snap_manager;
+ SPDesktop *desktop = n->subpath->nodepath->desktop;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, n->subpath->nodepath->item);
Inkscape::SnappedPoint s ;
Inkscape::NodePath::Node *othernode = opposite->other;
@@ -3675,18 +3678,13 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint /*state*/,
NR::Coord const scal = dot(delta, ndelta) / linelen;
(*p) = n->pos + (scal / linelen) * ndelta;
}
- s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), n->subpath->nodepath->item);
+ s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta));
} else {
- s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, n->subpath->nodepath->item);
+ s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p);
}
- } else {
- s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, n->subpath->nodepath->item);
}
-
+
*p = s.getPoint();
- if (s.getSnapped()) {
- n->subpath->nodepath->desktop->snapindicator->set_new_snappoint(s);
- }
sp_node_adjust_handle(n, -which);
diff --git a/src/object-edit.cpp b/src/object-edit.cpp
index b3d661586a2b08b2f2e012052f8779e6706bb1e7..3d4aaae399097fced9d1adfd384a40a0705f3ee6 100644 (file)
--- a/src/object-edit.cpp
+++ b/src/object-edit.cpp
SPDesktop const *desktop = inkscape_active_desktop();
NR::Matrix const i2d (sp_item_i2d_affine (item));
NR::Point s = p * i2d;
- SnapManager const &m = desktop->namedview->snap_manager;
- s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, s, item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, item);
+ s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, s).getPoint();
return s * i2d.inverse();
}
diff --git a/src/object-snapper.cpp b/src/object-snapper.cpp
index a9101415871be476db5f5da65f0bb105aa939dec..57ec1b3479f550a7edf3308916be10f925d041cc 100644 (file)
--- a/src/object-snapper.cpp
+++ b/src/object-snapper.cpp
* \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
+ * \param bbox_to_snap Bounding box hulling the whole bunch of points, all from the same selection and having the same transformation
* \param DimensionToSnap Snap in X, Y, or both directions.
*/
void Inkscape::ObjectSnapper::_findCandidates(SPObject* r,
- std::vector<SPItem const *> const &it,
+ std::vector<SPItem const *> const *it,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ NR::Rect const &bbox_to_snap,
DimensionToSnap const snap_dim) const
{
bool const c1 = (snap_dim == TRANSL_SNAP_XY) && ThisSnapperMightSnap();
bool const c2 = (snap_dim != TRANSL_SNAP_XY) && GuidesMightSnap();
- bool const c3 = points_to_snap.size() == 0;
- if (!(c1 || c2) || c3) {
+ if (!(c1 || c2)) {
return;
}
_candidates->clear();
}
- NR::Maybe<NR::Rect> bbox = NR::Rect(); // a default NR::Rect is infinitely large
- NR::Coord t = getSnapperTolerance();
+ NR::Maybe<NR::Rect> bbox_of_item = NR::Rect(); // a default NR::Rect is infinitely large
+ NR::Rect bbox_to_snap_incl = bbox_to_snap; // _incl means: will include the snapper tolerance
+ bbox_to_snap_incl.growBy(getSnapperTolerance()); // see?
- // When dragging a guide...
- NR::Point p_guide = points_to_snap[0];
- if (!getSnapperAlwaysSnap()) {
- bbox = NR::Rect(p_guide, p_guide); // bbox is now just a single point: p_guide
- bbox->growBy(t); // bbox width and height now measure 2x snapper tolerance
- // for angled guidelines the bbox is now larger than really needed
- // (up to sqrt(2) for 45 deg. guidelines) but we'll leave it like that
- } // else: use an infinitely large bbox to find candidates
-
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))) {
/* See if this item is on the ignore list */
- std::vector<SPItem const *>::const_iterator i = it.begin();
- while (i != it.end() && *i != o) {
- i++;
+ std::vector<SPItem const *>::const_iterator i;
+ if (it != NULL) {
+ i = it->begin();
+ while (i != it->end() && *i != o) {
+ i++;
+ }
}
- if (i == it.end()) {
+ if (it == NULL || i == it->end()) {
/* See if the item is within range */
if (SP_IS_GROUP(o)) {
- _findCandidates(o, it, false, points_to_snap, snap_dim);
+ _findCandidates(o, it, false, bbox_to_snap, snap_dim);
} else {
- // Now let's see if any of the snapping points is within snapping range of this object
- if (snap_dim == TRANSL_SNAP_XY) {
- bbox = sp_item_bbox_desktop(SP_ITEM(o));
- } // else: we're snapping a guide to an object and we will use the bbox as defined above
-
- if (bbox) {
- for (std::vector<NR::Point>::const_iterator i = points_to_snap.begin(); i != points_to_snap.end(); i++) {
- NR::Point b_min = bbox->min();
- NR::Point b_max = bbox->max();
- bool withinX = ((*i)[NR::X] >= b_min[NR::X] - t) && ((*i)[NR::X] <= b_max[NR::X] + t);
- bool withinY = ((*i)[NR::Y] >= b_min[NR::Y] - t) && ((*i)[NR::Y] <= b_max[NR::Y] + t);
- if (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;
- }
+ bbox_of_item = sp_item_bbox_desktop(SP_ITEM(o));
+ if (bbox_of_item) {
+ if (bbox_to_snap_incl.intersects(*bbox_of_item)) {
+ //This item is within snapping range, so record it as a candidate
+ _candidates->push_back(SP_ITEM(o));
}
}
}
bool const being_edited = (node_tool_active && (*k) == _paths_to_snap_to->back());
//if true then this path k is currently being edited in the node tool
- for (unsigned i = 1 ; i < (*k)->pts.size() ; i++) {
+ for (unsigned i = 1 ; i < (*k)->pts.size() ; i++) {
+ //pts describes a polyline approximation, which might consist of 1000s of points!
NR::Point start_point;
NR::Point end_point;
NR::Maybe<Path::cut_position> o = NR::Nothing();
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);
+
+ /* IF YOU'RE BUG HUNTING: IT LOOKS LIKE get_point_on_Path SOMETIMES
+ * RETURNS THE WRONG POINT (WITH AN OFFSET, BUT STILL ON THE PATH.
+ * THIS BUG WILL NO LONGER BE ENCOUNTERED ONCE WE'VE SWITCHED TO
+ * 2GEOM FOR THE OBJECT SNAPPER
+ */
+
NR::Point const o_dt = desktop->doc2dt(o_it);
NR::Coord const dist = NR::L2(o_dt - p);
}
-void Inkscape::ObjectSnapper::_doFreeSnap(SnappedConstraints &sc,
+void Inkscape::ObjectSnapper::freeSnap(SnappedConstraints &sc,
Inkscape::Snapper::PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
+ std::vector<SPItem const *> const *it,
std::vector<NR::Point> *unselected_nodes) const
{
- if ( NULL == _named_view ) {
+ if (_snap_enabled == false || getSnapFrom(t) == false || _named_view == NULL) {
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, TRANSL_SNAP_XY);
+ NR::Rect const local_bbox_to_snap = bbox_to_snap ? *bbox_to_snap : NR::Rect(p, p);
+ _findCandidates(sp_document_root(_named_view->document), it, first_point, local_bbox_to_snap, TRANSL_SNAP_XY);
}
if (_snap_to_itemnode || _snap_to_bboxnode) {
* of the node snapping requirements (i.e. only unselected nodes must be snapable).
* That path must not be ignored however when snapping to the paths, so we add it here
* manually when applicable
- */
- g_assert(it.size() == 1);
- g_assert(SP_IS_PATH(*it.begin()));
- _snapPaths(sc, t, p, first_point, unselected_nodes, SP_PATH(*it.begin()), border_bpath);
+ */
+ SPPath *path = NULL;
+ if (it != NULL) {
+ g_assert(SP_IS_PATH(*it->begin()));
+ g_assert(it->size() == 1);
+ path = SP_PATH(*it->begin());
+ }
+ _snapPaths(sc, t, p, first_point, unselected_nodes, path, border_bpath);
} else {
_snapPaths(sc, t, p, first_point, NULL, NULL, border_bpath);
}
}
}
-void Inkscape::ObjectSnapper::_doConstrainedSnap( SnappedConstraints &sc,
+void Inkscape::ObjectSnapper::constrainedSnap( SnappedConstraints &sc,
Inkscape::Snapper::PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const
+ std::vector<SPItem const *> const *it) const
{
- if ( NULL == _named_view ) {
+ if (_snap_enabled == false || getSnapFrom(t) == false || _named_view == NULL) {
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, TRANSL_SNAP_XY);
+ NR::Rect const local_bbox_to_snap = bbox_to_snap ? *bbox_to_snap : NR::Rect(p, p);
+ _findCandidates(sp_document_root(_named_view->document), it, first_point, local_bbox_to_snap, TRANSL_SNAP_XY);
}
// A constrained snap, is a snap in only one degree of freedom (specified by the constraint line).
/* Get a list of all the SPItems that we will try to snap to */
std::vector<SPItem*> cand;
std::vector<SPItem const *> const it; //just an empty list
-
- std::vector<NR::Point> points_to_snap;
- points_to_snap.push_back(p);
-
+
DimensionToSnap snap_dim;
if (guide_normal == component_vectors[NR::Y]) {
snap_dim = GUIDE_TRANSL_SNAP_Y;
} else {
snap_dim = ANGLED_GUIDE_TRANSL_SNAP;
}
+
// We don't support ANGLED_GUIDE_ROT_SNAP yet.
// It would be cool to allow the user to rotate a guide by dragging it, instead of
// or a transformation center (which can be moved after clicking for the
// second time on an object; but should this point then be constrained to the
// line, or can it be located anywhere?)
-
- _findCandidates(sp_document_root(_named_view->document), it, true, points_to_snap, snap_dim);
+
+ _findCandidates(sp_document_root(_named_view->document), &it, true, NR::Rect(p, p), snap_dim);
_snapTranslatingGuideToNodes(sc, Inkscape::Snapper::SNAPPOINT_GUIDE, p, guide_normal);
// _snapRotatingGuideToNodes has not been implemented yet.
diff --git a/src/object-snapper.h b/src/object-snapper.h
index 29f5954246a7a2cf8e37182f28c712c14b7ad49f..94c9e5a1c2df0aac9a89acbb8f86f52ede7dcb9d 100644 (file)
--- a/src/object-snapper.h
+++ b/src/object-snapper.h
ANGLED_GUIDE_ROT_SNAP, // For snapping an angled guide, while rotating it around some pivot point
TRANSL_SNAP_XY}; // All other cases; for snapping to objects, other than guides
- void setSnapToItemNode(bool s) {
- _snap_to_itemnode = s;
- }
-
- bool getSnapToItemNode() const {
- return _snap_to_itemnode;
- }
-
- void setSnapToItemPath(bool s) {
- _snap_to_itempath = s;
- }
-
- bool getSnapToItemPath() const {
- return _snap_to_itempath;
- }
-
- void setSnapToBBoxNode(bool s) {
- _snap_to_bboxnode = s;
- }
-
- bool getSnapToBBoxNode() const {
- return _snap_to_bboxnode;
- }
-
- void setSnapToBBoxPath(bool s) {
- _snap_to_bboxpath = s;
- }
-
- bool getSnapToBBoxPath() const {
- return _snap_to_bboxpath;
- }
-
- void setSnapToPageBorder(bool s) {
- _snap_to_page_border = s;
- }
-
- bool getSnapToPageBorder() const {
- return _snap_to_page_border;
- }
-
- void setIncludeItemCenter(bool s) {
- _include_item_center = s;
- }
-
- bool getIncludeItemCenter() const {
- return _include_item_center;
- }
-
- void setStrictSnapping(bool enabled) {
- _strict_snapping = enabled;
- }
+ void setSnapToItemNode(bool s) {_snap_to_itemnode = s;}
+ bool getSnapToItemNode() const {return _snap_to_itemnode;}
+ void setSnapToItemPath(bool s) {_snap_to_itempath = s;}
+ bool getSnapToItemPath() const {return _snap_to_itempath;}
+ void setSnapToBBoxNode(bool s) {_snap_to_bboxnode = s;}
+ bool getSnapToBBoxNode() const {return _snap_to_bboxnode;}
+ void setSnapToBBoxPath(bool s) {_snap_to_bboxpath = s;}
+ bool getSnapToBBoxPath() const {return _snap_to_bboxpath;}
+ void setSnapToPageBorder(bool s) {_snap_to_page_border = s;}
+ bool getSnapToPageBorder() const {return _snap_to_page_border;}
+ void setIncludeItemCenter(bool s) {_include_item_center = s;}
+ bool getIncludeItemCenter() const {return _include_item_center;}
+ void setStrictSnapping(bool enabled) {_strict_snapping = enabled;}
void guideSnap(SnappedConstraints &sc,
NR::Point const &p,
bool ThisSnapperMightSnap() const;
bool GuidesMightSnap() const;
-private:
- //store some lists of candidates, points and paths, so we don't have to rebuild them for each point we want to snap
- std::vector<SPItem*> *_candidates;
- std::vector<NR::Point> *_points_to_snap_to;
- std::vector<NArtBpath*> *_bpaths_to_snap_to;
- std::vector<Path*> *_paths_to_snap_to;
-
- void _doFreeSnap(SnappedConstraints &sc,
+ void freeSnap(SnappedConstraints &sc,
Inkscape::Snapper::PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
+ std::vector<SPItem const *> const *it,
std::vector<NR::Point> *unselected_nodes) const;
- void _doConstrainedSnap(SnappedConstraints &sc,
+ void constrainedSnap(SnappedConstraints &sc,
Inkscape::Snapper::PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const;
-
+ std::vector<SPItem const *> const *it) const;
+
+private:
+ //store some lists of candidates, points and paths, so we don't have to rebuild them for each point we want to snap
+ std::vector<SPItem*> *_candidates;
+ std::vector<NR::Point> *_points_to_snap_to;
+ std::vector<NArtBpath*> *_bpaths_to_snap_to;
+ std::vector<Path*> *_paths_to_snap_to;
+
void _findCandidates(SPObject* r,
- std::vector<SPItem const *> const &it,
+ std::vector<SPItem const *> const *it,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ NR::Rect const &bbox_to_snap,
DimensionToSnap snap_dim) const;
void _snapNodes(SnappedConstraints &sc,
NR::Point const &p,
bool const &first_point,
ConstraintLine const &c) const;
+
bool isUnselectedNode(NR::Point const &point, std::vector<NR::Point> const *unselected_nodes) const;
void _collectPaths(Inkscape::Snapper::PointType const &t,
diff --git a/src/pencil-context.cpp b/src/pencil-context.cpp
index 878651ade939b02fcb799c8abfcd215edbbd54af..3d397b1800e580b5cc86f38ae2e3c4815eb53862 100644 (file)
--- a/src/pencil-context.cpp
+++ b/src/pencil-context.cpp
#include "pixmaps/cursor-pencil.xpm"
#include "display/bezier-utils.h"
#include "display/canvas-bpath.h"
-#include "display/snap-indicator.h"
#include <glibmm/i18n.h>
#include "libnr/in-svg-plane.h"
#include "libnr/n-art-bpath.h"
@@ -246,8 +245,9 @@ pencil_handle_button_press(SPPencilContext *const pc, GdkEventButton const &beve
// anchor, which is handled by the sibling branch above)
selection->clear();
desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Creating new path"));
- SnapManager const &m = desktop->namedview->snap_manager;
- p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p, NULL).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
+ p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p).getPoint();
} else if (selection->singleItem() && SP_IS_PATH(selection->singleItem())) {
desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Appending to selected path"));
}
@@ -275,8 +275,6 @@ pencil_handle_motion_notify(SPPencilContext *const pc, GdkEventMotion const &mev
gint ret = FALSE;
SPDesktop *const dt = pc->desktop;
- dt->snapindicator->remove_snappoint();
-
SPEventContext *event_context = SP_EVENT_CONTEXT(pc);
if (event_context->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
// allow scrolling
@@ -324,12 +322,10 @@ pencil_handle_motion_notify(SPPencilContext *const pc, GdkEventMotion const &mev
if (anchor) {
p = anchor->dp;
} else if ((mevent.state & GDK_SHIFT_MASK) == 0) {
- SnapManager const &m = dt->namedview->snap_manager;
- Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p, NULL);
+ SnapManager &m = dt->namedview->snap_manager;
+ m.setup(dt, NULL);
+ Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p);
p = s.getPoint();
- if (s.getSnapped()) {
- dt->snapindicator->set_new_snappoint(s);
- }
}
if ( pc->npoints != 0 ) { // buttonpress may have happened before we entered draw context!
spdc_add_freehand_point(pc, p, mevent.state);
diff --git a/src/rect-context.cpp b/src/rect-context.cpp
index 1054a2c55850eca3d481cc513ac3ecf9acc80483..ad383b0144d24fdefa49fd2b4f1a583f38b0bd6c 100644 (file)
--- a/src/rect-context.cpp
+++ b/src/rect-context.cpp
#include "macros.h"
#include "display/sp-canvas.h"
-#include "display/snap-indicator.h"
#include "sp-rect.h"
#include "document.h"
#include "sp-namedview.h"
@@ -284,8 +283,6 @@ static gint sp_rect_context_root_handler(SPEventContext *event_context, GdkEvent
event_context->tolerance = prefs_get_int_attribute_limited("options.dragtolerance", "value", 0, 0, 100);
- desktop->snapindicator->remove_snappoint();
-
gint ret = FALSE;
switch (event->type) {
case GDK_BUTTON_PRESS:
@@ -307,13 +304,11 @@ static gint sp_rect_context_root_handler(SPEventContext *event_context, GdkEvent
NR::Point const button_dt(desktop->w2d(button_w));
/* Snap center */
- SnapManager const &m = desktop->namedview->snap_manager;
- Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, button_dt, rc->item);
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, rc->item);
+ Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, button_dt);
rc->center = s.getPoint();
- if (s.getSnapped()) {
- desktop->snapindicator->set_new_snappoint(s);
- }
-
+
sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
( GDK_KEY_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
@@ -341,13 +336,11 @@ static gint sp_rect_context_root_handler(SPEventContext *event_context, GdkEvent
event->motion.y);
NR::Point motion_dt(desktop->w2d(motion_w));
- SnapManager const &m = desktop->namedview->snap_manager;
- Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt, rc->item);
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, rc->item);
+ Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt);
motion_dt = s.getPoint();
- if (s.getSnapped()) {
- desktop->snapindicator->set_new_snappoint(s);
- }
-
+
sp_rect_drag(*rc, motion_dt, event->motion.state);
gobble_motion_events(GDK_BUTTON1_MASK);
ret = TRUE;
diff --git a/src/seltrans.cpp b/src/seltrans.cpp
index c90ac31cf519ba2efd3200825ab0fa6572425d9e..b7dc2e767da9055a260a2dbfee11eb7e74744ae1 100644 (file)
--- a/src/seltrans.cpp
+++ b/src/seltrans.cpp
// When scaling by an integer, snapping is not needed
} else {
// In all other cases we should try to snap now
- SnapManager const &m = _desktop->namedview->snap_manager;
+ SnapManager &m = _desktop->namedview->snap_manager;
+ m.setup(NULL, _items_const);
Inkscape::SnappedPoint bb, sn;
NR::Coord bd(NR_HUGE);
}
// Snap along a suitable constraint vector from the origin.
- bb = m.constrainedSnapScale(Snapper::SNAPPOINT_BBOX, _bbox_points, _items_const, default_scale, _origin_for_bboxpoints);
- sn = m.constrainedSnapScale(Snapper::SNAPPOINT_NODE, _snap_points, _items_const, geom_scale, _origin_for_specpoints);
+ bb = m.constrainedSnapScale(Snapper::SNAPPOINT_BBOX, _bbox_points, default_scale, _origin_for_bboxpoints);
+ sn = m.constrainedSnapScale(Snapper::SNAPPOINT_NODE, _snap_points, geom_scale, _origin_for_specpoints);
/* Choose the smaller difference in scale. Since s[X] == s[Y] we can
** just compare difference in s[X].
sd = sn.getSnapped() ? fabs(sn.getTransformation()[NR::X] - geom_scale[NR::X]) : NR_HUGE;
} else {
/* Scale aspect ratio is unlocked */
- bb = m.freeSnapScale(Snapper::SNAPPOINT_BBOX, _bbox_points, _items_const, default_scale, _origin_for_bboxpoints);
- sn = m.freeSnapScale(Snapper::SNAPPOINT_NODE, _snap_points, _items_const, geom_scale, _origin_for_specpoints);
+ bb = m.freeSnapScale(Snapper::SNAPPOINT_BBOX, _bbox_points, default_scale, _origin_for_bboxpoints);
+ sn = m.freeSnapScale(Snapper::SNAPPOINT_NODE, _snap_points, geom_scale, _origin_for_specpoints);
/* Pick the snap that puts us closest to the original scale */
bd = bb.getSnapped() ? fabs(NR::L2(bb.getTransformation()) - NR::L2(default_scale.point())) : NR_HUGE;
if (!(bb.getSnapped() || sn.getSnapped())) {
// We didn't snap at all! Don't update the handle position, just calculate the new transformation
_calcAbsAffineDefault(default_scale);
+ _desktop->snapindicator->remove_snappoint();
} else if (bd < sd) {
// We snapped the bbox (which is either visual or geometric)
_desktop->snapindicator->set_new_snappoint(bb);
@@ -1024,7 +1026,8 @@ gboolean Inkscape::SelTrans::stretchRequest(SPSelTransHandle const &handle, NR::
} else {
// In all other cases we should try to snap now
- SnapManager const &m = _desktop->namedview->snap_manager;
+ SnapManager &m = _desktop->namedview->snap_manager;
+ m.setup(NULL, _items_const);
Inkscape::SnappedPoint bb, sn;
g_assert(bb.getSnapped() == false); // Check initialization to catch any regression
@@ -1033,8 +1036,8 @@ gboolean Inkscape::SelTrans::stretchRequest(SPSelTransHandle const &handle, NR::
bool symmetrical = state & GDK_CONTROL_MASK;
- bb = m.constrainedSnapStretch(Snapper::SNAPPOINT_BBOX, _bbox_points, _items_const, default_scale[axis], _origin_for_bboxpoints, axis, symmetrical);
- sn = m.constrainedSnapStretch(Snapper::SNAPPOINT_NODE, _snap_points, _items_const, geom_scale[axis], _origin_for_specpoints, axis, symmetrical);
+ bb = m.constrainedSnapStretch(Snapper::SNAPPOINT_BBOX, _bbox_points, default_scale[axis], _origin_for_bboxpoints, axis, symmetrical);
+ sn = m.constrainedSnapStretch(Snapper::SNAPPOINT_NODE, _snap_points, geom_scale[axis], _origin_for_specpoints, axis, symmetrical);
if (bb.getSnapped()) {
// We snapped the bbox (which is either visual or geometric)
@@ -1057,6 +1060,7 @@ gboolean Inkscape::SelTrans::stretchRequest(SPSelTransHandle const &handle, NR::
if (!(bb.getSnapped() || sn.getSnapped())) {
// We didn't snap at all! Don't update the handle position, just calculate the new transformation
_calcAbsAffineDefault(default_scale);
+ _desktop->snapindicator->remove_snappoint();
} else if (bd < sd) {
_desktop->snapindicator->set_new_snappoint(bb);
// Calculate the new transformation and update the handle position
@@ -1143,12 +1147,13 @@ gboolean Inkscape::SelTrans::skewRequest(SPSelTransHandle const &handle, NR::Poi
} else {
// Snap to objects, grids, guides
- SnapManager const &m = _desktop->namedview->snap_manager;
+ SnapManager &m = _desktop->namedview->snap_manager;
+ m.setup(NULL, _items_const);
//TODO: While skewing, scaling in the opposite direction by integer multiples is also allowed. This is not handled though by freeSnapSkew / _snapTransformed yet!
//TODO: We need a constrainedSnapSkew instead of a freeSnapSkew
- Inkscape::SnappedPoint bb = m.freeSnapSkew(Inkscape::Snapper::SNAPPOINT_BBOX, _bbox_points, _items_const, skew[dim_a], _origin, dim_b);
- Inkscape::SnappedPoint sn = m.freeSnapSkew(Inkscape::Snapper::SNAPPOINT_NODE, _snap_points, _items_const, skew[dim_a], _origin, dim_b);
+ Inkscape::SnappedPoint bb = m.freeSnapSkew(Inkscape::Snapper::SNAPPOINT_BBOX, _bbox_points, skew[dim_a], _origin, dim_b);
+ Inkscape::SnappedPoint sn = m.freeSnapSkew(Inkscape::Snapper::SNAPPOINT_NODE, _snap_points, skew[dim_a], _origin, dim_b);
if (bb.getSnapped() || sn.getSnapped()) {
// We snapped something, so change the skew to reflect it
@@ -1161,7 +1166,9 @@ gboolean Inkscape::SelTrans::skewRequest(SPSelTransHandle const &handle, NR::Poi
_desktop->snapindicator->set_new_snappoint(sn);
skew[dim_a] = sd;
}
- }
+ } else {
+ _desktop->snapindicator->remove_snappoint();
+ }
}
// Update the handle position
gboolean Inkscape::SelTrans::centerRequest(NR::Point &pt, guint state)
{
- SnapManager const &m = _desktop->namedview->snap_manager;
- pt = m.freeSnap(Snapper::SNAPPOINT_NODE, pt, NULL).getPoint();
+ SnapManager &m = _desktop->namedview->snap_manager;
+ m.setup(_desktop);
+ pt = m.freeSnap(Snapper::SNAPPOINT_NODE, pt).getPoint();
if (state & GDK_CONTROL_MASK) {
if ( fabs(_point[NR::X] - pt[NR::X]) > fabs(_point[NR::Y] - pt[NR::Y]) ) {
@@ -1345,7 +1353,8 @@ void sp_sel_trans_center(Inkscape::SelTrans *seltrans, SPSelTransHandle const &,
void Inkscape::SelTrans::moveTo(NR::Point const &xy, guint state)
{
- SnapManager const &m = _desktop->namedview->snap_manager;
+ SnapManager &m = _desktop->namedview->snap_manager;
+ m.setup(_desktop, _items_const);
/* The amount that we've moved by during this drag */
NR::Point dxy = xy - _point;
** FIXME: this will snap to more than just the grid, nowadays.
*/
- dxy = m.freeSnap(Snapper::SNAPPOINT_NODE, dxy, NULL).getPoint();
+ dxy = m.freeSnap(Snapper::SNAPPOINT_NODE, dxy).getPoint();
} else if (!shift) {
for (unsigned int dim = 0; dim < 2; dim++) {
s.push_back(m.constrainedSnapTranslation(Inkscape::Snapper::SNAPPOINT_BBOX,
_bbox_points,
- _items_const,
Inkscape::Snapper::ConstraintLine(component_vectors[dim]),
dxy));
s.push_back(m.constrainedSnapTranslation(Inkscape::Snapper::SNAPPOINT_NODE,
_snap_points,
- _items_const,
Inkscape::Snapper::ConstraintLine(component_vectors[dim]),
dxy));
}
g_get_current_time(&starttime); */
/* Snap to things with no constraint */
- s.push_back(m.freeSnapTranslation(Inkscape::Snapper::SNAPPOINT_BBOX,
- _bbox_points, _items_const, dxy));
- s.push_back(m.freeSnapTranslation(Inkscape::Snapper::SNAPPOINT_NODE,
- _snap_points, _items_const, dxy));
+ s.push_back(m.freeSnapTranslation(Inkscape::Snapper::SNAPPOINT_BBOX, _bbox_points, dxy));
+ s.push_back(m.freeSnapTranslation(Inkscape::Snapper::SNAPPOINT_NODE, _snap_points, dxy));
/*g_get_current_time(&endtime);
double elapsed = ((((double)endtime.tv_sec - starttime.tv_sec) * G_USEC_PER_SEC + (endtime.tv_usec - starttime.tv_usec))) / 1000.0;
}
if (best_snapped_point.getSnapped()) {
_desktop->snapindicator->set_new_snappoint(best_snapped_point);
+ } else {
+ _desktop->snapindicator->remove_snappoint();
}
}
diff --git a/src/snap.cpp b/src/snap.cpp
index 2d23a7745458ccb176c56becb561f357a58d7205..c9944cb0453409889befda5ecf5571216d4a1f05 100644 (file)
--- a/src/snap.cpp
+++ b/src/snap.cpp
#include <libnr/nr-values.h>
#include "display/canvas-grid.h"
+#include "display/snap-indicator.h"
#include "inkscape.h"
#include "desktop.h"
return object.getSnapFrom(Inkscape::Snapper::SNAPPOINT_GUIDE);
}
-/**
- * Try to snap a point to any interested snappers.
- *
- * \param t Type of point.
- * \param p Point.
- * \param it Item to ignore when snapping.
- * \return Snapped point.
- */
-
-Inkscape::SnappedPoint SnapManager::freeSnap(Inkscape::Snapper::PointType t,
- NR::Point const &p,
- SPItem const *it,
- NR::Maybe<NR::Point> point_not_to_snap_to) const
-
-{
- std::vector<SPItem const *> lit;
- if (it) {
- lit.push_back(it);
- }
-
- std::vector<NR::Point> points_to_snap;
- points_to_snap.push_back(p);
-
- return freeSnap(t, p, true, points_to_snap, lit, NULL);
-}
-
-/**
- * Try to snap a point to any interested snappers.
- *
- * \param t Type of point.
- * \param p Point.
- * \param it Item to ignore when snapping.
- * \return Snapped point.
- */
-
-Inkscape::SnappedPoint SnapManager::freeSnap(Inkscape::Snapper::PointType t,
- NR::Point const &p,
- SPItem const *it,
- std::vector<NR::Point> *unselected_nodes) const
-
-{
- std::vector<SPItem const *> lit;
- if (it) {
- lit.push_back(it);
- }
-
- std::vector<NR::Point> points_to_snap;
- points_to_snap.push_back(p);
-
- return freeSnap(t, p, true, points_to_snap, lit, unselected_nodes);
-}
-
-
/**
* Try to snap a point to any of the specified snappers.
*
- * \param t Type of point.
+ * \param point_type Type of point.
* \param p Point.
* \param first_point If true then this point is the first one from a whole bunch of points
* \param points_to_snap The whole bunch of points, all from the same selection and having the same transformation
- * \param it List of items to ignore when snapping.
- * \param snappers List of snappers to try to snap to
+ * \param snappers List of snappers to try to snap to
* \return Snapped point.
*/
-Inkscape::SnappedPoint SnapManager::freeSnap(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::freeSnap(Inkscape::Snapper::PointType point_type,
NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
- std::vector<NR::Point> *unselected_nodes) const
+ bool first_point,
+ NR::Maybe<NR::Rect> const &bbox_to_snap) const
{
if (!SomeSnapperMightSnap()) {
return Inkscape::SnappedPoint(p, NR_HUGE, 0, false);
}
- SnappedConstraints sc;
+ std::vector<SPItem const *> *items_to_ignore;
+ if (_item_to_ignore) { // If we have only a single item to ignore
+ // then build a list containing this single item;
+ // This single-item list will prevail over any other _items_to_ignore list, should that exist
+ items_to_ignore = new std::vector<SPItem const *>;
+ items_to_ignore->push_back(_item_to_ignore);
+ } else {
+ items_to_ignore = _items_to_ignore;
+ }
+ SnappedConstraints sc;
SnapperList const snappers = getSnappers();
-
+
for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
- (*i)->freeSnap(sc, t, p, first_point, points_to_snap, it, unselected_nodes);
- }
-
- return findBestSnap(p, sc, false);
-}
-
-/**
- * Try to snap a point to any interested snappers. A snap will only occur along
- * a line described by a Inkscape::Snapper::ConstraintLine.
- *
- * \param t Type of point.
- * \param p Point.
- * \param c Constraint line.
- * \param it Item to ignore when snapping.
- * \return Snapped point.
- */
-
-Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::Snapper::PointType t,
- NR::Point const &p,
- Inkscape::Snapper::ConstraintLine const &c,
- SPItem const *it) const
-{
- std::vector<SPItem const *> lit;
- if (it) {
- lit.push_back(it);
+ (*i)->freeSnap(sc, point_type, p, first_point, bbox_to_snap, items_to_ignore, _unselected_nodes);
}
- std::vector<NR::Point> points_to_snap;
- points_to_snap.push_back(p);
+ if (_item_to_ignore) {
+ delete items_to_ignore;
+ }
- return constrainedSnap(t, p, true, points_to_snap, c, lit);
+ return findBestSnap(p, sc, false);
}
-
-
/**
* Try to snap a point to any interested snappers. A snap will only occur along
* a line described by a Inkscape::Snapper::ConstraintLine.
*
- * \param t Type of point.
+ * \param point_type Type of point.
* \param p Point.
* \param first_point If true then this point is the first one from a whole bunch of points
* \param points_to_snap The whole bunch of points, all from the same selection and having the same transformation
- * \param c Constraint line.
- * \param it List of items to ignore when snapping.
+ * \param constraint Constraint line.
* \return Snapped point.
*/
-Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::Snapper::PointType point_type,
NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- Inkscape::Snapper::ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const
+ Inkscape::Snapper::ConstraintLine const &constraint,
+ bool first_point,
+ NR::Maybe<NR::Rect> const &bbox_to_snap) const
{
if (!SomeSnapperMightSnap()) {
return Inkscape::SnappedPoint(p, NR_HUGE, 0, false);
}
- SnappedConstraints sc;
-
+ std::vector<SPItem const *> *items_to_ignore;
+ if (_item_to_ignore) { // If we have only a single item to ignore
+ // then build a list containing this single item;
+ // This single-item list will prevail over any other _items_to_ignore list, should that exist
+ items_to_ignore = new std::vector<SPItem const *>;
+ items_to_ignore->push_back(_item_to_ignore);
+ } else {
+ items_to_ignore = _items_to_ignore;
+ }
+
+ SnappedConstraints sc;
SnapperList const snappers = getSnappers();
for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); i++) {
- (*i)->constrainedSnap(sc, t, p, first_point, points_to_snap, c, it);
+ (*i)->constrainedSnap(sc, point_type, p, first_point, bbox_to_snap, constraint, items_to_ignore);
}
-
+
+ if (_item_to_ignore) {
+ delete items_to_ignore;
+ }
+
return findBestSnap(p, sc, true);
}
*
* \param type Type of points being snapped.
* \param points List of points to snap.
- * \param ignore List of items to ignore while snapping.
* \param constrained true if the snap is constrained.
* \param constraint Constraint line to use, if `constrained' is true, otherwise undefined.
* \param transformation_type Type of transformation to apply to points before trying to snap them.
Inkscape::SnappedPoint SnapManager::_snapTransformed(
Inkscape::Snapper::PointType type,
std::vector<NR::Point> const &points,
- std::vector<SPItem const *> const &ignore,
bool constrained,
Inkscape::Snapper::ConstraintLine const &constraint,
Transformation transformation_type,
}
std::vector<NR::Point> transformed_points;
+ NR::Rect bbox;
for (std::vector<NR::Point>::const_iterator i = points.begin(); i != points.end(); i++) {
}
// add the current transformed point to the box hulling all transformed points
+ if (i == points.begin()) {
+ bbox = NR::Rect(transformed, transformed);
+ } else {
+ bbox.expandTo(transformed);
+ }
+
transformed_points.push_back(transformed);
}
if (transformation_type == SCALE && !uniform) {
g_warning("Non-uniform constrained scaling is not supported!");
}
- snapped_point = constrainedSnap(type, *j, i == points.begin(), transformed_points, dedicated_constraint, ignore);
+ snapped_point = constrainedSnap(type, *j, dedicated_constraint, i == points.begin(), bbox);
} else {
- snapped_point = freeSnap(type, *j, i == points.begin(), transformed_points, ignore, NULL);
+ snapped_point = freeSnap(type, *j, i == points.begin(), bbox);
}
NR::Point result;
* Try to snap a list of points to any interested snappers after they have undergone
* a translation.
*
- * \param t Type of points.
+ * \param point_type Type of points.
* \param p Points.
- * \param it List of items to ignore when snapping.
* \param tr Proposed translation.
* \return Snapped translation, if a snap occurred, and a flag indicating whether a snap occurred.
*/
-Inkscape::SnappedPoint SnapManager::freeSnapTranslation(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::freeSnapTranslation(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::Point const &tr) const
{
- return _snapTransformed(t, p, it, false, NR::Point(), TRANSLATION, tr, NR::Point(), NR::X, false);
+ return _snapTransformed(point_type, p, false, NR::Point(), TRANSLATION, tr, NR::Point(), NR::X, false);
}
@@ -611,21 +554,19 @@ Inkscape::SnappedPoint SnapManager::freeSnapTranslation(Inkscape::Snapper::Point
* translation. A snap will only occur along a line described by a
* Inkscape::Snapper::ConstraintLine.
*
- * \param t Type of points.
+ * \param point_type Type of points.
* \param p Points.
- * \param it List of items to ignore when snapping.
- * \param c Constraint line.
+ * \param constraint Constraint line.
* \param tr Proposed translation.
* \return Snapped translation, if a snap occurred, and a flag indicating whether a snap occurred.
*/
-Inkscape::SnappedPoint SnapManager::constrainedSnapTranslation(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::constrainedSnapTranslation(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
- Inkscape::Snapper::ConstraintLine const &c,
+ Inkscape::Snapper::ConstraintLine const &constraint,
NR::Point const &tr) const
{
- return _snapTransformed(t, p, it, true, c, TRANSLATION, tr, NR::Point(), NR::X, false);
+ return _snapTransformed(point_type, p, true, constraint, TRANSLATION, tr, NR::Point(), NR::X, false);
}
@@ -633,21 +574,19 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapTranslation(Inkscape::Snapper
* Try to snap a list of points to any interested snappers after they have undergone
* a scale.
*
- * \param t Type of points.
+ * \param point_type Type of points.
* \param p Points.
- * \param it List of items to ignore when snapping.
* \param s Proposed scale.
* \param o Origin of proposed scale.
* \return Snapped scale, if a snap occurred, and a flag indicating whether a snap occurred.
*/
-Inkscape::SnappedPoint SnapManager::freeSnapScale(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::freeSnapScale(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::scale const &s,
NR::Point const &o) const
{
- return _snapTransformed(t, p, it, false, NR::Point(), SCALE, NR::Point(s[NR::X], s[NR::Y]), o, NR::X, false);
+ return _snapTransformed(point_type, p, false, NR::Point(), SCALE, NR::Point(s[NR::X], s[NR::Y]), o, NR::X, false);
}
@@ -656,22 +595,20 @@ Inkscape::SnappedPoint SnapManager::freeSnapScale(Inkscape::Snapper::PointType t
* a scale. A snap will only occur along a line described by a
* Inkscape::Snapper::ConstraintLine.
*
- * \param t Type of points.
+ * \param point_type Type of points.
* \param p Points.
- * \param it List of items to ignore when snapping.
* \param s Proposed scale.
* \param o Origin of proposed scale.
* \return Snapped scale, if a snap occurred, and a flag indicating whether a snap occurred.
*/
-Inkscape::SnappedPoint SnapManager::constrainedSnapScale(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::constrainedSnapScale(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::scale const &s,
NR::Point const &o) const
{
// When constrained scaling, only uniform scaling is supported.
- return _snapTransformed(t, p, it, true, NR::Point(), SCALE, NR::Point(s[NR::X], s[NR::Y]), o, NR::X, true);
+ return _snapTransformed(point_type, p, true, NR::Point(), SCALE, NR::Point(s[NR::X], s[NR::Y]), o, NR::X, true);
}
@@ -679,9 +616,8 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapScale(Inkscape::Snapper::Poin
* Try to snap a list of points to any interested snappers after they have undergone
* a stretch.
*
- * \param t Type of points.
+ * \param point_type Type of points.
* \param p Points.
- * \param it List of items to ignore when snapping.
* \param s Proposed stretch.
* \param o Origin of proposed stretch.
* \param d Dimension in which to apply proposed stretch.
@@ -689,15 +625,14 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapScale(Inkscape::Snapper::Poin
* \return Snapped stretch, if a snap occurred, and a flag indicating whether a snap occurred.
*/
-Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::Coord const &s,
NR::Point const &o,
NR::Dim2 d,
bool u) const
{
- return _snapTransformed(t, p, it, true, NR::Point(), STRETCH, NR::Point(s, s), o, d, u);
+ return _snapTransformed(point_type, p, true, NR::Point(), STRETCH, NR::Point(s, s), o, d, u);
}
@@ -705,23 +640,21 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(Inkscape::Snapper::Po
* Try to snap a list of points to any interested snappers after they have undergone
* a skew.
*
- * \param t Type of points.
+ * \param point_type Type of points.
* \param p Points.
- * \param it List of items to ignore when snapping.
* \param s Proposed skew.
* \param o Origin of proposed skew.
* \param d Dimension in which to apply proposed skew.
* \return Snapped skew, if a snap occurred, and a flag indicating whether a snap occurred.
*/
-Inkscape::SnappedPoint SnapManager::freeSnapSkew(Inkscape::Snapper::PointType t,
+Inkscape::SnappedPoint SnapManager::freeSnapSkew(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::Coord const &s,
NR::Point const &o,
NR::Dim2 d) const
{
- return _snapTransformed(t, p, it, false, NR::Point(), SKEW, NR::Point(s, s), o, d, false);
+ return _snapTransformed(point_type, p, false, NR::Point(), SKEW, NR::Point(s, s), o, d, false);
}
Inkscape::SnappedPoint SnapManager::findBestSnap(NR::Point const &p, SnappedConstraints &sc, bool constrained) const
@@ -821,9 +754,35 @@ Inkscape::SnappedPoint SnapManager::findBestSnap(NR::Point const &p, SnappedCons
}
}
+
+ // Update the snap indicator, if requested
+ if (_desktop_for_snapindicator) {
+ if (bestSnappedPoint.getSnapped()) {
+ _desktop_for_snapindicator->snapindicator->set_new_snappoint(bestSnappedPoint);
+ } else {
+ _desktop_for_snapindicator->snapindicator->remove_snappoint();
+ }
+ }
+
return bestSnappedPoint;
}
+void SnapManager::setup(SPDesktop const *desktop_for_snapindicator, SPItem const *item_to_ignore, std::vector<NR::Point> *unselected_nodes)
+{
+ _item_to_ignore = item_to_ignore;
+ _items_to_ignore = NULL;
+ _desktop_for_snapindicator = desktop_for_snapindicator;
+ _unselected_nodes = unselected_nodes;
+}
+
+void SnapManager::setup(SPDesktop const *desktop_for_snapindicator, std::vector<SPItem const *> &items_to_ignore, std::vector<NR::Point> *unselected_nodes)
+{
+ _item_to_ignore = NULL;
+ _items_to_ignore = &items_to_ignore;
+ _desktop_for_snapindicator = desktop_for_snapindicator;
+ _unselected_nodes = unselected_nodes;
+}
+
/*
Local Variables:
mode:c++
diff --git a/src/snap.h b/src/snap.h
index 0de8902f45daa676ffea026c2a965e112d76e5d6..f11b7c743ad45193d5bcdf0efd5cc36f1495b2f0 100644 (file)
--- a/src/snap.h
+++ b/src/snap.h
typedef std::list<const Inkscape::Snapper*> SnapperList;
bool SomeSnapperMightSnap() const;
-
- Inkscape::SnappedPoint freeSnap(Inkscape::Snapper::PointType t,
- NR::Point const &p,
- SPItem const *it,
- NR::Maybe<NR::Point> point_not_to_snap_to = NR::Nothing()) const;
-
- Inkscape::SnappedPoint freeSnap(Inkscape::Snapper::PointType t,
- NR::Point const &p,
- SPItem const *it,
- std::vector<NR::Point> *unselected_nodes) const;
- Inkscape::SnappedPoint freeSnap(Inkscape::Snapper::PointType t,
+ void setup(SPDesktop const *desktop_for_snapindicator = NULL, SPItem const *item_to_ignore = NULL, std::vector<NR::Point> *unselected_nodes = NULL);
+ void setup(SPDesktop const *desktop_for_snapindicator, std::vector<SPItem const *> &items_to_ignore, std::vector<NR::Point> *unselected_nodes = NULL);
+
+ Inkscape::SnappedPoint freeSnap(Inkscape::Snapper::PointType point_type,
NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
- std::vector<NR::Point> *unselected_nodes) const;
+ bool first_point = true,
+ NR::Maybe<NR::Rect> const &bbox_to_snap = NR::Nothing()) const;
- Inkscape::SnappedPoint constrainedSnap(Inkscape::Snapper::PointType t,
+ Inkscape::SnappedPoint constrainedSnap(Inkscape::Snapper::PointType point_type,
NR::Point const &p,
- Inkscape::Snapper::ConstraintLine const &c,
- SPItem const *it) const;
-
- Inkscape::SnappedPoint constrainedSnap(Inkscape::Snapper::PointType t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- Inkscape::Snapper::ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const;
+ Inkscape::Snapper::ConstraintLine const &constraint,
+ bool first_point = true,
+ NR::Maybe<NR::Rect> const &bbox_to_snap = NR::Nothing()) const;
Inkscape::SnappedPoint guideSnap(NR::Point const &p,
NR::Point const &guide_normal) const;
- Inkscape::SnappedPoint freeSnapTranslation(Inkscape::Snapper::PointType t,
+ Inkscape::SnappedPoint freeSnapTranslation(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::Point const &tr) const;
- Inkscape::SnappedPoint constrainedSnapTranslation(Inkscape::Snapper::PointType t,
+ Inkscape::SnappedPoint constrainedSnapTranslation(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
- Inkscape::Snapper::ConstraintLine const &c,
+ Inkscape::Snapper::ConstraintLine const &constraint,
NR::Point const &tr) const;
- Inkscape::SnappedPoint freeSnapScale(Inkscape::Snapper::PointType t,
+ Inkscape::SnappedPoint freeSnapScale(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::scale const &s,
NR::Point const &o) const;
- Inkscape::SnappedPoint constrainedSnapScale(Inkscape::Snapper::PointType t,
+ Inkscape::SnappedPoint constrainedSnapScale(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::scale const &s,
NR::Point const &o) const;
- Inkscape::SnappedPoint constrainedSnapStretch(Inkscape::Snapper::PointType t,
+ Inkscape::SnappedPoint constrainedSnapStretch(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::Coord const &s,
NR::Point const &o,
NR::Dim2 d,
bool uniform) const;
- Inkscape::SnappedPoint freeSnapSkew(Inkscape::Snapper::PointType t,
+ Inkscape::SnappedPoint freeSnapSkew(Inkscape::Snapper::PointType point_type,
std::vector<NR::Point> const &p,
- std::vector<SPItem const *> const &it,
NR::Coord const &s,
NR::Point const &o,
NR::Dim2 d) const;
- Inkscape::SnappedPoint guideSnap(NR::Point const &p,
- Inkscape::ObjectSnapper::DimensionToSnap const snap_dim) const;
+ //Inkscape::SnappedPoint guideSnap(NR::Point const &p,
+ // Inkscape::ObjectSnapper::DimensionToSnap const snap_dim) const;
Inkscape::GuideSnapper guide; ///< guide snapper
void setSnapIntersectionGG(bool enabled) {_intersectionGG = enabled;}
void setSnapIntersectionLS(bool enabled) {_intersectionLS = enabled;}
- bool getSnapIntersectionGG() { return _intersectionGG;}
- bool getSnapIntersectionLS() { return _intersectionLS;}
+ bool getSnapIntersectionGG() {return _intersectionGG;}
+ bool getSnapIntersectionLS() {return _intersectionLS;}
void setIncludeItemCenter(bool enabled) {
_include_item_center = enabled;
bool _intersectionLS;
bool _snap_enabled_globally; //Toggles ALL snapping
+ std::vector<SPItem const *> *_items_to_ignore;
+ SPItem const *_item_to_ignore;
+ SPDesktop const *_desktop_for_snapindicator;
+ std::vector<NR::Point> *_unselected_nodes;
+
Inkscape::SnappedPoint _snapTransformed(Inkscape::Snapper::PointType type,
std::vector<NR::Point> const &points,
- std::vector<SPItem const *> const &ignore,
bool constrained,
Inkscape::Snapper::ConstraintLine const &constraint,
Transformation transformation_type,
diff --git a/src/snapper.cpp b/src/snapper.cpp
index 803506e7641d88c6468541200b5433546b582ef9..4dfb9042e6f74c710e78f7454bc3c2003fcfb37e 100644 (file)
--- a/src/snapper.cpp
+++ b/src/snapper.cpp
_snap_enabled = s;
}
-
-/**
- * Try to snap a point to whatever this snapper is interested in. Any
- * snap that occurs will be to the nearest "interesting" thing (e.g. a
- * grid or guide line)
- *
- * \param t Point type.
- * \param p Point to snap (desktop coordinates).
- * \param it Item that should not be snapped to.
- * \return Snapped point.
- */
-
-void Inkscape::Snapper::freeSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- SPItem const *it) const
-{
- std::vector<SPItem const *> lit;
- if (it) {
- lit.push_back(it);
- }
-
- freeSnap(sc, t, p, first_point, points_to_snap, lit, NULL);
-}
-
-/**
- * Try to snap a point to whatever this snapper is interested in. Any
- * snap that occurs will be to the nearest "interesting" thing (e.g. a
- * grid or guide line)
- *
- * \param t Point type.
- * \param p Point to snap (desktop coordinates).
- * \param it Items that should not be snapped to.
- * \return Snapped point.
- */
-
-void Inkscape::Snapper::freeSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
- std::vector<NR::Point> *unselected_nodes) const
-{
- if (_snap_enabled == false || getSnapFrom(t) == false) {
- return;
- }
-
- _doFreeSnap(sc, t, p, first_point, points_to_snap, it, unselected_nodes);
-}
-
-
-
-
-/**
- * Try to snap a point to whatever this snapper is interested in, where
- * the snap point is constrained to lie along a specified vector from the
- * original point.
- *
- * \param p Point to snap (desktop coordinates).
- * \param c Vector to constrain the snap to.
- * \param it Items that should not be snapped to.
- * \return Snapped point.
- */
-
-void Inkscape::Snapper::constrainedSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- ConstraintLine const &c,
- SPItem const *it) const
-{
- std::vector<SPItem const *> lit;
- if (it) {
- lit.push_back(it);
- }
- constrainedSnap(sc, t, p, first_point, points_to_snap, c, lit);
-}
-
-
-/**
- * Try to snap a point to whatever this snapper is interested in, where
- * the snap point is constrained to lie along a specified vector from the
- * original point.
- *
- * \param p Point to snap (desktop coordinates).
- * \param c Vector to constrain the snap to.
- * \param it Items that should not be snapped to.
- * \return Snapped point.
- */
-
-void Inkscape::Snapper::constrainedSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const
-{
- if (_snap_enabled == false || getSnapFrom(t) == false) {
- return;
- }
-
- _doConstrainedSnap(sc, t, p, first_point, points_to_snap, c, it);
-}
-
/*
Local Variables:
mode:c++
diff --git a/src/snapper.h b/src/snapper.h
index cad4200ab6e0e237c72af4c8ef9f7e8fa782ed78..533a3909090f973e1e553cfb3fffc870f33a6f01 100644 (file)
--- a/src/snapper.h
+++ b/src/snapper.h
void setEnabled(bool s);
bool getEnabled() const {return _snap_enabled;}
- void freeSnap(SnappedConstraints &sc,
+ virtual void freeSnap(SnappedConstraints &sc,
PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- SPItem const *it) const;
-
- void freeSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- std::vector<SPItem const *> const &it,
- std::vector<NR::Point> *unselected_nodes) const;
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
+ std::vector<SPItem const *> const *it,
+ std::vector<NR::Point> *unselected_nodes) const {};
class ConstraintLine
{
NR::Point _direction;
};
- void constrainedSnap(SnappedConstraints &sc,
- PointType const &t,
- NR::Point const &p,
- bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
- ConstraintLine const &c,
- SPItem const *it) const;
-
- void constrainedSnap(SnappedConstraints &sc,
+ virtual void constrainedSnap(SnappedConstraints &sc,
PointType const &t,
NR::Point const &p,
bool const &first_point,
- std::vector<NR::Point> &points_to_snap,
+ NR::Maybe<NR::Rect> const &bbox_to_snap,
ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const;
+ std::vector<SPItem const *> const *it) const {};
protected:
SPNamedView const *_named_view;
// must be private to enforce the usage of getTolerance(), which retrieves
// the tolerance in screen pixels (making it zoom independent)
-
- /**
- * Try to snap a point to whatever this snapper is interested in. Any
- * snap that occurs will be to the nearest "interesting" thing (e.g. a
- * grid or guide line)
- *
- * \param p Point to snap (desktop coordinates).
- * \param it Items that should not be snapped to.
- * \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,
- std::vector<SPItem const *> const &it,
- std::vector<NR::Point> *unselected_nodes) const = 0;
-
- /**
- * Try to snap a point to whatever this snapper is interested in, where
- * the snap point is constrained to lie along a specified vector from the
- * original point.
- *
- * \param p Point to snap (desktop coordinates).
- * \param c Vector to constrain the snap to.
- * \param it Items that should not be snapped to.
- * \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,
- ConstraintLine const &c,
- std::vector<SPItem const *> const &it) const = 0;
};
}
diff --git a/src/spiral-context.cpp b/src/spiral-context.cpp
index d0404c3d024f37ce790151d6bf77ea7c5314ee37..a4c402f407b3f81fb5f98ebf38cda8c7ef1a6f5e 100644 (file)
--- a/src/spiral-context.cpp
+++ b/src/spiral-context.cpp
dragging = TRUE;
sc->center = Inkscape::setup_for_drag_start(desktop, event_context, event);
- SnapManager const &m = desktop->namedview->snap_manager;
- sc->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, sc->center, sc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, sc->item);
+ sc->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, sc->center).getPoint();
sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
( GDK_KEY_PRESS_MASK |
NR::Point const motion_w(event->motion.x, event->motion.y);
NR::Point motion_dt(event_context->desktop->w2d(motion_w));
- SnapManager const &m = desktop->namedview->snap_manager;
- motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt, sc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, sc->item);
+ motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt).getPoint();
sp_spiral_drag(sc, motion_dt, event->motion.state);
gobble_motion_events(GDK_BUTTON1_MASK);
NR::Point const p0 = sp_desktop_dt2root_xy_point(desktop, sc->center);
NR::Point p1 = sp_desktop_dt2root_xy_point(desktop, p);
- SnapManager const &m = desktop->namedview->snap_manager;
- p1 = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p1, sc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, sc->item);
+ p1 = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p1).getPoint();
SPSpiral *spiral = SP_SPIRAL(sc->item);
diff --git a/src/star-context.cpp b/src/star-context.cpp
index cee03b4b1fbea8906f704cb7b470ab38631d9dea..816e6b7793871d100a98d33d0a20c2d286c199c9 100644 (file)
--- a/src/star-context.cpp
+++ b/src/star-context.cpp
@@ -280,8 +280,9 @@ static gint sp_star_context_root_handler(SPEventContext *event_context, GdkEvent
sc->center = Inkscape::setup_for_drag_start(desktop, event_context, event);
- SnapManager const &m = desktop->namedview->snap_manager;
- sc->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, sc->center, sc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, sc->item);
+ sc->center = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, sc->center).getPoint();
sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
GDK_KEY_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
@@ -306,8 +307,9 @@ static gint sp_star_context_root_handler(SPEventContext *event_context, GdkEvent
NR::Point const motion_w(event->motion.x, event->motion.y);
NR::Point motion_dt(event_context->desktop->w2d(motion_w));
- SnapManager const &m = desktop->namedview->snap_manager;
- motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt, sc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, sc->item);
+ motion_dt = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, motion_dt).getPoint();
sp_star_drag (sc, motion_dt, event->motion.state);
NR::Point p1 = sp_desktop_dt2root_xy_point(desktop, p);
/* Snap corner point with no constraints */
- SnapManager const &m = desktop->namedview->snap_manager;
- p1 = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p1, sc->item).getPoint();
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, sc->item);
+ p1 = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, p1).getPoint();
SPStar *star = SP_STAR(sc->item);