Merge lp:~danieljabailey/inkscape/arc_node_editor into lp:~inkscape.dev/inkscape/trunk

[Daniel]

Hi, This is my first time contributing to inkscape and also my first time using bazaar.

I noticed that inkscape converts arc segments in paths into bezier curves when you edit them using the node editor. I had an SVG file that contained some arcs that I wanted to manipulate and so decided to add this feature to avoid having the arcs changed to beziers.

Arc segments are manipulated with a pair of perpendicular handles that pivot around the mid point between two nodes. (This is not always the arc's mid-point) They control the rotation and the radii of the elipse upon which the arc sits. The two nodes define two arc end points and two flags control the direction and 'largeness'. The two flags can be controlled with buttons in the toolbar.

This feature required a change to the handle class so that the origin of a handle could be somewhere other than its parent node. This has been done by adding an 'offset' relative to the parent position. The length of the handle is measured from the offset point to the handle point, not from the parent. In most cases however, the offset is zero and the length, as before is from the parent node to the handle point.

This change adds four buttons to the node editor toolbar. I have created icons for these using the new arc editor tools. :-)
The four buttons are: "Make selected segments arcs", "Make selected arc segments shallow", "Make selected arc segments bulge" and "Flip selected arc segments"

I have done my best to stick to the style guides, however there was some code that I copied and pasted from something that did not match the style guide particularly well, I was unsure if I should clean up the old code or the new code and so left them both as they were (see geom.cpp function pathv_to_linear_and_cubic_beziers_and_arcs).

Please let me know if this is a valuable change that can be merged.
Also let me know if I need to fix anything.

I am aware of one slight bug, but wanted to check if there was interest in this change before I put effort into fixing it.
When an arc segment is dragged (as you would to manipulate a bezier segment) the bezier handles appear and so both the arc handles and bezier handles are visible.
Let me know if there is interest in this feature and I will start hunting this bug.

Thanks,
Dan.

[lp:~danieljabailey/inkscape/arc_node_editor]

14891. By Daniel Bailey <email address hidden> on 2016-07-08

Handle conversion from arcs to beziers in node editor

14892. By Daniel Bailey <email address hidden> on 2016-07-08

fix bug where closing arc segment sometimes becomes as straight line

14893. By Daniel Bailey <email address hidden> on 2016-07-09

Merge upstream changes

[Jabiertxof (jabiertxof)]

Added some comments about coding style, also start compiling to see the UX and give a better review.
Great work!

[Jabiertxof (jabiertxof)]

When compiling wirh CMAKE I get this error:
[ 81%] Building CXX object src/CMakeFiles/inkscape_base.dir/version.cpp.o
make[2]: *** No rule to make target 'src/inkscape-version.cpp', needed by 'src/CMakeFiles/inkscape_base.dir/inkscape-version.cpp.o'. Stop.
CMakeFiles/Makefile2:597: recipe for target 'src/CMakeFiles/inkscape_base.dir/all' failed
make[1]: *** [src/CMakeFiles/inkscape_base.dir/all] Error 2
Makefile:127: recipe for target 'all' failed
make: *** [all] Error 2

Unmerged revisions

14893. By Daniel Bailey <email address hidden> on 2016-07-09

Merge upstream changes

14892. By Daniel Bailey <email address hidden> on 2016-07-08

fix bug where closing arc segment sometimes becomes as straight line

14891. By Daniel Bailey <email address hidden> on 2016-07-08

Handle conversion from arcs to beziers in node editor

14890. By Daniel Bailey <email address hidden> on 2016-05-15

fix TODO for arc segment handling

14889. By Daniel Bailey <email address hidden> on 2016-05-15

Added support for editting arc segments in the node editor

=== modified file 'share/icons/icons.svg'
--- share/icons/icons.svg	2016-04-14 19:09:11 +0000
+++ share/icons/icons.svg	2016-07-09 15:52:46 +0000
@@ -1109,6 +1109,29 @@
 <use xlink:href="#rect4374" height="1250" width="1250" id="use5756" y="0" x="0" transform="translate(-5.018707,-0.0241656)" />
 <use xlink:href="#rect4374" height="1250" width="1250" id="use5758" y="0" x="0" transform="translate(6.0238,-11.02417)" />
 </g>
+<g id="node-segment-elliptical-arc" transform="translate(673.00134,25.751197)" inkscape:label="#node_curve">
+<path style="fill:none;stroke:#646464;stroke-width:1.00000024;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0;stroke-dasharray:none;stroke-opacity:1" d="m -38.600913,188.52882 a 6.0591792,7.0458508 48.505394 1 1 7.123238,-5.61527" id="path10679-5" sodipodi:nodetypes="cc" inkscape:connector-curvature="0" />
+<rect y="175" x="-45" height="16" width="16" id="rect10681-3" style="color:#000000;display:inline;fill:none;stroke:none;stroke-width:1;marker:none" />
+<use xlink:href="#rect4374" height="1250" width="1250" id="use5745-8" y="0" x="0" transform="translate(-1.0764281,-0.01573529)" />
+<use xlink:href="#rect4374" height="1250" width="1250" id="use5747-9" y="0" x="0" transform="translate(5.9949619,-5.5106093)" />
+</g>
+<g id="node-segment-elliptical-arc-bulge" transform="translate(693.93498,25.748197)" inkscape:label="#node_curve">
+<rect y="175" x="-45" height="16" width="16" id="rect10681-3-6" style="color:#000000;display:inline;fill:none;stroke:none;stroke-width:1;marker:none" />
+<path style="fill:none;stroke:#646464;stroke-width:1.00000024;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0;stroke-dasharray:none;stroke-opacity:1" d="m -37.870441,189.45456 a 6.0591792,7.0458508 48.505394 1 1 7.123238,-5.61527" id="path10679-5-2" sodipodi:nodetypes="cc" inkscape:connector-curvature="0" />
+<path style="fill:none;stroke:#ff8080;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0;stroke-dasharray:1, 2;stroke-dashoffset:0;stroke-opacity:1" d="m -37.870438,189.45456 a 6.0591792,7.0458508 48.505394 0 1 7.12324,-5.61527" id="path10679-5-2-8" sodipodi:nodetypes="cc" inkscape:connector-curvature="0" />
+</g>
+<g id="node-segment-elliptical-arc-flip" transform="translate(736.50086,25.748197)" inkscape:label="#node_curve">
+<rect y="175" x="-45" height="16" width="16" id="rect10681-3-67" style="color:#000000;display:inline;fill:none;stroke:none;stroke-width:1;marker:none" />
+<path style="fill:none;stroke:#646464;stroke-width:1.00000024;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0;stroke-dasharray:none;stroke-opacity:1" d="m -40.865556,188.5577 a 5.0424426,7.9529262 56.470438 1 1 7.281336,-12.07083" id="path10679-5-5" sodipodi:nodetypes="cc" inkscape:connector-curvature="0" />
+<path style="fill:none;stroke:#ff5555;stroke-width:1.00000024;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0;stroke-dasharray:none;stroke-opacity:1" d="m -40.866246,188.55761 a 5.0424427,7.9529265 56.470438 1 0 7.28134,-12.07083" id="path10679-5-5-6" sodipodi:nodetypes="cc" inkscape:connector-curvature="0" />
+<use xlink:href="#path4376" height="1250" width="1250" id="use5754-7" y="0" x="0" transform="rotate(90,-38.492674,181.50732)" />
+<use xlink:href="#path4376" height="1250" width="1250" id="use5754-7-9" y="0" x="0" transform="matrix(0,1,1,0,-217.00767,220)" />
+</g>
+<g id="node-segment-elliptical-arc-shallow" transform="translate(714.9873,25.748197)" inkscape:label="#node_curve">
+<rect y="175" x="-45" height="16" width="16" id="rect10681-3-6-6" style="color:#000000;display:inline;fill:none;stroke:none;stroke-width:1;marker:none" />
+<path style="fill:none;stroke:#646464;stroke-width:1.00000024;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0;stroke-dasharray:none;stroke-opacity:1" d="m -37.870441,189.45456 a 6.0591792,7.0458508 48.505394 0 1 7.123238,-5.61527" id="path10679-5-2-3" sodipodi:nodetypes="cc" inkscape:connector-curvature="0" />
+<path style="fill:none;stroke:#ff8080;stroke-width:1.00000024;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0;stroke-dasharray:1.00000024, 2.00000048;stroke-dashoffset:0;stroke-opacity:1" d="m -37.870438,189.45456 a 6.0591792,7.0458508 48.505394 1 1 7.12324,-5.61527" id="path10679-5-2-8-2" sodipodi:nodetypes="cc" inkscape:connector-curvature="0" />
+</g>
 <g id="object-to-path" transform="translate(280.041,-149.9465)" inkscape:label="#object_tocurve">
 <path style="fill:none;stroke:#646464;stroke-width:1.0000002;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0" d="M -37.0131,188.9855 C -35.0131,192.9855 -27.81159,188.3079 -29.81159,185.3079 -31.10674,183.3652 -39.24159,185.6729 -42.56979,183.4541 -45.56979,181.4541 -45.12074,174.9746 -40.0534,175.5422 -35.41611,176.0661 -38.62555,185.7606 -37.0131,188.9855 Z" id="path4438" sodipodi:nodetypes="cssss" inkscape:connector-curvature="0" />
 <rect y="175" x="-45" height="16" width="16" id="rect4440" style="color:#000000;fill:none" />
 
=== modified file 'src/helper/geom.cpp'
--- src/helper/geom.cpp	2015-05-08 17:26:29 +0000
+++ src/helper/geom.cpp	2016-07-09 15:52:46 +0000
@@ -456,6 +456,48 @@
 
 //#################################################################################
 
+/**
+ * Converts all segments in all paths to Geom::LineSegment or Geom::HLineSegment or
+ * Geom::VLineSegment or Geom::CubicBezier or Geom::EllipticalArc.
+ */
+Geom::PathVector
+pathv_to_linear_and_cubic_beziers_and_arcs( Geom::PathVector const &pathv )
+{
+    Geom::PathVector output;
+
+    for (Geom::PathVector::const_iterator pit = pathv.begin(); pit != pathv.end(); ++pit) {
+        output.push_back( Geom::Path() );
+        output.back().setStitching(true);
+        output.back().start( pit->initialPoint() );
+
+        for (Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_open(); ++cit) {
+            if (is_straight_curve(*cit)) {
+                Geom::LineSegment l(cit->initialPoint(), cit->finalPoint());
+                output.back().append(l);
+            } else {
+                Geom::EllipticalArc const *arc = dynamic_cast<Geom::EllipticalArc const *>(&*cit);
+                if (arc){
+                    output.back().append(arc->duplicate());
+                }
+                else{
+                    Geom::BezierCurve const *curve = dynamic_cast<Geom::BezierCurve const *>(&*cit);
+                    if (curve && curve->order() == 3) {
+                        Geom::CubicBezier b((*curve)[0], (*curve)[1], (*curve)[2], (*curve)[3]);
+                        output.back().append(b);
+                    } else {
+                        // convert all other curve types to cubicbeziers
+                        Geom::Path cubicbezier_path = Geom::cubicbezierpath_from_sbasis(cit->toSBasis(), 0.1);
+                        cubicbezier_path.close(false);
+                        output.back().append(cubicbezier_path);
+                    }
+                }
+            }
+        }
+        output.back().close( pit->closed() );
+    }
+    return output;
+}
+
 /*
  * Converts all segments in all paths to Geom::LineSegment or Geom::HLineSegment or
  * Geom::VLineSegment or Geom::CubicBezier.
 
=== modified file 'src/helper/geom.h'
--- src/helper/geom.h	2015-05-08 15:40:38 +0000
+++ src/helper/geom.h	2016-07-09 15:52:46 +0000
@@ -25,6 +25,7 @@
                                              Geom::Rect *bbox, int *wind, Geom::Coord *dist,
                                              Geom::Coord tolerance, Geom::Rect const *viewbox);
 
+Geom::PathVector pathv_to_linear_and_cubic_beziers_and_arcs( Geom::PathVector const &pathv );
 Geom::PathVector pathv_to_linear_and_cubic_beziers( Geom::PathVector const &pathv );
 Geom::PathVector pathv_to_linear( Geom::PathVector const &pathv, double maxdisp );
 Geom::PathVector pathv_to_cubicbezier( Geom::PathVector const &pathv);
 
=== modified file 'src/ui/tool/control-point.cpp'
--- src/ui/tool/control-point.cpp	2015-05-30 18:27:42 +0000
+++ src/ui/tool/control-point.cpp	2016-07-09 15:52:46 +0000
@@ -225,7 +225,6 @@
 {
     // NOTE the static variables below are shared for all points!
     // TODO handle clicks and drags from other buttons too
-
     if (event == NULL)
     {
         return false;
 
=== modified file 'src/ui/tool/multi-path-manipulator.cpp'
--- src/ui/tool/multi-path-manipulator.cpp	2015-08-08 20:19:02 +0000
+++ src/ui/tool/multi-path-manipulator.cpp	2016-07-09 15:52:46 +0000
@@ -319,11 +319,38 @@
 {
     if (_selection.empty()) return;
     invokeForAll(&PathManipulator::setSegmentType, type);
-    if (type == SEGMENT_STRAIGHT) {
-        _done(_("Straighten segments"));
-    } else {
-        _done(_("Make segments curves"));
-    }
+    switch (type){
+        case SEGMENT_STRAIGHT:
+            _done(_("Straighten segments"));
+            break;
+        case SEGMENT_CUBIC_BEZIER:
+            _done(_("Make segments curves"));
+            break;
+        case SEGMENT_ELIPTICAL_ARC:
+            _done(_("Make segments arcs"));
+            break;
+        default:
+            g_error("Unknown segment type");
+    }
+}
+
+void MultiPathManipulator::setArcSegmentLarge(bool large)
+{
+    if (_selection.empty()) return;
+    invokeForAll(&PathManipulator::setArcSegmentLarge, large);
+    if (large){
+        _done(_("Make arc segments bulge"));
+    }
+    else{
+        _done(_("Make arc segments shallow"));
+    }
+}
+
+void MultiPathManipulator::toggleArcSegmentSweep()
+{
+    if (_selection.empty()) return;
+    invokeForAll(&PathManipulator::toggleArcSegmentSweep);
+    _done(_("Flip arc segments"));
 }
 
 void MultiPathManipulator::insertNodes()
 
=== modified file 'src/ui/tool/multi-path-manipulator.h'
--- src/ui/tool/multi-path-manipulator.h	2015-05-30 18:27:42 +0000
+++ src/ui/tool/multi-path-manipulator.h	2016-07-09 15:52:46 +0000
@@ -51,6 +51,9 @@
     void setNodeType(NodeType t);
     void setSegmentType(SegmentType t);
 
+    void setArcSegmentLarge(bool large);
+    void toggleArcSegmentSweep();
+
     void insertNodesAtExtrema(ExtremumType extremum);
     void insertNodes();
     void insertNode(Geom::Point pt);
 
=== modified file 'src/ui/tool/node-types.h'
--- src/ui/tool/node-types.h	2010-11-17 02:12:56 +0000
+++ src/ui/tool/node-types.h	2016-07-09 15:52:46 +0000
@@ -28,7 +28,8 @@
 /** Types of segments supported in the node tool. */
 enum SegmentType {
     SEGMENT_STRAIGHT, ///< Straight linear segment
-    SEGMENT_CUBIC_BEZIER ///< Bezier curve with two control points
+    SEGMENT_CUBIC_BEZIER, ///< Bezier curve with two control points
+    SEGMENT_ELIPTICAL_ARC ///< Eliptical arc (two radii, rotation, size flag, direction flag)
 };
 
 } // namespace UI
 
=== modified file 'src/ui/tool/node.cpp'
--- src/ui/tool/node.cpp	2016-05-29 10:13:55 +0000
+++ src/ui/tool/node.cpp	2016-07-09 15:52:46 +0000
@@ -112,7 +112,8 @@
                  _handle_colors, data.handle_group),
     _parent(parent),
     _handle_line(ControlManager::getManager().createControlLine(data.handle_line_group)),
-    _degenerate(true)
+    _degenerate(true),
+    _offset(Geom::Point())// Start with 0 offset
 {
     setVisible(false);
 }
@@ -184,8 +185,8 @@
 
     if (_parent->type() == NODE_SMOOTH && Node::_is_line_segment(_parent, node_away)) {
         // restrict movement to the line joining the nodes
-        Geom::Point direction = _parent->position() - node_away->position();
-        Geom::Point delta = new_pos - _parent->position();
+        Geom::Point direction = _parent->position() + _offset - node_away->position();
+        Geom::Point delta = new_pos - _parent->position() + _offset;
         // project the relative position on the direction line
         Geom::Point new_delta = (Geom::dot(delta, direction)
             / Geom::L2sq(direction)) * direction;
@@ -212,7 +213,7 @@
         } break;
     case NODE_SYMMETRIC:
         // for symmetric nodes, place the other handle on the opposite side
-        other->setRelativePos(-(new_pos - _parent->position()));
+        other->setRelativePos(-(new_pos - _parent->position() + _offset));
         break;
     default: break;
     }
@@ -229,10 +230,10 @@
 void Handle::setPosition(Geom::Point const &p)
 {
     ControlPoint::setPosition(p);
-    _handle_line->setCoords(_parent->position(), position());
+    _handle_line->setCoords(_parent->position() + _offset, position());
 
     // update degeneration info and visibility
-    if (Geom::are_near(position(), _parent->position()))
+    if (Geom::are_near(position(), _parent->position() + _offset))
         _degenerate = true;
     else _degenerate = false;
 
@@ -243,6 +244,15 @@
     }
 }
 
+/** Set the offset between the parent node and the origin */
+void Handle::setOffset(Geom::Point const &offset){
+    _offset = offset;
+    _handle_line->setCoords(_parent->position() + _offset, position());
+}
+
+/** Set the length of the handle, if the handle is degenerate then
+    the function returns without changing the handle position as
+    it cannot determine the desired direction of the handle */
 void Handle::setLength(double len)
 {
     if (isDegenerate()) return;
@@ -250,9 +260,30 @@
     setRelativePos(dir * len);
 }
 
