~tex-sx/tex-sx/development

\useasboundingbox (-1,1) rectangle (2,-2);

 

This fills out all the attributes.

Finding the information for an attribute involves ``walking'' along the path.

Therefore, if we're going to need more than one, it makes sense to do them all in one go.

Calling this method ensures that they are all filled in and does so more efficiently than calling each individually.

 

 

One of the things that the \texttt{calligraphy} package wants to be able to do is taper a path.

To do this nicely, the path should have at least three drawing pieces.

This ensures that this is so by splitting it if it does not.

If it has one piece, it is split into three at the .3 and .7 marks.

If it has two pieces, each is split in half.

 

 

This is used to taper a path.

In fact, it replaces the first drawing component by a simularted tapered path (actually the outline of the tapered path is returned).

The rest of the path is thrown away, so this should be used after the path has been split.

 

 

This splits a path according to the length.

The first argument will be an \Verb+spath+ object corresponding to the first part of the path, the second the rest, and the third says how many tokens should be in the first part of the path.

Both pieces are ``proper'' paths, so the second will be given an initial \Verb+moveto+.

 

 

This is the same as \Verb+split path by length+ except that it uses the \Verb+real length+ as the criterion of when to split.

 

 

This is the same as \Verb+split path by length+ except that it uses the \Verb+number of components+ as the criterion of when to split.

 

 

This is the method that actually does the splitting.

It depends on certain macros being set which the previous three methods initialise.

It should therefore not be called directly.

Consider it a ``private'' method.

 

 

This reprocesses the path.

Some TikZ/PGF settings have implications for how a path is constructed (such as the \Verb+rounded corners+ option).

If these have changed since the path was originally defined, it might be reasonable to redraw the path under the new conditions.

This does so.

 

 

This replaces the current path by the path stored in this object.

 

 

This replaces the path stored in this object by the current path.

 

 

This uses the path.

The argument should be one of the PGF usage commands: \Verb+draw+, \Verb+fill+, \Verb+clip+, or \Verb+discard+.

 

 

This uses the path but in a TikZian way.

The argument should be a list of TikZ styles to be set for the path.

Imagine this as \Verb+\path[<options>] <path>;+.

 

 

This concatenates the path in the current object with that from another.

If the first argument is given (which should be a macro), the result will a new \Verb+spath+ object stored in that macro.

If not, the object will be modified itself.

Since paths start with a \Verb+moveto+, the concatenation will not be a continuous path. 

 

 

This concatenates the path as \Verb+concatenate+ does, except that the \Verb+moveto+ in the middle is replaced by a \Verb+lineto+.

 

 

This welds two paths together.

Welding is like concatenation except that the second path is translated so that its starting point is the final point of the first path (and the \Verb+moveto+ is removed).

 

 

This closes the path.

\subsection{The \texttt{spath component} Object}

 

An \Verb+spath component+ object is an element in an array of \Verb+spath+ objects.

Each element contains an \Verb+spath+ object and pointers to the previous and successive components.

 

This is the \Verb+spath+ object of the current element.

 

 

This is the next \Verb+spath component+ object (if non-empty).

 

 

This is the previous \Verb+spath component+ object (if non-empty).

The methods for \Verb+spath component+s are as follows.

 

 

This is the initialiser method.

The argument should be the previous component in the array.

 

 

This method, and the following ones, are exactly as in the \Verb+spath+ object.

 

 

This sets the \Verb+spath+ attribute of this object.

 

 

This applies a method to all of the \Verb+spath+ objects in the array, starting with the current path and proceding to the next component, and so on.

The first argument is the method name, the second is any argument that is to be passed to that method.

 

 

This applies a method to all of the \Verb+spath+ objects in the array, starting with the current path and proceding to the previous component, and so on.

There is an additional command for use when creating an array of \Verb+spath component+s.

This is \Verb+\spathsplit+.

It takes two arguments.

The first is a macro that will become the first component of an array of \Verb+spath component+s.

The second is a macro containing a soft path.

The soft path will be split into pieces according to its components (that is, at the \Verb+moveto+s) and stored in the array.

At the moment, the last component is (temporarily) available at the end of the split as the \Verb+\spath@this@component+ macro.