X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fui%2Ftool%2Fnode.cpp;h=a79a5c409ce9a847991593631e8d3466edccacf0;hb=4a02a8d1cbfb847a89e8bb5b6a32479036044b30;hp=f2bec1f5ffb3fa5a7295df47ce293886f428707d;hpb=f200d31b8a03050faa7243929bbd5698db488399;p=inkscape.git diff --git a/src/ui/tool/node.cpp b/src/ui/tool/node.cpp index f2bec1f5f..a79a5c409 100644 --- a/src/ui/tool/node.cpp +++ b/src/ui/tool/node.cpp @@ -77,6 +77,7 @@ static Geom::Point direction(Geom::Point const &first, Geom::Point const &second * Keeping the invariant on node moves is left to the %Node class. */ +Geom::Point Handle::_saved_other_pos(0, 0); double Handle::_saved_length = 0.0; bool Handle::_drag_out = false; @@ -89,20 +90,10 @@ Handle::Handle(NodeSharedData const &data, Geom::Point const &initial_pos, Node _cset = &handle_colors; _handle_line = sp_canvas_item_new(data.handle_line_group, SP_TYPE_CTRLLINE, NULL); setVisible(false); - signal_grabbed.connect( - sigc::bind_return( - sigc::hide( - sigc::mem_fun(*this, &Handle::_grabbedHandler)), - false)); - signal_dragged.connect( - sigc::hide<0>( - sigc::mem_fun(*this, &Handle::_draggedHandler))); - signal_ungrabbed.connect( - sigc::hide(sigc::mem_fun(*this, &Handle::_ungrabbedHandler))); } Handle::~Handle() { - sp_canvas_item_hide(_handle_line); + //sp_canvas_item_hide(_handle_line); gtk_object_destroy(GTK_OBJECT(_handle_line)); } @@ -115,30 +106,36 @@ void Handle::setVisible(bool v) void Handle::move(Geom::Point const &new_pos) { - Handle *other, *towards, *towards_second; - Node *node_towards; // node in direction of this handle - Node *node_away; // node in the opposite direction - if (this == &_parent->_front) { - other = &_parent->_back; - node_towards = _parent->_next(); - node_away = _parent->_prev(); - towards = node_towards ? &node_towards->_back : 0; - towards_second = node_towards ? &node_towards->_front : 0; - } else { - other = &_parent->_front; - node_towards = _parent->_prev(); - node_away = _parent->_next(); - towards = node_towards ? &node_towards->_front : 0; - towards_second = node_towards ? &node_towards->_back : 0; - } + Handle *other = this->other(); + Node *node_towards = _parent->nodeToward(this); // node in direction of this handle + Node *node_away = _parent->nodeAwayFrom(this); // node in the opposite direction + Handle *towards = node_towards ? node_towards->handleAwayFrom(_parent) : NULL; + Handle *towards_second = node_towards ? node_towards->handleToward(_parent) : NULL; if (Geom::are_near(new_pos, _parent->position())) { - // The handle becomes degenerate. If the segment between it and the node + // The handle becomes degenerate. + // Adjust node type as necessary. + if (other->isDegenerate()) { + // If both handles become degenerate, convert to parent cusp node + _parent->setType(NODE_CUSP, false); + } else { + // Only 1 handle becomes degenerate + switch (_parent->type()) { + case NODE_AUTO: + case NODE_SYMMETRIC: + _parent->setType(NODE_SMOOTH, false); + break; + default: + // do nothing for other node types + break; + } + } + // If the segment between the handle and the node // in its direction becomes linear and there are smooth nodes // at its ends, make their handles colinear with the segment - if (towards && towards->isDegenerate()) { + if (towards && towards_second->isDegenerate()) { if (node_towards->type() == NODE_SMOOTH) { - towards_second->setDirection(*_parent, *node_towards); + towards->setDirection(*_parent, *node_towards); } if (_parent->type() == NODE_SMOOTH) { other->setDirection(*node_towards, *_parent); @@ -180,6 +177,7 @@ void Handle::move(Geom::Point const &new_pos) void Handle::setPosition(Geom::Point const &p) { + Geom::Point old_pos = position(); ControlPoint::setPosition(p); sp_ctrlline_set_coords(SP_CTRLLINE(_handle_line), _parent->position(), position()); @@ -187,15 +185,12 @@ void Handle::setPosition(Geom::Point const &p) if (Geom::are_near(position(), _parent->position())) _degenerate = true; else _degenerate = false; + if (_parent->_handles_shown && _parent->visible() && !_degenerate) { setVisible(true); } else { setVisible(false); } - // If both handles become degenerate, convert to parent cusp node - if (_parent->isDegenerate()) { - _parent->setType(NODE_CUSP, false); - } } void Handle::setLength(double len) @@ -207,7 +202,7 @@ void Handle::setLength(double len) void Handle::retract() { - setPosition(_parent->position()); + move(_parent->position()); } void Handle::setDirection(Geom::Point const &from, Geom::Point const &to) @@ -232,33 +227,106 @@ char const *Handle::handle_type_to_localized_string(NodeType type) } } -void Handle::_grabbedHandler() +bool Handle::grabbed(GdkEventMotion *) { + _saved_other_pos = other()->position(); _saved_length = _drag_out ? 0 : length(); + _pm()._handleGrabbed(); + return false; } -void Handle::_draggedHandler(Geom::Point &new_pos, GdkEventMotion *event) +void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event) { Geom::Point parent_pos = _parent->position(); + Geom::Point origin = _last_drag_origin(); + SnapManager &sm = _desktop->namedview->snap_manager; + bool snap = sm.someSnapperMightSnap(); + boost::optional ctrl_constraint; + // with Alt, preserve length if (held_alt(*event)) { new_pos = parent_pos + Geom::unit_vector(new_pos - parent_pos) * _saved_length; + snap = false; } - // with Ctrl, constrain to M_PI/rotationsnapsperpi increments. + // with Ctrl, constrain to M_PI/rotationsnapsperpi increments from vertical + // and the original position. if (held_control(*event)) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); int snaps = 2 * prefs->getIntLimited("/options/rotationsnapsperpi/value", 12, 1, 1000); - Geom::Point origin = _last_drag_origin(); - Geom::Point rel_origin = origin - parent_pos; - new_pos = parent_pos + Geom::constrain_angle(Geom::Point(0,0), new_pos - parent_pos, snaps, - _drag_out ? Geom::Point(1,0) : Geom::unit_vector(rel_origin)); + + // note: if snapping to the original position is only desired in the original + // direction of the handle, change to Ray instead of Line + Geom::Line original_line(parent_pos, origin); + Geom::Line perp_line(parent_pos, parent_pos + Geom::rot90(origin - parent_pos)); + Geom::Point snap_pos = parent_pos + Geom::constrain_angle( + Geom::Point(0,0), new_pos - parent_pos, snaps, Geom::Point(1,0)); + Geom::Point orig_pos = original_line.pointAt(original_line.nearestPoint(new_pos)); + Geom::Point perp_pos = perp_line.pointAt(perp_line.nearestPoint(new_pos)); + + Geom::Point result = snap_pos; + ctrl_constraint = Inkscape::Snapper::SnapConstraint(parent_pos, parent_pos - snap_pos); + if (Geom::distance(orig_pos, new_pos) < Geom::distance(result, new_pos)) { + result = orig_pos; + ctrl_constraint = Inkscape::Snapper::SnapConstraint(parent_pos, parent_pos - orig_pos); + } + if (Geom::distance(perp_pos, new_pos) < Geom::distance(result, new_pos)) { + result = perp_pos; + ctrl_constraint = Inkscape::Snapper::SnapConstraint(parent_pos, parent_pos - perp_pos); + } + new_pos = result; + } + + std::vector unselected; + if (snap) { + typedef ControlPointSelection::Set Set; + Set &nodes = _parent->_selection.allPoints(); + for (Set::iterator i = nodes.begin(); i != nodes.end(); ++i) { + Node *n = static_cast(*i); + Inkscape::SnapCandidatePoint p(n->position(), n->_snapSourceType(), n->_snapTargetType()); + unselected.push_back(p); + } + sm.setupIgnoreSelection(_desktop, true, &unselected); + + Node *node_away = _parent->nodeAwayFrom(this); + if (_parent->type() == NODE_SMOOTH && Node::_is_line_segment(_parent, node_away)) { + Inkscape::Snapper::SnapConstraint cl(_parent->position(), + _parent->position() - node_away->position()); + Inkscape::SnappedPoint p; + p = sm.constrainedSnap(Inkscape::SnapCandidatePoint(new_pos, SNAPSOURCE_NODE_HANDLE), cl); + new_pos = p.getPoint(); + } else if (ctrl_constraint) { + // NOTE: this is subtly wrong. + // We should get all possible constraints and snap along them using + // multipleConstrainedSnaps, instead of first snapping to angle and the to objects + Inkscape::SnappedPoint p; + p = sm.constrainedSnap(Inkscape::SnapCandidatePoint(new_pos, SNAPSOURCE_NODE_HANDLE), *ctrl_constraint); + new_pos = p.getPoint(); + } else { + sm.freeSnapReturnByRef(new_pos, SNAPSOURCE_NODE_HANDLE); + } + sm.unSetup(); + } + + + // with Shift, if the node is cusp, rotate the other handle as well + if (_parent->type() == NODE_CUSP && !_drag_out) { + if (held_shift(*event)) { + Geom::Point other_relpos = _saved_other_pos - parent_pos; + other_relpos *= Geom::Rotate(Geom::angle_between(origin - parent_pos, new_pos - parent_pos)); + other()->setRelativePos(other_relpos); + } else { + // restore the position + other()->setPosition(_saved_other_pos); + } } - signal_update.emit(); + move(new_pos); // needed for correct update, even though it's redundant + _pm().update(); } -void Handle::_ungrabbedHandler() +void Handle::ungrabbed(GdkEventButton *event) { // hide the handle if it's less than dragtolerance away from the node + // TODO is this actually desired? Inkscape::Preferences *prefs = Inkscape::Preferences::get(); int drag_tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100); @@ -266,7 +334,27 @@ void Handle::_ungrabbedHandler() if (dist.length() <= drag_tolerance) { move(_parent->position()); } + + // HACK: If the handle was dragged out, call parent's ungrabbed handler, + // so that transform handles reappear + if (_drag_out) { + _parent->ungrabbed(event); + } _drag_out = false; + + _pm()._handleUngrabbed(); +} + +bool Handle::clicked(GdkEventButton *event) +{ + _pm()._handleClicked(this, event); + return true; +} + +Handle *Handle::other() +{ + if (this == &_parent->_front) return &_parent->_back; + return &_parent->_front; } static double snap_increment_degrees() { @@ -277,29 +365,59 @@ static double snap_increment_degrees() { Glib::ustring Handle::_getTip(unsigned state) { + char const *more; + bool can_shift_rotate = _parent->type() == NODE_CUSP && !other()->isDegenerate(); + if (can_shift_rotate) { + more = C_("Path handle tip", "more: Shift, Ctrl, Alt"); + } else { + more = C_("Path handle tip", "more: Ctrl, Alt"); + } if (state_held_alt(state)) { if (state_held_control(state)) { - return format_tip(C_("Path handle tip", - "Ctrl+Alt: preserve length and snap rotation angle to %f° increments"), - snap_increment_degrees()); + if (state_held_shift(state) && can_shift_rotate) { + return format_tip(C_("Path handle tip", + "Shift+Ctrl+Alt: preserve length and snap rotation angle to %g° " + "increments while rotating both handles"), + snap_increment_degrees()); + } else { + return format_tip(C_("Path handle tip", + "Ctrl+Alt: preserve length and snap rotation angle to %g° increments"), + snap_increment_degrees()); + } } else { - return C_("Path handle tip", - "Alt: preserve handle length while dragging"); + if (state_held_shift(state) && can_shift_rotate) { + return C_("Path handle tip", + "Shift+Alt: preserve handle length and rotate both handles"); + } else { + return C_("Path handle tip", + "Alt: preserve handle length while dragging"); + } } } else { if (state_held_control(state)) { - return format_tip(C_("Path handle tip", - "Ctrl: snap rotation angle to %f° increments, click to retract"), - snap_increment_degrees()); + if (state_held_shift(state) && can_shift_rotate) { + return format_tip(C_("Path handle tip", + "Shift+Ctrl: snap rotation angle to %g° increments and rotate both handles"), + snap_increment_degrees()); + } else { + return format_tip(C_("Path handle tip", + "Ctrl: snap rotation angle to %g° increments, click to retract"), + snap_increment_degrees()); + } + } else if (state_held_shift(state) && can_shift_rotate) { + return C_("Path hande tip", + "Shift: rotate both handles by the same angle"); } } + switch (_parent->type()) { case NODE_AUTO: - return C_("Path handle tip", - "Auto node handle: drag to convert to smooth node"); + return format_tip(C_("Path handle tip", + "Auto node handle: drag to convert to smooth node (%s)"), more); default: - return format_tip(C_("Path handle tip", "%s: drag to shape the curve"), - handle_type_to_localized_string(_parent->type())); + return format_tip(C_("Path handle tip", + "%s: drag to shape the segment (%s)"), + handle_type_to_localized_string(_parent->type()), more); } } @@ -314,7 +432,7 @@ Glib::ustring Handle::_getDragTip(GdkEventMotion */*event*/) GString *y = SP_PX_TO_METRIC_STRING(dist[Geom::Y], _desktop->namedview->getDefaultMetric()); GString *len = SP_PX_TO_METRIC_STRING(length(), _desktop->namedview->getDefaultMetric()); Glib::ustring ret = format_tip(C_("Path handle tip", - "Move by %s, %s; angle %.2f°, length %s"), x->str, y->str, angle, len->str); + "Move handle by %s, %s; angle %.2f°, length %s"), x->str, y->str, angle, len->str); g_string_free(x, TRUE); g_string_free(y, TRUE); g_string_free(len, TRUE); @@ -337,11 +455,6 @@ Node::Node(NodeSharedData const &data, Geom::Point const &initial_pos) , _handles_shown(false) { // NOTE we do not set type here, because the handles are still degenerate - // connect to own grabbed signal - dragging out handles - signal_grabbed.connect( - sigc::mem_fun(*this, &Node::_grabbedHandler)); - signal_dragged.connect( sigc::hide<0>( - sigc::mem_fun(*this, &Node::_draggedHandler))); } // NOTE: not using iterators won't make this much quicker because iterators can be 100% inlined. @@ -485,11 +598,7 @@ void Node::setType(NodeType type, bool update_handles) if (update_handles) { switch (type) { case NODE_CUSP: - // if the existing type is also NODE_CUSP, retract handles - if (_type == NODE_CUSP) { - _front.retract(); - _back.retract(); - } + // nothing to do break; case NODE_AUTO: // auto handles make no sense for endnodes @@ -497,11 +606,24 @@ void Node::setType(NodeType type, bool update_handles) _updateAutoHandles(); break; case NODE_SMOOTH: { + // ignore attempts to make smooth endnodes. + if (isEndNode()) return; // rotate handles to be colinear // for degenerate nodes set positions like auto handles bool prev_line = _is_line_segment(_prev(), this); bool next_line = _is_line_segment(this, _next()); - if (isDegenerate()) { + if (_type == NODE_SMOOTH) { + // For a node that is already smooth and has a degenerate handle, + // drag out the second handle without changing the direction of the first one. + if (_front.isDegenerate()) { + double dist = Geom::distance(_next()->position(), position()); + _front.setRelativePos(Geom::unit_vector(-_back.relativePos()) * dist / 3); + } + if (_back.isDegenerate()) { + double dist = Geom::distance(_prev()->position(), position()); + _back.setRelativePos(Geom::unit_vector(-_front.relativePos()) * dist / 3); + } + } else if (isDegenerate()) { _updateAutoHandles(); } else if (_front.isDegenerate()) { // if the front handle is degenerate and this...next is a line segment, @@ -511,14 +633,14 @@ void Node::setType(NodeType type, bool update_handles) _back.setDirection(*_next(), *this); } else if (_prev()) { Geom::Point dir = direction(_back, *this); - _front.setRelativePos((_prev()->position() - position()).length() / 3 * dir); + _front.setRelativePos(Geom::distance(_prev()->position(), position()) / 3 * dir); } } else if (_back.isDegenerate()) { if (prev_line) { _front.setDirection(*_prev(), *this); } else if (_next()) { Geom::Point dir = direction(_front, *this); - _back.setRelativePos((_next()->position() - position()).length() / 3 * dir); + _back.setRelativePos(Geom::distance(_next()->position(), position()) / 3 * dir); } } else { // both handles are extended. make colinear while keeping length @@ -636,8 +758,7 @@ NodeType Node::parse_nodetype(char x) /** Customized event handler to catch scroll events needed for selection grow/shrink. */ bool Node::_eventHandler(GdkEvent *event) { - static NodeList::iterator origin; - static int dir; + int dir = 0; switch (event->type) { @@ -648,14 +769,34 @@ bool Node::_eventHandler(GdkEvent *event) dir = -1; } else break; if (held_control(event->scroll)) { - _selection.spatialGrow(this, dir); + _linearGrow(dir); } else { + _selection.spatialGrow(this, dir); + } + return true; + case GDK_KEY_PRESS: + switch (shortcut_key(event->key)) + { + case GDK_Page_Up: + dir = 1; + break; + case GDK_Page_Down: + dir = -1; + break; + default: goto bail_out; + } + + if (held_control(event->key)) { _linearGrow(dir); + } else { + _selection.spatialGrow(this, dir); } return true; default: break; } + + bail_out: return ControlPoint::_eventHandler(event); } @@ -807,8 +948,11 @@ void Node::_setState(State state) SelectableControlPoint::_setState(state); } -bool Node::_grabbedHandler(GdkEventMotion *event) +bool Node::grabbed(GdkEventMotion *event) { + if (SelectableControlPoint::grabbed(event)) + return true; + // Dragging out handles with Shift + drag on a node. if (!held_shift(*event)) return false; @@ -843,11 +987,19 @@ bool Node::_grabbedHandler(GdkEventMotion *event) return true; } -void Node::_draggedHandler(Geom::Point &new_pos, GdkEventMotion *event) +void Node::dragged(Geom::Point &new_pos, GdkEventMotion *event) { // For a note on how snapping is implemented in Inkscape, see snap.h. SnapManager &sm = _desktop->namedview->snap_manager; - bool snap = sm.someSnapperMightSnap(); + // even if we won't really snap, we might still call the one of the + // constrainedSnap() methods to enforce the constraints, so we need + // to setup the snapmanager anyway; this is also required for someSnapperMightSnap() + sm.setup(_desktop); + + // do not snap when Shift is pressed + bool snap = !held_shift(*event) && sm.someSnapperMightSnap(); + + Inkscape::SnappedPoint sp; std::vector unselected; if (snap) { /* setup @@ -859,7 +1011,7 @@ void Node::_draggedHandler(Geom::Point &new_pos, GdkEventMotion *event) // Build the list of unselected nodes. typedef ControlPointSelection::Set Set; - Set nodes = _selection.allPoints(); + Set &nodes = _selection.allPoints(); for (Set::iterator i = nodes.begin(); i != nodes.end(); ++i) { if (!(*i)->selected()) { Node *n = static_cast(*i); @@ -867,61 +1019,81 @@ void Node::_draggedHandler(Geom::Point &new_pos, GdkEventMotion *event) unselected.push_back(p); } } + sm.unSetup(); sm.setupIgnoreSelection(_desktop, true, &unselected); } if (held_control(*event)) { Geom::Point origin = _last_drag_origin(); + std::vector constraints; if (held_alt(*event)) { // with Ctrl+Alt, constrain to handle lines - // project the new position onto a handle line that is closer - Inkscape::Snapper::ConstraintLine line_front(origin, _front.relativePos()); - Inkscape::Snapper::ConstraintLine line_back(origin, _back.relativePos()); - - // TODO: combine these two branches by modifying snap.h / snap.cpp - if (snap) { - Inkscape::SnappedPoint fp, bp; - fp = sm.constrainedSnap(Inkscape::SnapCandidatePoint(position(), _snapSourceType()), line_front); - bp = sm.constrainedSnap(Inkscape::SnapCandidatePoint(position(), _snapSourceType()), line_back); - - if (fp.isOtherSnapBetter(bp, false)) { - bp.getPoint(new_pos); - } else { - fp.getPoint(new_pos); - } + // project the new position onto a handle line that is closer; + // also snap to perpendiculars of handle lines + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + int snaps = prefs->getIntLimited("/options/rotationsnapsperpi/value", 12, 1, 1000); + double min_angle = M_PI / snaps; + + boost::optional front_point, back_point, fperp_point, bperp_point; + if (_front.isDegenerate()) { + if (_is_line_segment(this, _next())) + front_point = _next()->position() - origin; } else { - Geom::Point p_front = line_front.projection(new_pos); - Geom::Point p_back = line_back.projection(new_pos); - if (Geom::distance(new_pos, p_front) < Geom::distance(new_pos, p_back)) { - new_pos = p_front; - } else { - new_pos = p_back; - } + front_point = _front.relativePos(); } - } else { - // with Ctrl, constrain to axes - // TODO combine the two branches - if (snap) { - Inkscape::SnappedPoint fp, bp; - Inkscape::Snapper::ConstraintLine line_x(origin, Geom::Point(1, 0)); - Inkscape::Snapper::ConstraintLine line_y(origin, Geom::Point(0, 1)); - fp = sm.constrainedSnap(Inkscape::SnapCandidatePoint(position(), _snapSourceType()), line_x); - bp = sm.constrainedSnap(Inkscape::SnapCandidatePoint(position(), _snapSourceType()), line_y); - - if (fp.isOtherSnapBetter(bp, false)) { - fp = bp; - } - fp.getPoint(new_pos); + if (_back.isDegenerate()) { + if (_is_line_segment(_prev(), this)) + back_point = _prev()->position() - origin; } else { - Geom::Point origin = _last_drag_origin(); - Geom::Point delta = new_pos - origin; - Geom::Dim2 d = (fabs(delta[Geom::X]) < fabs(delta[Geom::Y])) ? Geom::X : Geom::Y; - new_pos[d] = origin[d]; + back_point = _back.relativePos(); + } + if (front_point) { + constraints.push_back(Inkscape::Snapper::SnapConstraint(origin, *front_point)); + fperp_point = Geom::rot90(*front_point); + } + if (back_point) { + constraints.push_back(Inkscape::Snapper::SnapConstraint(origin, *back_point)); + bperp_point = Geom::rot90(*back_point); + } + // perpendiculars only snap when they are further than snap increment away + // from the second handle constraint + if (fperp_point && (!back_point || + (fabs(Geom::angle_between(*fperp_point, *back_point)) > min_angle && + fabs(Geom::angle_between(*fperp_point, *back_point)) < M_PI - min_angle))) + { + constraints.push_back(Inkscape::Snapper::SnapConstraint(origin, *fperp_point)); + } + if (bperp_point && (!front_point || + (fabs(Geom::angle_between(*bperp_point, *front_point)) > min_angle && + fabs(Geom::angle_between(*bperp_point, *front_point)) < M_PI - min_angle))) + { + constraints.push_back(Inkscape::Snapper::SnapConstraint(origin, *bperp_point)); } + + sp = sm.multipleConstrainedSnaps(Inkscape::SnapCandidatePoint(new_pos, _snapSourceType()), constraints, held_shift(*event)); + } else { + // with Ctrl, constrain to axes + constraints.push_back(Inkscape::Snapper::SnapConstraint(origin, Geom::Point(1, 0))); + constraints.push_back(Inkscape::Snapper::SnapConstraint(origin, Geom::Point(0, 1))); + sp = sm.multipleConstrainedSnaps(Inkscape::SnapCandidatePoint(new_pos, _snapSourceType()), constraints, held_shift(*event)); } + new_pos = sp.getPoint(); } else if (snap) { - sm.freeSnapReturnByRef(new_pos, _snapSourceType()); + sp = sm.freeSnap(Inkscape::SnapCandidatePoint(new_pos, _snapSourceType())); + new_pos = sp.getPoint(); } + + sm.unSetup(); + + SelectableControlPoint::dragged(new_pos, event); +} + +bool Node::clicked(GdkEventButton *event) +{ + if(_pm()._nodeClicked(this, event)) + return true; + return SelectableControlPoint::clicked(event); } Inkscape::SnapSourceType Node::_snapSourceType() @@ -937,33 +1109,98 @@ Inkscape::SnapTargetType Node::_snapTargetType() return SNAPTARGET_NODE_CUSP; } +/** @brief Gets the handle that faces the given adjacent node. + * Will abort with error if the given node is not adjacent. */ +Handle *Node::handleToward(Node *to) +{ + if (_next() == to) { + return front(); + } + if (_prev() == to) { + return back(); + } + g_error("Node::handleToward(): second node is not adjacent!"); +} + +/** @brief Gets the node in the direction of the given handle. + * Will abort with error if the handle doesn't belong to this node. */ +Node *Node::nodeToward(Handle *dir) +{ + if (front() == dir) { + return _next(); + } + if (back() == dir) { + return _prev(); + } + g_error("Node::nodeToward(): handle is not a child of this node!"); +} + +/** @brief Gets the handle that goes in the direction opposite to the given adjacent node. + * Will abort with error if the given node is not adjacent. */ +Handle *Node::handleAwayFrom(Node *to) +{ + if (_next() == to) { + return back(); + } + if (_prev() == to) { + return front(); + } + g_error("Node::handleAwayFrom(): second node is not adjacent!"); +} + +/** @brief Gets the node in the direction opposite to the given handle. + * Will abort with error if the handle doesn't belong to this node. */ +Node *Node::nodeAwayFrom(Handle *h) +{ + if (front() == h) { + return _prev(); + } + if (back() == h) { + return _next(); + } + g_error("Node::nodeAwayFrom(): handle is not a child of this node!"); +} + Glib::ustring Node::_getTip(unsigned state) { if (state_held_shift(state)) { - if ((_next() && _front.isDegenerate()) || (_prev() && _back.isDegenerate())) { - if (state_held_control(state)) { + bool can_drag_out = (_next() && _front.isDegenerate()) || (_prev() && _back.isDegenerate()); + if (can_drag_out) { + /*if (state_held_control(state)) { return format_tip(C_("Path node tip", "Shift+Ctrl: drag out a handle and snap its angle " "to %f° increments"), snap_increment_degrees()); - } + }*/ return C_("Path node tip", - "Shift: drag out a handle, click to toggle selection"); + "Shift: drag out a handle, click to toggle selection"); } - return C_("Path node tip", "Shift: click to toggle selection"); + return C_("Path node tip", "Shift: click to toggle selection"); } if (state_held_control(state)) { if (state_held_alt(state)) { - return C_("Path node tip", "Ctrl+Alt: move along handle lines, click to delete node"); + return C_("Path node tip", "Ctrl+Alt: move along handle lines, click to delete node"); } return C_("Path node tip", - "Ctrl: move along axes, click to change node type"); + "Ctrl: move along axes, click to change node type"); + } + + if (state_held_alt(state)) { + return C_("Path node tip", "Alt: sculpt nodes"); } - // assemble tip from node name + // No modifiers: assemble tip from node type char const *nodetype = node_type_to_localized_string(_type); + if (_selection.transformHandlesEnabled() && selected()) { + if (_selection.size() == 1) { + return format_tip(C_("Path node tip", + "%s: drag to shape the path (more: Shift, Ctrl, Alt)"), nodetype); + } + return format_tip(C_("Path node tip", + "%s: drag to shape the path, click to toggle scale/rotation handles (more: Shift, Ctrl, Alt)"), nodetype); + } return format_tip(C_("Path node tip", - "%s: drag to shape the path, click to select this node"), nodetype); + "%s: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt)"), nodetype); } Glib::ustring Node::_getDragTip(GdkEventMotion */*event*/) @@ -971,7 +1208,7 @@ Glib::ustring Node::_getDragTip(GdkEventMotion */*event*/) Geom::Point dist = position() - _last_drag_origin(); GString *x = SP_PX_TO_METRIC_STRING(dist[Geom::X], _desktop->namedview->getDefaultMetric()); GString *y = SP_PX_TO_METRIC_STRING(dist[Geom::Y], _desktop->namedview->getDefaultMetric()); - Glib::ustring ret = format_tip(C_("Path node tip", "Move by %s, %s"), + Glib::ustring ret = format_tip(C_("Path node tip", "Move node by %s, %s"), x->str, y->str); g_string_free(x, TRUE); g_string_free(y, TRUE); @@ -1025,9 +1262,9 @@ NodeList::NodeList(SubpathList &splist) : _list(splist) , _closed(false) { - this->list = this; - this->next = this; - this->prev = this; + this->ln_list = this; + this->ln_next = this; + this->ln_prev = this; } NodeList::~NodeList() @@ -1037,13 +1274,13 @@ NodeList::~NodeList() bool NodeList::empty() { - return next == this; + return ln_next == this; } NodeList::size_type NodeList::size() { size_type sz = 0; - for (ListNode *ln = next; ln != this; ln = ln->next) ++sz; + for (ListNode *ln = ln_next; ln != this; ln = ln->ln_next) ++sz; return sz; } @@ -1074,12 +1311,11 @@ NodeList::iterator NodeList::before(double t, double *fracpart) NodeList::iterator NodeList::insert(iterator i, Node *x) { ListNode *ins = i._node; - x->next = ins; - x->prev = ins->prev; - ins->prev->next = x; - ins->prev = x; - x->ListNode::list = this; - _list.signal_insert_node.emit(x); + x->ln_next = ins; + x->ln_prev = ins->ln_prev; + ins->ln_prev->ln_next = x; + ins->ln_prev = x; + x->ln_list = this; return iterator(x); } @@ -1095,53 +1331,51 @@ void NodeList::splice(iterator pos, NodeList &list, iterator i) splice(pos, list, i, j); } -void NodeList::splice(iterator pos, NodeList &list, iterator first, iterator last) +void NodeList::splice(iterator pos, NodeList &/*list*/, iterator first, iterator last) { ListNode *ins_beg = first._node, *ins_end = last._node, *at = pos._node; - for (ListNode *ln = ins_beg; ln != ins_end; ln = ln->next) { - list._list.signal_remove_node.emit(static_cast(ln)); - ln->list = this; - _list.signal_insert_node.emit(static_cast(ln)); + for (ListNode *ln = ins_beg; ln != ins_end; ln = ln->ln_next) { + ln->ln_list = this; } - ins_beg->prev->next = ins_end; - ins_end->prev->next = at; - at->prev->next = ins_beg; - - ListNode *atprev = at->prev; - at->prev = ins_end->prev; - ins_end->prev = ins_beg->prev; - ins_beg->prev = atprev; + ins_beg->ln_prev->ln_next = ins_end; + ins_end->ln_prev->ln_next = at; + at->ln_prev->ln_next = ins_beg; + + ListNode *atprev = at->ln_prev; + at->ln_prev = ins_end->ln_prev; + ins_end->ln_prev = ins_beg->ln_prev; + ins_beg->ln_prev = atprev; } void NodeList::shift(int n) { // 1. make the list perfectly cyclic - next->prev = prev; - prev->next = next; + ln_next->ln_prev = ln_prev; + ln_prev->ln_next = ln_next; // 2. find new begin - ListNode *new_begin = next; + ListNode *new_begin = ln_next; if (n > 0) { - for (; n > 0; --n) new_begin = new_begin->next; + for (; n > 0; --n) new_begin = new_begin->ln_next; } else { - for (; n < 0; ++n) new_begin = new_begin->prev; + for (; n < 0; ++n) new_begin = new_begin->ln_prev; } // 3. relink begin to list - next = new_begin; - prev = new_begin->prev; - new_begin->prev->next = this; - new_begin->prev = this; + ln_next = new_begin; + ln_prev = new_begin->ln_prev; + new_begin->ln_prev->ln_next = this; + new_begin->ln_prev = this; } void NodeList::reverse() { - for (ListNode *ln = next; ln != this; ln = ln->prev) { - std::swap(ln->next, ln->prev); + for (ListNode *ln = ln_next; ln != this; ln = ln->ln_prev) { + std::swap(ln->ln_next, ln->ln_prev); Node *node = static_cast(ln); Geom::Point save_pos = node->front()->position(); node->front()->setPosition(node->back()->position()); node->back()->setPosition(save_pos); } - std::swap(next, prev); + std::swap(ln_next, ln_prev); } void NodeList::clear() @@ -1154,12 +1388,11 @@ NodeList::iterator NodeList::erase(iterator i) // some gymnastics are required to ensure that the node is valid when deleted; // otherwise the code that updates handle visibility will break Node *rm = static_cast(i._node); - ListNode *rmnext = rm->next, *rmprev = rm->prev; + ListNode *rmnext = rm->ln_next, *rmprev = rm->ln_prev; ++i; - _list.signal_remove_node.emit(rm); delete rm; - rmprev->next = rmnext; - rmnext->prev = rmprev; + rmprev->ln_next = rmnext; + rmnext->ln_prev = rmprev; return i; } @@ -1176,10 +1409,10 @@ void NodeList::kill() } NodeList &NodeList::get(Node *n) { - return *(n->list()); + return n->nodeList(); } NodeList &NodeList::get(iterator const &i) { - return *(i._node->list); + return *(i._node->ln_list); } @@ -1200,4 +1433,4 @@ NodeList &NodeList::get(iterator const &i) { fill-column:99 End: */ -// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :