\HeaderA{llines}{Replacements of traditional graphics functions}{llines}
\aliasA{larrows}{llines}{larrows}
\methaliasA{llines.default}{llines}{llines.default}
\aliasA{lplot.xy}{llines}{lplot.xy}
\aliasA{lpoints}{llines}{lpoints}
\methaliasA{lpoints.default}{llines}{lpoints.default}
\aliasA{lpolygon}{llines}{lpolygon}
\aliasA{lrect}{llines}{lrect}
\aliasA{lsegments}{llines}{lsegments}
\aliasA{ltext}{llines}{ltext}
\methaliasA{ltext.default}{llines}{ltext.default}
\aliasA{panel.arrows}{llines}{panel.arrows}
\aliasA{panel.lines}{llines}{panel.lines}
\aliasA{panel.points}{llines}{panel.points}
\aliasA{panel.polygon}{llines}{panel.polygon}
\aliasA{panel.rect}{llines}{panel.rect}
\aliasA{panel.segments}{llines}{panel.segments}
\aliasA{panel.text}{llines}{panel.text}
\keyword{dplot}{llines}
\begin{Description}\relax
These functions are intended to replace common low level traditional
graphics functions, primarily for use in panel functions.  The
originals can not be used (at least not easily) because lattice panel
functions need to use grid graphics.  Low level drawing functions in
grid can be used directly as well, and is often more flexible.  These
functions are provided for convenience and portability.
\end{Description}
\begin{Usage}
\begin{verbatim}
lplot.xy(xy, type, pch, lty, col, cex, lwd,
         font, fontfamily, fontface,
         col.line, alpha, fill,
         origin = 0, ...)

llines(x, ...)
lpoints(x, ...)
ltext(x, ...)

## Default S3 method:
llines(x, y = NULL, type = "l",
       col, alpha, lty, lwd, ...)
## Default S3 method:
lpoints(x, y = NULL, type = "p", col, pch, alpha, fill,
        font, fontfamily, fontface, cex, ...)  
## Default S3 method:
ltext(x, y = NULL, labels = seq_along(x),
      col, alpha, cex, srt = 0,
      lineheight, font, fontfamily, fontface,
      adj = c(0.5, 0.5), pos = NULL, offset = 0.5, ...)  

lsegments(x0, y0, x1, y1, x2, y2,
          col, alpha, lty, lwd, ...)
lrect(xleft, ybottom, xright, ytop,
      x = (xleft + xright) / 2,
      y = (ybottom + ytop) / 2,
      width = xright - xleft,
      height = ytop - ybottom,
      col = "transparent",
      border = "black",
      lty = 1, lwd = 1, alpha = 1,
      just = "center",
      hjust = NULL, vjust = NULL,
      ...)
larrows(x0 = NULL, y0 = NULL, x1, y1, x2 = NULL, y2 = NULL,
        angle = 30, code = 2, length = 0.25, unit = "inches",
        ends = switch(code, "first", "last", "both"),
        type = "open",
        col = add.line$col,
        alpha = add.line$alpha,
        lty = add.line$lty,
        lwd = add.line$lwd,
        fill = NULL, ...)
lpolygon(x, y = NULL,
         border = "black", col = "transparent", ...)

panel.lines(...)
panel.points(...)
panel.segments(...)
panel.text(...)
panel.rect(...)
panel.arrows(...)
panel.polygon(...)
\end{verbatim}
\end{Usage}
\begin{Arguments}
\begin{ldescription}
\item[\code{ x, y, x0, y0, x1, y1, x2, y2, xy}] locations. \code{x2} and
\code{y2} are available for for S compatibility.  
\item[\code{length, unit}] determines extent of arrow head.  \code{length} specifies the length
in terms of \code{unit}, which can be any valid grid unit as long as
it doesn't need a \code{data} argument.  \code{unit} defaults to
inches, which is the only option in the base version of the
function, \code{\LinkA{arrows}{arrows}}.  
\item[\code{angle, code, type, labels, srt, adj, pos, offset}] arguments
controlling behaviour.  See respective base functions for details.
For \code{larrows} and \code{panel.larrows}, \code{type} is either
\code{"open"} or \code{"closed"}, indicating the type of
arrowhead. 
\item[\code{ends}] serves the same function as \code{code}, using
descriptive names rather than integer codes.  If specified, this
overrides \code{code}
\item[\code{col, alpha, lty, lwd, fill, pch, cex, lineheight, font,
fontfamily, fontface, col.line, border}] graphical parameters.
\code{fill} applies to points when \code{pch} is in \code{21:25} and
specifies the fill color, similar to the \code{bg} argument in the
base graphics function \code{\LinkA{points}{points}}. For devices that
support alpha-transparency, a numeric argument \code{alpha} between
0 and 1 can controls transparency.  Be careful with this, since for
devices that do not support alpha-transparency, nothing will be
drawn at all if this is set to anything other than 0.

\item[\code{origin}] for \code{type="h"} or \code{type="H"}, the value to
which lines drop down. 
\item[\code{xleft, ybottom, xright, ytop}] see \code{\LinkA{rect}{rect}}
\item[\code{width, height, just, hjust, vjust}] finer control over
rectangles, see \code{\LinkA{grid.rect}{grid.rect}} 
\item[\code{...}] extra arguments, passed on to lower level functions as
appropriate.  
\end{ldescription}
\end{Arguments}
\begin{Details}\relax
These functions are meant to be grid replacements of the corresponding
base R graphics functions, to allow existing Trellis code to be used
with minimal modification.  The functions \code{panel.*} are
essentally identical to the \code{l*} versions, are recommended for
use in new code (as opposed to ported code) as they have more readable
names.

See the documentation of the base functions for usage. Not all
arguments are always supported. All these correspond to the default
methods only.
\end{Details}
\begin{Note}\relax
There is a new \code{type="H"} option wherever appropriate, which is
similar to \code{type="h"}, but with horizontal lines.
\end{Note}
\begin{Author}\relax
Deepayan Sarkar \email{Deepayan.Sarkar@R-project.org}
\end{Author}
\begin{SeeAlso}\relax
\code{\LinkA{points}{points}}, \code{\LinkA{lines}{lines}}, \code{\LinkA{rect}{rect}},
\code{\LinkA{text}{text}}, \code{\LinkA{segments}{segments}}, \code{\LinkA{arrows}{arrows}},
\code{\LinkA{Lattice}{Lattice}}
\end{SeeAlso}