+/** Set the angle of the handle, if the handle is degenerate then
+    the function returns without changing the handle position as
+    it is not possible to set the orientation of a zero length line */
+void Handle::setAngle(Geom::Angle a){
+    if (isDegenerate()) return;
+    setRelativePos(Geom::Point::polar(a, length()));
+}
+
+/** Set the angle and the length of the handle by moving the handle position
+    unlike Handle::setLength and Handle::setAngle, this function works for
+    degenerate handles as both the desired length and angle are known*/
+void Handle::setAngleAndLength(Geom::Angle a, double len){
+    // Degenerate case can be handled by setting the handle relative position
+    // to be any vector of non-zero length. A unit vector is used here.
+    if (isDegenerate()) {
+        setRelativePos(Geom::Point(0,1));
+    }
+    setAngle(a);
+    setLength(len);
+}
+
 void Handle::retract()
 {
-    move(_parent->position());
+    move(_parent->position() + _offset);
 }
 
 void Handle::setDirection(Geom::Point const &from, Geom::Point const &to)
@@ -428,6 +459,7 @@
         new_pos=_last_drag_origin();
     }
     move(new_pos); // needed for correct update, even though it's redundant
+    _parent->updateArcHandleConstriants(this);
     _pm().update();
 }
 
@@ -585,6 +617,10 @@
                            node_colors, data.node_group),
     _front(data, initial_pos, this),
     _back(data, initial_pos, this),
+    _arc_rx(data, initial_pos, this),
+    _arc_ry(data, initial_pos, this),
+    _arc_large(true),
+    _arc_sweep(false),
     _type(NODE_CUSP),
     _handles_shown(false)
 {
@@ -622,6 +658,52 @@
     }
 }
 
+/** Update constrained arc handles given a new constraint.
+    This is used to keep the arc radius handles at right angles
+    @param constraint Pointer to the handle that was forced to a new position.
+        If the constraint is anything other than _arc_rx or _arc_ry then this function does nothing */
+void Node::updateArcHandleConstriants(Handle *constraint)
+{
+    Handle *updateTarget = NULL;
+    Geom::Angle rotation = 0.0;
+    // Check which handle moved and set the update target and rotation
+    if      (constraint == &_arc_rx){ updateTarget = &_arc_ry; rotation = Geom::rad_from_deg( 90.0); }
+    else if (constraint == &_arc_ry){ updateTarget = &_arc_rx; rotation = Geom::rad_from_deg(-90.0); }
+    else return;
+    // Calculate the new position and move the constrained handle (updateTarget)
+    Geom::Angle newAngle = constraint->angle() + rotation;
+    Geom::Coord newLength = updateTarget->length();
+    Geom::Point newPos = Geom::Point::polar(newAngle, newLength);
+    updateTarget->setRelativePos(newPos);
+}
+
+/** Move the arc handles so that their origin is half way along the line between the nodes */
+void Node::moveArcHandles(Geom::Point lineBetweenNodes, double lenX, double lenY, Geom::Angle rotX, Geom::Angle rotY)
+{
+    // Calculate the mid point between the two nodes, put the origin of the handles there.
+    // This usually changes the length and angle of the handle lines
+    Geom::Point midPointOffset = lineBetweenNodes / 2.0;
+    _arc_rx.setOffset(midPointOffset);
+    _arc_ry.setOffset(midPointOffset);
+
+    _arc_rx.setPosition(position());
+    _arc_ry.setPosition(position());
+
+    // Apply the stored angle and length
+    _arc_rx.setAngleAndLength(rotX, lenX);
+    _arc_ry.setAngleAndLength(rotY, lenY);
+
+}
+
+/** Retract this node's handles for controling arcs */
+void Node::retractArcHandles()
+{
+    _arc_rx.setOffset(Geom::Point());
+    _arc_ry.setOffset(Geom::Point());
+    _arc_rx.retract();
+    _arc_ry.retract();
+}
+
 void Node::move(Geom::Point const &new_pos)
 {
     // move handles when the node moves.
@@ -643,11 +725,47 @@
         nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back());
     }
 
+    // Save the lengths and angles of the two arc handles to apply again after the node is moved.
+    double lenX, lenY;
+    Geom::Angle rotX, rotY;
+    lenX = _arc_rx.length(); lenY = _arc_ry.length();
+    rotX = _arc_rx.angle();  rotY = _arc_ry.angle();
+
     setPosition(new_pos);
 
+    // _front and _back are translated with the node to which they belong.
+    // This means that if they were degenrate then they are still degenerate.
     _front.setPosition(_front.position() + delta);
     _back.setPosition(_back.position() + delta);
 
+    // For arc manipulation handles, the position relative to their parent nodes
+    // may change as the node moves. For this reason, the degenerate case must be
+    // handled as a special case.
+    if (nextNode) { // Must have a next node for this to be an arc segment
+       if (_arc_rx.isDegenerate() || _arc_ry.isDegenerate()){
+           retractArcHandles();
+       }
+       else{
+            moveArcHandles(nextNode->position() - position(), lenX, lenY, rotX, rotY);
+       }
+    }
+    // If this is the end of an arc segment then the arc data for prevNode needs updating
+    if (prevNode){
+        if (prevNode->arc_rx()->isDegenerate() || prevNode->arc_ry()->isDegenerate()){
+            prevNode->retractArcHandles();
+        }
+        else{
+            // In this case, the parent node for the arc handles hasn't moved,
+            // for this reason, we didn't need to save the length and rotation earlier,
+            // we can get the length and rotation now.
+            lenX = prevNode->arc_rx()->length();
+            lenY = prevNode->arc_ry()->length();
+            rotX = prevNode->arc_rx()->angle();
+            rotY = prevNode->arc_ry()->angle();
+            prevNode->moveArcHandles(n->position() - prevNode->position(), lenX, lenY, rotX, rotY);
+        }
+    }
+
     // if the node has a smooth handle after a line segment, it should be kept colinear
     // with the segment
     _fixNeighbors(old_pos, new_pos);
