This change has been taken from the PR at

rustyoz#4

This change has been taken from the pull request at

rustyoz#4

These changes are from the pull request at

rustyoz#3

This is hacky but it should work for now.

In addition to the path segments we want to emit drawinginstructions. We
gradually start converting the parsing functions to also emit these
instructions.

Also add the close path instruction.

We also make sure that both get drained.

Implementers of this interface are able to return a channel of
DrawingInstructions. All SVG elements should implement this interface
allowing us to draw all of them.

It hey are not, we will get a deadlock.

This DrawingInstructions signifies that a path element should now be
drawn. We need to do this in order to be able to take the line width
into account.

Apparently we were adding the same point twice which is not what we
wanted to do.

…ions

We also make sure that we emit a CloseInstruction regardless of the
segment state.

We were using the non-transformed ones by mistake.

The SVG we get sometimes contains commata between points. At the moment
we only added it to the 'C' command coordinate parsing and we may have
to add it to other places later.

That way we can more easily distinguish between the no-attribute-present
case and the attribute set to "none" case.

It would be more elegant to use this method to get all the drawing
instructions. Sadly, at the moment we rely on knowing whether there is
a scale operation in the group or not so we cannot use this method yet.

We are not using Segments and it's not an error for us so we just don't
return an error here.

The potrace SVGs still don't work.

In a bezier curve instruction, the target point becomes the new current
point. This is true when several bezier curve instructions are chained
as well and that's why we have to update the current relative coordinate.

We remove the segments channel which is now not needed anymore.

According to

https://www.w3.org/TR/SVG2/paths.html#PathDataMovetoCommands

multiple moveto commands have to be interpreted as lineto commands.

The interface now returns an error channel to which we write the first
error that occurs.

We do this for consistency.

Using this struct we can save 40 bytes for each non-Bezier curve
instruction. Bezier curve instructions get 8 bytes bigger however.