@@ -667,7 +785,6 @@
 
 void Node::transform(Geom::Affine const &m)
 {
-
     Geom::Point old_pos = position();
 
     // save the previous nodes strength to apply it again once the node is moved 
@@ -685,10 +802,26 @@
         nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back());
     }
 
+    // Save the lengths and angles of the two arc handles to apply again after the node is moved.
+    double lenX, lenY;
+    Geom::Angle rotX, rotY;
+    lenX = _arc_rx.length(); lenY = _arc_ry.length();
+    rotX = _arc_rx.angle();  rotY = _arc_ry.angle();
+
     setPosition(position() * m);
     _front.setPosition(_front.position() * m);
     _back.setPosition(_back.position() * m);
 
+
+    if (nextNode){
+        if (_arc_rx.isDegenerate() || _arc_ry.isDegenerate()){
+            retractArcHandles();
+        }
+        else{
+            moveArcHandles(nextNode->position() - position(), lenX, lenY, rotX, rotY);
+        }
+    }
+
     /* Affine transforms keep handle invariants for smooth and symmetric nodes,
      * but smooth nodes at ends of linear segments and auto nodes need special treatment */
     _fixNeighbors(old_pos, position());
@@ -789,7 +922,12 @@
     if (!_back.isDegenerate()) {
         _back.setVisible(v);
     }
-
+    if (!_arc_rx.isDegenerate()) {
+        _arc_rx.setVisible(v);
+    }
+    if (!_arc_ry.isDegenerate()) {
+        _arc_ry.setVisible(v);
+    }
 }
 
 void Node::updateHandles()
@@ -798,6 +936,8 @@
 
     _front._handleControlStyling();
     _back._handleControlStyling();
+    _arc_rx._handleControlStyling();
+    _arc_ry._handleControlStyling();
 }
 
 
@@ -1332,7 +1472,6 @@
     }
 
     sm.unSetup();
-
     SelectableControlPoint::dragged(new_pos, event);
 }
 
@@ -1361,6 +1500,15 @@
     return SnapCandidatePoint(position(), _snapSourceType(), _snapTargetType());
 }
 
+Geom::EllipticalArc Node::getEllipticalArc(){
+    // Must have a next node for this to be an arc
+    if (not _next()) return Geom::EllipticalArc();
+    Geom::Point r = Geom::Point(_arc_rx.length(), _arc_ry.length());
+    Geom::Coord rot = _arc_rx.angle();
+    // Create an arc and return it
+    return Geom::EllipticalArc(position(), r, rot, _arc_large, _arc_sweep, _next()->position());
+}
+
 Handle *Node::handleToward(Node *to)
 {
     if (_next() == to) {
@@ -1378,7 +1526,7 @@
     if (front() == dir) {
         return _next();
     }
-    if (back() == dir) {
+    if ( (back() == dir) || (arc_rx() == dir) || (arc_ry() == dir) ) {
         return _prev();
     }
     g_error("Node::nodeToward(): handle is not a child of this node!");
@@ -1402,7 +1550,7 @@
     if (front() == h) {
         return _prev();
     }
-    if (back() == h) {
+    if ( (back() == h) || (arc_rx() == h) || (arc_ry() == h) ) {
         return _next();
     }
     g_error("Node::nodeAwayFrom(): handle is not a child of this node!");
@@ -1492,9 +1640,9 @@
 {
     if (!first || !second) return false;
     if (first->_next() == second)
-        return first->_front.isDegenerate() && second->_back.isDegenerate();
+        return first->_front.isDegenerate() && second->_back.isDegenerate() && first->_arc_rx.isDegenerate()  && first->_arc_ry.isDegenerate();
     if (second->_next() == first)
-        return second->_front.isDegenerate() && first->_back.isDegenerate();
+        return second->_front.isDegenerate() && first->_back.isDegenerate() && second->_arc_rx.isDegenerate()  && second->_arc_ry.isDegenerate();
     return false;
 }
 
 
=== modified file 'src/ui/tool/node.h'
--- src/ui/tool/node.h	2015-04-30 09:17:07 +0000
+++ src/ui/tool/node.h	2016-07-09 15:52:46 +0000
@@ -29,6 +29,7 @@
 
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/shared_ptr.hpp>
+#include <2geom/elliptical-arc.h>
 #include "ui/tool/selectable-control-point.h"
 #include "snapped-point.h"
 #include "ui/tool/node-types.h"
@@ -100,6 +101,7 @@
     virtual ~Handle();
     inline Geom::Point relativePos() const;
     inline double length() const;
+    inline Geom::Angle angle() const;
     bool isDegenerate() const { return _degenerate; } // True if the handle is retracted, i.e. has zero length.
 
     virtual void setVisible(bool);
@@ -107,7 +109,10 @@
 
     virtual void setPosition(Geom::Point const &p);
     inline void setRelativePos(Geom::Point const &p);
+    virtual void setOffset(Geom::Point const &offset);
     void setLength(double len);
+    void setAngle(Geom::Angle a);
+    void setAngleAndLength(Geom::Angle a, double len);
     void retract();
     void setDirection(Geom::Point const &from, Geom::Point const &to);
     void setDirection(Geom::Point const &dir);
@@ -140,6 +145,8 @@
     SPCtrlLine *_handle_line;
     bool _degenerate; // True if the handle is retracted, i.e. has zero length. This is used often internally so it makes sense to cache this
 
+    Geom::Point _offset;
+
     /**
      * Control point of a cubic Bezier curve in a path.
      *
@@ -183,6 +190,10 @@
     void showHandles(bool v);
 
     void updateHandles();
+    void updateArcHandleConstriants(Handle *constraint);
+    void moveArcHandles(Geom::Point lineBetweenNodes, double lenX, double lenY, Geom::Angle rotX, Geom::Angle rotY);
+
+    void retractArcHandles();
 
 
     /**
@@ -195,6 +206,11 @@
     bool isEndNode() const;
     Handle *front() { return &_front; }
     Handle *back()  { return &_back;  }
+    Handle *arc_rx() { return &_arc_rx; }
+    Handle *arc_ry() { return &_arc_ry; }
+    bool *arc_large() { return &_arc_large; }
+    bool *arc_sweep() { return &_arc_sweep; }
+    Geom::EllipticalArc getEllipticalArc();
 
     /**
      * Gets the handle that faces the given adjacent node.
@@ -278,6 +294,11 @@
     // as a line segment
     Handle _front; ///< Node handle in the backward direction of the path
     Handle _back; ///< Node handle in the forward direction of the path
+    // The arc control points and flags relate to an arc starting at this node and ending at the next node
+    Handle _arc_rx; ///< Handle for controling the x radius and rotation of the elipse (in eliptical arc mode)
+    Handle _arc_ry; ///< Handle for controling the y radius and rotation of the elipse (in eliptical arc mode)
+    bool _arc_large; ///< Flag that determines if arc mode is shallow or bulge
+    bool _arc_sweep; ///< Flag that determines the direction of an arc's sweep
     NodeType _type; ///< Type of node - cusp, smooth...
     bool _handles_shown;
     static ColorSet node_colors;
@@ -489,14 +510,17 @@
 
 // define inline Handle funcs after definition of Node
 inline Geom::Point Handle::relativePos() const {
-    return position() - _parent->position();
+    return position() - (_parent->position() + _offset);
 }
 inline void Handle::setRelativePos(Geom::Point const &p) {
-    setPosition(_parent->position() + p);
+    setPosition(_parent->position() + _offset + p);
 }
 inline double Handle::length() const {
     return relativePos().length();
 }
+inline Geom::Angle Handle::angle() const {
+    return Geom::Angle(position() - _parent->position() - _offset);
+}
 inline PathManipulator &Handle::_pm() {
     return _parent->_pm();
 }
 
=== modified file 'src/ui/tool/path-manipulator.cpp'
--- src/ui/tool/path-manipulator.cpp	2016-05-19 22:11:42 +0000
+++ src/ui/tool/path-manipulator.cpp	2016-07-09 15:52:46 +0000
@@ -21,6 +21,7 @@
 #include <2geom/bezier-curve.h>
 #include <2geom/bezier-utils.h>
 #include <2geom/path-sink.h>
+#include <2geom/pathvector.h>
 #include <glibmm/i18n.h>
 #include "ui/tool/path-manipulator.h"
 #include "desktop.h"
@@ -801,7 +802,10 @@
     }
 }
 
-/** Make selected segments curves / lines. */
+// \todo The three functions setSegmentType, setArcSegmentLarge, setArcSegmentSweep could be
+// refactored to share the code that iterates over all selected segments.
+
+/** Make selected segments curves / lines / arcs. */
 void PathManipulator::setSegmentType(SegmentType type)
 {
     if (_num_selected == 0) return;
@@ -811,18 +815,81 @@
             if (!(k && j->selected() && k->selected())) continue;
             switch (type) {
             case SEGMENT_STRAIGHT:
-                if (j->front()->isDegenerate() && k->back()->isDegenerate())
+                if ((j->front()->isDegenerate() && k->back()->isDegenerate())
+                    && (j->arc_rx()->isDegenerate() && j->arc_ry()->isDegenerate()))
                     break;
                 j->front()->move(*j);
                 k->back()->move(*k);
+                j->retractArcHandles();
                 break;
             case SEGMENT_CUBIC_BEZIER:
-                if (!j->front()->isDegenerate() || !k->back()->isDegenerate())
-                    break;
+                if (!j->front()->isDegenerate() || !k->back()->isDegenerate()){
+                    // Already a cubic bezier
+                    break;
+                }
+                if (!j->arc_rx()->isDegenerate() || !j->arc_ry()->isDegenerate()){
+                    // This is an elliptical arc that is being converted to a cubic bezier
+                    // Generate the bezier path and use it to replace the current segment
+                    Geom::Path cubicbezier_path = Geom::cubicbezierpath_from_sbasis(j->getEllipticalArc().toSBasis(), 0.1);
+                    replaceSegmentWithPath(j, cubicbezier_path);
+                    break;
+                }
+                
                 // move both handles to 1/3 of the line
                 j->front()->move(j->position() + (k->position() - j->position()) / 3);
                 k->back()->move(k->position() + (j->position() - k->position()) / 3);
-                break;
+                j->arc_rx()->move(*j);
+                j->arc_ry()->move(*j);
+                j->retractArcHandles();
+                break;
+            case SEGMENT_ELIPTICAL_ARC:
+                if (!(j->front()->isDegenerate() && k->back()->isDegenerate())){
+                    j->front()->move(*j);
+                    k->back()->move(*k);
+                }
+
+                if (j->arc_rx()->isDegenerate() && j->arc_ry()->isDegenerate()){
+                    Geom::Point midPointOffset = ((k->position() - j->position()) / 2);
+                    Geom::Point handleOrigin = j->position()+midPointOffset;
+
+                    j->arc_rx()->setOffset(midPointOffset);
+                    j->arc_ry()->setOffset(midPointOffset);
+                    j->arc_rx()->move(j->position() + ((k->position() - handleOrigin) / 2));
+                    j->updateArcHandleConstriants(j->arc_rx());
+                }
+                break;
+            }
+        }
+    }
+}
+
+/** Set the large flag on selected arcs */
+void PathManipulator::setArcSegmentLarge(bool large){
+    if (_num_selected == 0) return;
+    for (SubpathList::iterator i = _subpaths.begin(); i != _subpaths.end(); ++i) {
+        for (NodeList::iterator j = (*i)->begin(); j != (*i)->end(); ++j) {
+            NodeList::iterator k = j.next();
+            if (!(k && j->selected() && k->selected())) continue;
+            // This code executes for every selected segment
+            if (!j->arc_rx()->isDegenerate() || !j->arc_ry()->isDegenerate()){
+                // This code executes for every selected ARC segment
+                *(j->arc_large()) = large;
+            }
+        }
+    }
+}
+
+/** Set the sweep flag on selected arcs */
+void PathManipulator::toggleArcSegmentSweep(){
+    if (_num_selected == 0) return;
+    for (SubpathList::iterator i = _subpaths.begin(); i != _subpaths.end(); ++i) {
+        for (NodeList::iterator j = (*i)->begin(); j != (*i)->end(); ++j) {
+            NodeList::iterator k = j.next();
+            if (!(k && j->selected() && k->selected())) continue;
+            // This code executes for every selected segment
+            if (!j->arc_rx()->isDegenerate() || !j->arc_ry()->isDegenerate()){
+                // This code executes for every selected ARC segment
+                *(j->arc_sweep()) = !*j->arc_sweep();
             }
         }
     }
@@ -1094,6 +1161,75 @@
     return match;
 }
 
+/** Replace a segment with a path.
+ * @param segment The segment to replace
+ * @param newPath The path to insert in place of 'segment'
+ *
+ * Currently, newPath must be composed only of cubic beziers, the caller must
+ * ensure that the path only contains cubic beziers (until other segments are
+ * implemented in this function)  */
+void PathManipulator::replaceSegmentWithPath(NodeList::iterator segment, Geom::Path newPath)
+{
+    if (!segment) throw std::invalid_argument("Invalid iterator for replacement");
+    NodeList &list = NodeList::get(segment);
+    NodeList::iterator second = segment.next();
+    if (!second) throw std::invalid_argument("Replace after last node in open path");
+
+    // Retract all handles relating to this segment
+    segment->retractArcHandles();
+    segment->front()->retract();
+    
+    // get the insertion point
+    NodeList::iterator insert_at = segment;
+    ++insert_at;
+
+    // Keep the previous node handy to update its handles when needed
+    Node *prevNode = &(*insert_at);
+
+    // Path is to be inserted in reverse order
+    Geom::Path reversedPath = newPath.reversed();
+
+    // Iterate over the path
+    for (Geom::Path::iterator i = reversedPath.begin(); i != reversedPath.end(); ++i){
+        const Geom::Curve & thisCurve = *i;
+
+        // Try converting to a bezier
+        const Geom::BezierCurve * bezier = dynamic_cast<const Geom::BezierCurve*>(&thisCurve);
+        if (bezier) {
+            // Check order of bezier (currently only cubic beziers are supported)
+            if (bezier->order() == 3)
+            {
+                // Create one new node
+                Node *newNode = new Node(_multi_path_manipulator._path_data.node_data, bezier->finalPoint());
+                // Set the control points for this node and the previous node
+                newNode->front() ->setPosition((*bezier)[2]);
+                prevNode->back()->setPosition((*bezier)[1]);
+                // All new nodes are smooth
+                newNode->setType(NODE_SMOOTH, false);
+
+                // Insert new node
+                list.insert(insert_at, newNode);
+                // Move along to next node
+                prevNode = newNode;
+                insert_at--;
+            }
+            else{
+                // TODO, Is there a better exception to raise here?
+                // TODO, implement this if needed in future
+                throw std::invalid_argument("Only cubic bezier curves are implemented in PathManipulator::replaceSegment."
+                    " newPath contains beziers with order!=3.");
+            }
+        }
+        else{
+            // Not a bezier
+            // TODO, Is there a better exception to raise here?
+            // TODO, implement this if needed in future
+            throw std::invalid_argument("Only cubic bezier curves are implemented in PathManipulator::replaceSegment."
+                " newPath contains non-bezier segments.");
+        }
+    }
+}
+
 /** Called by the XML observer when something else than us modifies the path. */
 void PathManipulator::_externalChange(unsigned type)
 {
@@ -1149,7 +1285,8 @@
 
     // sanitize pathvector and store it in SPCurve,
     // so that _updateDragPoint doesn't crash on paths with naked movetos
-    Geom::PathVector pathv = pathv_to_linear_and_cubic_beziers(_spcurve->get_pathvector());
+    Geom::PathVector pathv = pathv_to_linear_and_cubic_beziers_and_arcs(_spcurve->get_pathvector());
+
     for (Geom::PathVector::iterator i = pathv.begin(); i != pathv.end(); ) {
         // NOTE: this utilizes the fact that Geom::PathVector is an std::vector.
         // When we erase an element, the next one slides into position,
@@ -1199,6 +1336,15 @@
                 previous_node->front()->setPosition((*bezier)[1]);
                 current_node ->back() ->setPosition((*bezier)[2]);
             }
+            Geom::EllipticalArc const *arc = dynamic_cast<Geom::EllipticalArc const*>(&*cit);
+            if (arc)
+            {
+                Geom::Coord angleX = arc->rotationAngle();
+                Geom::Coord angleY = angleX + Geom::rad_from_deg(90);
+                previous_node->moveArcHandles(current_node->position() - previous_node->position(), arc->ray(Geom::X), arc->ray(Geom::Y), angleX, angleY);
+                *(previous_node->arc_large()) = arc->largeArc();
+                *(previous_node->arc_sweep()) = arc->sweep();
+            }
             previous_node = current_node;
         }
         // If the path is closed, make the list cyclic
@@ -1355,8 +1501,9 @@
         }
         if (subpath->closed()) {
             // Here we link the last and first node if the path is closed.
-            // If the last segment is Bezier, we add it.
-            if (!prev->front()->isDegenerate() || !subpath->begin()->back()->isDegenerate()) {
+            // If the last segment is Bezier or arc, we add it.
+            if (!prev->front()->isDegenerate() || !subpath->begin()->back()->isDegenerate()
+                || !prev->arc_rx()->isDegenerate() || !prev->arc_ry()->isDegenerate()) {
                 build_segment(builder, prev.ptr(), subpath->begin().ptr());
             }
             // if that segment is linear, we just call closePath().
@@ -1397,16 +1544,33 @@
  * @relates PathManipulator */
 void build_segment(Geom::PathBuilder &builder, Node *prev_node, Node *cur_node)
 {
-    if (cur_node->back()->isDegenerate() && prev_node->front()->isDegenerate())
-    {
-        // NOTE: It seems like the renderer cannot correctly handle vline / hline segments,
-        // and trying to display a path using them results in funny artifacts.
-        builder.lineTo(cur_node->position());
-    } else {
-        // this is a bezier segment
-        builder.curveTo(
-            prev_node->front()->position(),
-            cur_node->back()->position(),
+    if (prev_node->arc_rx()->isDegenerate() || prev_node->arc_ry()->isDegenerate() ){
+        // This is not an eliptical arc, check if it is a straight line or bezier
+        if (cur_node->back()->isDegenerate() && prev_node->front()->isDegenerate())
+        {
+            // NOTE: It seems like the renderer cannot correctly handle vline / hline segments,
+            // and trying to display a path using them results in funny artifacts.
+            builder.lineTo(cur_node->position());
+        } else {
+            // this is a bezier segment
+            builder.curveTo(
+                prev_node->front()->position(),
+                cur_node->back()->position(),
+                cur_node->position());
+        }
+    }
+    else{
+        // This is an eliptical arc, get the x and y set by the xy handle
+        Geom::Coord rx = prev_node->arc_rx()->length();
+        Geom::Coord ry = prev_node->arc_ry()->length();
+        Geom::Angle rot = prev_node->arc_rx()->angle();
+
+        builder.arcTo(
+            rx,
+            ry,
+            rot,
+            *prev_node->arc_large(),
+            *prev_node->arc_sweep(),
             cur_node->position());
     }
 }
 
=== modified file 'src/ui/tool/path-manipulator.h'
--- src/ui/tool/path-manipulator.h	2015-08-13 23:23:05 +0000
+++ src/ui/tool/path-manipulator.h	2016-07-09 15:52:46 +0000
@@ -15,6 +15,7 @@
 #include <memory>
 #include <2geom/pathvector.h>
 #include <2geom/affine.h>
+#include <2geom/sbasis-to-bezier.h>
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 #include "ui/tool/node.h"
@@ -81,6 +82,9 @@
     void reverseSubpaths(bool selected_only);
     void setSegmentType(SegmentType);
 
+    void setArcSegmentLarge(bool large);
+    void toggleArcSegmentSweep();
+
     void scaleHandle(Node *n, int which, int dir, bool pixel);
     void rotateHandle(Node *n, int which, int dir, bool pixel);
 
@@ -97,6 +101,7 @@
     NodeList::iterator subdivideSegment(NodeList::iterator after, double t);
     NodeList::iterator extremeNode(NodeList::iterator origin, bool search_selected,
         bool search_unselected, bool closest);
+    void replaceSegmentWithPath(NodeList::iterator segment, Geom::Path newPath);
 
     int _bsplineGetSteps() const;
     // this is necessary for Tab-selection in MultiPathManipulator
 
=== modified file 'src/widgets/node-toolbar.cpp'
--- src/widgets/node-toolbar.cpp	2014-12-21 21:58:32 +0000
+++ src/widgets/node-toolbar.cpp	2016-07-09 15:52:46 +0000
@@ -171,6 +171,38 @@
     }
 }
 
+static void sp_node_path_edit_toarc(void)
+{
+    NodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setSegmentType(Inkscape::UI::SEGMENT_ELIPTICAL_ARC);
+    }
+}
+
+static void sp_node_path_edit_arc_shallow(void)
+{
+    NodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setArcSegmentLarge(false);
+    }
+}
+
+static void sp_node_path_edit_arc_bulge(void)
+{
+    NodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->setArcSegmentLarge(true);
+    }
+}
+
+static void sp_node_path_edit_arc_flip(void)
+{
+    NodeTool *nt = get_node_tool();
+    if (nt) {
+        nt->_multipath->toggleArcSegmentSweep();
+    }
+}
+
 static void sp_node_path_edit_cusp(void)
 {
     NodeTool *nt = get_node_tool();
@@ -486,6 +518,36 @@
     }
 
     {
+        InkAction* inky = ink_action_new( "NodeArcShallowAction",
+                                          _("Node Arc Shallow"),
+                                          _("Make selected arc segments shallow"),
+                                          INKSCAPE_ICON("node-segment-elliptical-arc-shallow"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_arc_shallow), 0 );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    {
+        InkAction* inky = ink_action_new( "NodeArcBulgeAction",
+                                          _("Node Arc Bulge"),
+                                          _("Make selected arc segments bulge"),
+                                          INKSCAPE_ICON("node-segment-elliptical-arc-bulge"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_arc_bulge), 0 );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    {
+        InkAction* inky = ink_action_new( "NodeArcFlipAction",
+                                          _("Node Arc Flip"),
+                                          _("Flip selected arc segments"),
+                                          INKSCAPE_ICON("node-segment-elliptical-arc-flip"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_arc_flip), 0 );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    {
         InkAction* inky = ink_action_new( "NodeLineAction",
                                           _("Node Line"),
                                           _("Make selected segments lines"),
@@ -506,6 +568,16 @@
     }
 
     {
+        InkAction* inky = ink_action_new( "NodeArcAction",
+                                          _("Node Arc"),
+                                          _("Make selected segments arcs"),
+                                          INKSCAPE_ICON("node-segment-elliptical-arc"),
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_toarc), 0 );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    {
         InkToggleAction* act = ink_toggle_action_new( "NodesShowTransformHandlesAction",
                                                       _("Show Transform Handles"),
                                                       _("Show transformation handles for selected nodes"),
 
=== modified file 'src/widgets/toolbox.cpp'
--- src/widgets/toolbox.cpp	2016-05-22 00:49:33 +0000
+++ src/widgets/toolbox.cpp	2016-07-09 15:52:46 +0000
@@ -282,6 +282,11 @@
         "    <separator />"
         "    <toolitem action='NodeLineAction' />"
         "    <toolitem action='NodeCurveAction' />"
+        "    <toolitem action='NodeArcAction' />"
+        "    <separator />"
+        "    <toolitem action='NodeArcShallowAction' />"
+        "    <toolitem action='NodeArcBulgeAction' />"
+        "    <toolitem action='NodeArcFlipAction' />"
         "    <separator />"
         "    <toolitem action='ObjectToPath' />"
         "    <toolitem action='StrokeToPath' />"