@r-universe/webr 2023.6.11 → 2023.6.21

package/dist/vfs/usr/lib/R/library/grid/doc/changes.txt

@@ -0,0 +1,1714 @@
+
+Changes from grid_4.2.* to grid_4.3.0:
+-------------------------------------
+
+1.  New isClosed() function so can provide (sensible) default for 'closed'
+    argument in grobCoords().
+
+2.  Bug fix:  grid.display.list(TRUE) incorrectly initialised the 'grid'
+    display list.  Thanks to Kaiguang Zhao for the bug report.
+
+3.  Bug fix:  fix for "polygon edge not found" (at least when font
+    cannot be found).  Fixes ggplot2 issue 2252 (hopefully).
+
+4.  Improvements to polygonEdge() for very tall and thin or wide and short
+    polygons; fix to textRect() so that it returns vertices anti-clockwise;
+    changes to L_textBounds() so that edgex/edgey are not calculated if theta is
+    NA (which is set by, e.g., widthDetails()).  May also have positive
+    impact for ggplot2 issue 2252.
+
+
+Changes from grid_4.1.* to grid_4.2.0:
+-------------------------------------
+
+1.  New 'vpPath' argument to grid.grep() so that we can ask for
+    matching grobs WITH vpPaths WITHOUT having to ask for matching
+    viewports, e.g., grid.grep("path", vpPath=TRUE).
+
+    The value of 'vpPath' defaults to the value of 'viewports', so ...
+
+    grid.grep("path", viewports=TRUE)
+
+    ... behaves as before.
+
+2.  New grid.group(), grid.define(), and grid.use() functions for
+    defining and using "isolated groups" (on supported devices).
+    These can be used to draw content in isolation before combining
+    the content with the main image, to apply compositing operators
+    other than "over", and to apply affine transformations to
+    content.
+
+3.  New grid.stroke(), grid.fill(), and grid.fillStroke() functions
+    for defining a path (based on a grob) and then stroking and/or
+    filling that path.
+
+4.  viewport(clip) can now be a path, from as.path().  This defines a
+    clipping path and allows the fill rule for the path to be
+    specified.
+
+5.  Text and raster content can now be included in patterns,
+    (clipping) paths, and masks (and groups).  (On supported devices.)
+
+6.  The fixed limit on the number of patterns, clipping paths, and/or
+    masks on Cairo-based devices has been removed.
+
+7.  Fix for reinitialising gpar settings when pushViewport() then
+    grid.newpage() WITHOUT up/popViewport().
+
+8.  Clipping paths and masks are turned off (initially) when resolving
+    a pattern.
+
+9.  Stricter rules to disallow pattern, clipping path, mask, group, or
+    path within clipping path or path.
+
+10. Fix for replayPlot() of an "empty" 'grid' "plot"
+    (where recordPlot() was called with 'grid' loaded, 
+     but with no 'grid' drawing performed).
+
+    Bug 18237 (Thanks to Kevin Ushey for bug report).
+
+
+Changes from grid_4.0.* to grid_4.1.0:
+-------------------------------------
+
+1.  Bug fix for grid.curve() with vertical or horizontal "curve".
+    Thanks to Patrick Breheney for the report.
+
+2.  Bug fix for grid.pack(side="[left|top]").
+    Thanks to Deepayan Sarkar for the report.
+
+3.  New editViewport() function.
+
+4.  gpar(fill) can now be a linearGradient() or radialGradient() or 
+    pattern().
+
+5.  viewport(clip) can now be a grob (that defines a clipping path).
+
+6.  New viewport(mask) argument that can be "none", "inherit", or
+    a grob (that defines a mask).
+
+
+Changes from grid_3.6.* to grid_4.0.0:
+-------------------------------------
+
+1.  upViewport() or popViewport() now correctly reverts to previous
+    gpar() settings.  
+
+    It used to always revert to previous viewport gpar() settings, 
+    but that is wrong if we are coming out of a viewport that 
+    is a 'childrenvp' of a gTree and the gTree has gpar() settings
+    (in that case we should revert to the gTree gpar() settings).
+
+    Reported by Nicolas Coutin.
+
+2.  Internal reimplementation of units, thanks to Thomas Lin Pedersen,
+    which makes operations on units MUCH faster.
+
+    Only user-visible change is printing of results of unit arithmetic,
+    which now always looks like a call to sum(), and a new unit.psum()
+    function.
+
+    Internally, there are now just "simpleUnit" and "unit" (no more
+    "unit.arithmetic" and "unit.list").
+
+
+Changes from grid_3.5.* to grid_3.6.0:
+-------------------------------------
+
+1.  New functions deviceLoc() and deviceDim().
+
+2.  Improve handling of graphics devices in grid.grabExpr().
+    Should now work when multiple graphics devices already open
+    (e.g., within 'knitr' document).
+
+3.  Fix bug in grid.layout() when viewport has negative width/height
+    (e.g., due to being sized in "native" units within viewport
+     with flipped scales).
+
+    Thanks to report by Silas Dean.
+
+4.  Add 'wrap.grob' argument to grid.grab() and grid.grabExpr()
+    to allow wrapping of grobs as well as viewports (if both
+    'wrap' and 'wrap.grob' are TRUE.
+
+    Also, no longer check for duplicate grob names at top-level
+    if 'wrap' is TRUE.
+
+    Also, do not start new page if 'wrap' is TRUE.
+
+    Thanks to report from John Bullock.
+
+5.  Exported makeContent.default() (so that
+    external packages can do more stuff with grobs)
+
+6.  New 'pathId' and 'pathId.lengths' arguments for grid.path()
+    to allow multiple paths to be drawn at once.
+
+    Contributed by Thomas Lin Pedersen.
+
+7.  New grobCoords() and grobPoints() functions to calculate points 
+    along the perimeter (or length) of a grob.
+
+8.  Internal changes to graphical parameter setting to speed things
+    up a bit.  
+    
+    Contributed by Thomas Lin Pedersen.
+
+
+Changes from grid_3.4.* to grid_3.5.0:
+-------------------------------------
+
+1.  Fix for current.vpTree() so that it puts you back in the right
+    place in the viewport tree if there are nested viewports with
+    the same name (e.g., pushViewport(vp, vp)).
+
+    Reported by Prem Thomas.
+
+2.  Added 'device' (and 'width' and 'height') arguments to grid.grabExpr()
+
+    Suggestion from Claus Wilke.
+
+
+Changes from grid_3.3.* to grid_3.4.0:
+-------------------------------------
+
+1.  Added format() method for units, so, for example, the number of 
+    digits printed for numeric values can be controlled.
+
+    grid.show.layout() now uses format() for annotating layout
+    widths and heights.
+
+2.  More robust handling of NA values in graphical parameter settings
+    that affect text.  NA values for fontsize, lineheight, cex, and
+    fontfamily are ignored, i.e., inherited from parent drawing context.
+    A mixture of NA and non-NA generates an error.
+
+3.  Improved support for calcStringMetric() function (and
+    stringAscent() and stringDescent() and grobAscent() and
+    grobDescent()) so that text encoding is now handled.
+
+    Reported by Hakon Malmedal and Hadley Wickham.
+
+
+Changes from grid_3.2.* to grid_3.3.0:
+-------------------------------------
+
+1.  Added "pseudonym" units to check made in absolute.size() so that,
+    for example, absolute.size(unit(1, "in")) works properly
+    (reported by Baptiste Auguie).
+
+2.  Registered absolute.units() methods in NAMESPACE, so that, for
+    example, a call to absolute.size(unit(1,"npc") + unit(2,"mm"))
+    works outside of 'grid' (reported by Baptiste Auguie).
+
+3.  Refactored grid.draw() so that grid.draw(NULL) now works 
+    (by doing nothing).  Reported by Hadley Wickham.
+
+4.  Modified grid.ls() so that it returns nothing if there are no
+    active devices (rather than opening a new device).
+  
+5.  Modified grid.grep() so that it returns an empty list (rather than
+    throwing an error) when the 'grid' display list is empty.
+
+6.  Added subassignment methods for unit objects
+    (e.g., x <- unit(1:3, "cm"); x[2] <- unit(.5, "npc"))
+
+    Thanks to Baptiste Auguie for code suggestions.
+
+
+Changes from grid_3.1.* to grid_3.2.0:
+-------------------------------------
+
+1.  Fixed evaluation of "pure null" units (by making evaluation recursive).
+    Previously, for example, a unit list with a unit list as its first
+    component would evaluate to NA.  This typically only affects layouts 
+    in grid.
+
+    Problem reported by Baptiste Auguie.
+
+2.  Fixed problem in validDetails.beziergrob(), which used to fail if
+    you tried to specify 'id.lengths'
+
+3.  Fixed bug in downViewport() when descending more than one
+    viewport.  It was possible for this to end up with the wrong
+    clipping region (because if you ended up in a viewport that
+    inherited its clipping region from a parent, that clipping region
+    was not enforced).
+
+
+Changes from grid_3.0.* to grid_3.1.0:
+-------------------------------------
+
+1.  New current.rotation() function.
+
+2.  vpPath() and gPath() now automatically expand any embedded path 
+    separators in their input.
+
+3.  New functions depth(), for determining the depth of a viewport 
+    hierarchy or path, and explode(), for expanding a path into
+    its components.
+
+4.  New function grid.grep()
+    (based on ideas and code from Simon Potter).
+
+5.  The grid.force() function now accepts an explicit grob to (draw 
+    and) force or a gPath to force a specific already-drawn grob.
+    Ditto the grid.revert() function.
+
+6.  New current.parent() function to return parent of current viewport.
+
+7.  New resolveRasterSize() function.
+
+8.  Made 'vp' argument of current.viewport() defunct.
+
+9.  Deprecated functions made defunct: 
+    grid.grob, grid.arrows, arrowsGrob, grid.convert, grid.convertX,
+    grid.convertY, grid.convertWidth, grid.convertHeight,
+    grid.collection, push.viewport, pop.viewport, viewport.transform,
+    draw.details, convertNative.
+
+10. Down viewports are now recorded on the display list as full-depth
+    strict vpPaths even when downViewport() is called with non-strict
+    vpPath (which can produce a down viewport of greater depth than
+    the depth of the vpPath).
+
+11. Exported generic forceGrob().
+
+12. Bug fix for recording viewport pushes on the graphics engine display
+    list (reported by the friendly folks from RStudio).
+
+    The bug could be tickled by copying a grid scene from one graphics
+    device to another and then attempting to navigate within 
+    viewports on the original graphics device.
+
+13. Better defenses against division-by-zero in unit resolution/conversion
+    (see ./DivByZero.txt).
+
+
+Changes from grid_3.0.0 to grid_3.0.1:
+-------------------------------------
+
+1.  Added str() method for "unit.arithmetic"
+    Reported by Andreas Leha.
+
+
+Changes from grid_2.15.0 to grid_3.0.0:
+--------------------------------------
+
+1.  Bug fix for showViewport() when the viewport is a
+    "vpStack" and one of the components of the stack
+    is NOT just a simple viewport (e.g., when one of
+    the components of the "vpStack" is a "vpStack").
+
+2.  Bug fix for grid.ls(viewports = TRUE) when listing a
+    "vpStack" and one of the components of the stack
+    is NOT just a simple viewport (e.g., when one of
+    the components of the "vpStack" is a "vpStack").
+
+3.  Added support for "vpPaths" within a "vpStack",
+    "vpList", or "vpTree" (i.e., mixing of viewports
+    and "vpPaths").
+
+4.  New functions grid.reorder() and reorderGrob() to  
+    modify the order in which the children of a gTree 
+    are drawn.
+
+5.  Bug fix for grid.ls() to report children of a gTree
+    in the correct order.
+
+6.  New makeContext() and makeContent() "hook" functions
+    to allow alternative method for creating custom grobs.
+
+7.  Standard behaviour for grobs is now to use upViewport()
+    rather than popViewport() on the 'vp' slot.
+
+8.  New grid.force() function to provide access to grobs 
+    that are generated only at drawing time (for grobs that 
+    use the new makeContent() hook).
+
+9.  New grid.revert() function to revert the effect of 
+    grid.force().
+
+10. Implementation of "xaxis", "yaxis", "frame", "cellGrob",
+    "roundrect", "beziergrob", "curve", and "functiongrob"
+    changed to use makeContext() and makeContent() hooks.
+
+11. New grid.delay() and delayGrob() functions;  analogues
+    of grid.record() and recordGrob() that are implemented
+    via makeContent() hooks.
+
+
+Changes from grid_2.14.0 to grid_2.15.0:
+---------------------------------------
+
+1.  Added calcStringMetric() function.
+
+2.  Added "strascent" and "strdescent" units, plus 
+    stringAscent() and stringDescent() convenience functions.
+
+3.  Added "grobascent" and "grobdescent" units, plus 
+    grobAscent() and grobDescent() convenience functions.
+
+    The "ascent" of a grob is equivalent to its height by default,
+    but ascentDetails() methods can be written 
+    (e.g., text grobs are different).
+
+    The "descent" of a grob is zero by default,
+    but descentDetails() methods can be written 
+    (e.g., text grobs are different).
+
+4.  Fix for xsplinePoints() so that it copes with xspline grob
+    with non-NULL 'id' AND so that it takes the 'vp' and 'gp'
+    settings into account.
+
+5.  Added grid.bezier() function to draw Bezier curve
+    (using an X-spline approximation).
+
+    Also added bezierPoints() function.
+
+6.  Added grid.DLapply() function.
+
+
+Changes from grid_2.12.0 to grid_2.13.0:
+---------------------------------------
+
+1.  Added grid.function() for drawing lines to represent functions.
+
+2.  Fixed bug in calculation of x, y, width, and height of segments
+    grobs.
+
+3.  Fixed bug in grid.grab(wrap = TRUE) when the scene includes 
+    downViewport()s.
+
+4.  Added showGrob() function.
+
+
+Changes from grid_2.11.0 to grid_2.12.0:
+---------------------------------------
+
+1.  Neither width nor height need to be specified in 
+    grid.raster().  The image aspect ratio will be used
+    to calculate an appropriate image size for the 
+    current viewport.
+
+2.  Added [x|y|width|height]Details() methods for "rastergrob"s
+
+3.  "roundrect" grobs now obey their 'just' setting
+    (bug reported by Beau Benjamin Bruce)
+
+4.  Added grid.path() for rendering paths with holes.
+
+
+Changes from grid_2.10.0 to grid_2.11.0:
+---------------------------------------
+
+1.  Added xsplinePoints() function to return the (x, y) 
+    locations that an Xspline would be drawn through.
+    Useful for, e.g., clipping an Xspline against a
+    boundary.
+
+2.  Added grid.raster() function for rendering raster images.
+
+3.  Added grid.cap() function for capturing output on
+    current graphics device as a raster image.
+
+4.  Fixed PROTECT() bug in grid.rect() PR#14199
+    Thanks to Andrew Runnalls for the bug report.
+
+5.  Fixed multiple problems in rep.unit() and unit subsetting.
+    Motivated by PR#14170.  Thanks to Bert Gunter.
+    
+
+Changes from grid_2.9.0 to grid_2.10.0:
+--------------------------------------
+
+1.  Added showViewport() function for displaying viewport trees
+    graphically.
+
+2.  Fixed bug in unit() indexing;  negative integer indices now work.
+
+3.  Modified behaviour of editGrob() and addGrob() so that they 
+    return the original grob if the specified gPath does not exist,
+    and issue a warning (if new argument 'warn' is TRUE).
+    
+
+Changes from grid_2.8.0 to grid_2.9.0:
+-------------------------------------
+
+1.  Copied grid.roundRect() from 'RGraphics' package into 'grid'.
+
+    Renamed to grid.roundrect() and also used roundrectGrob()
+    rather than roundRect(), partly for more consistent naming,
+    partly to avoid namespace collision until original functions
+    get removed from 'RGraphics' package.
+
+2.  Fixed bug in grid.curve() when curve is horizontal or vertical
+    straight line.
+
+3.  Exposed is.grob() and valid.just() via the NAMESPACE.
+
+4.  Fixed bug in downViewport(), which meant that unsuccessful
+    downViewport()s were still being recorded on the graphics
+    engine display list.  This could cause interesting results
+    when a window is resized (i.e., when the display list is 
+    replayed).  
+
+    Bug reported by Felix Andrews.
+
+5.  Added some pseudonyms for come units.  For example, it is now
+    possible to specify just "in" instead of "inches".
+
+
+Changes from grid_2.7.0 to grid_2.8.0:
+-------------------------------------
+
+1.  Added grid.null() and nullGrob();  grob that is guaranteed
+    to have zero-width, zero-height, and draw nothing.
+
+    Useful as zero-size placeholder AND as invisible reference
+    point for other grobs to draw relative to.
+
+2.  Fixed bug in listing, via grid.ls(), of frame grobs.  If the frame
+    had a vpPath in its 'vp' component, you got an error from vpStack().
+
+    Problem reported by Hadley Wickham.
+
+3.  Fixed a bug in grid.ls() when attempting to list the display list
+    following the removal of a grob (i.e., so that there were NULLs
+    in the display list).
+
+    Problem reported by Felix Andrews.
+
+
+Changes from grid_2.6.0 to grid_2.7.0:
+-------------------------------------
+
+1.  Grid will no longer complain about clipping to a rotated
+    viewport if the rotation is a multiple of 90 degrees.
+
+    Prompted by report from Gustaf Rydevik.
+
+2.  Open Xsplines must have zero shape for first and last
+    control point, but this was not being enforced correctly
+    for the case where there were multiple Xsplines in a
+    single grid.xspline() call (i.e., with use of 'id' or
+    'id.length').  The problem can be seen with this code
+    (most curves do not connect to the first control point
+    [there are also subtle errors in the curve shapes]):
+
+        grid.newpage()
+        pushViewport(viewport(w=.5, h=.5))
+        grid.xspline(x=outer(c(0, .5, 1, .5), 5:1/5),
+                     s=1,
+                     y=outer(c(.5, 1, .5, 0), 5:1/5),
+                     id.lengths=rep(4, 5),
+                     gp=gpar(col=1:5, lwd=3))
+        grid.rect()
+
+3.  Frame grobs have been improved so that all of the viewports
+    that are generated during the drawing of a frame (and its
+    cells) are left on the display list (previously, they were
+    popped).
+
+    This has implications particularly for ggplot[2] because
+    it means that it is now possible to downViewport() to 
+    viewports created during the drawing of a ggplot[2] plot
+    to, for example, add further annotations to the plot.
+
+4.  Small fixes to grid.ls():
+
+    - viewports pushed by cellGrobs within frames are now
+      shown by grid.ls()
+
+    - fixed warning (bug really) when display list contains
+      only one grob (and padPrefix() is called).
+
+
+Changes from grid_2.5.0 to grid_2.6.0:
+-------------------------------------
+
+1.  Added grid.gedit() as convenience wrapper for grid.edit()
+    based on usage patterns of Hadley Wickham when working with
+    'ggplot' package.
+
+    Ditto, grid.gget() and grid.gremove().
+
+2.  Improved implementation of 'id' and 'id.lengths' arguments
+    for drawing multiple polygons/polylines/xsplines to gain 
+    order 2 speed improvement.  
+
+    Problem independently reported by Luke Tierney, Deepayan Sarkar and
+    Vilmos Prokaj.
+
+3.  Bug fixes for grid.remove(), especially for grep=TRUE and global=TRUE
+    (i.e., removing all grobs from DL where the name matches a pattern).
+
+    Also some fixes to grid.remove() error messages when no match found.
+
+    Bug reports from Hadley Wickham.
+
+4.  New function grid.ls() for listing grob trees and viewport trees
+    (including both grob trees and viewport trees interlaced).
+
+    Useful for exploring current grob/viewport tree, explaining
+    grob/viewport trees, and programming on or debugging 
+    grob/viewport trees.
+
+
+Changes from grid_2.4.0 to grid_2.5.0:
+-------------------------------------
+
+1.  Added 'open' argument to grid.curve().  This allows, for example,
+    filling the segment of a circle.
+
+2.  Fixed bug in arrow() function:  segfault produced if either 
+    'ends' or 'type' argument are given as NULL.  Thanks to
+    Sebastien Luque for the report.
+
+
+Changes from grid_2.3.0 to grid_2.4.0:
+-------------------------------------
+
+1.  Bug fix for colour used when drawing a rectangle in a
+    rotated viewport (reported by Olaf Burger).
+
+2.  Removed 'units.per.obs' argument from grid.lines() and 
+    grid.segments() 
+
+    (This is a bug fix;  should have been removed long ago).
+
+3.  Added extra check on 'data' argument of unit(), which means
+    that if you supply a non-NULL value where the 'unit' is
+    not "str[width|height]" or "grob[x|y|width|height]", you
+    get an error.  This may impact on existing code.
+
+4.  Radii in grid.circle() are now silently converted to their
+    absolute value (negative values used to trigger an error).
+
+5.  New function grobName() for generating unique (within-session)
+    grob names (based on class of grob).
+
+    Also, modified default naming of grobs to be based on class
+    of grob.  This should not impact on existing code because
+    noone should be depending on the default names generated by grid.
+
+
+Changes from grid_2.2.0 to grid_2.3.0:
+-------------------------------------
+
+1.  Bug fix for stringWidth() and stringHeight() with mathematical 
+    annotation.
+
+    These used to always convert the argument to "character".
+    Now they let language objects (e.g., expressions) pass through.
+
+2.  New grid.xspline() function to draw X-splines (a general curve
+    approximated or interpolated relative to control points).
+
+3.  New 'arrow' argument to grid.line.to(), grid.lines(), and
+    grid.segments().  This provides a new way to specify arrow
+    heads on either end of a line.
+
+    grid.arrows() has been deprecated.
+
+    NOTE: that the new 'arrow' arguments have been added BEFORE
+    the name, gp and vp arguments so existing code that specifies
+    any of these arguments *by position* (not by name) will fail.
+
+4.  Added "[" (subset) methods for "gpar" objects.
+
+5.  New grobX() and grobY() functions for producing units 
+    describing a location on the boundary of a grob.
+
+6.  Units produced by grobX() and grobY() make use of new 
+    xDetails() and yDetails() generic functions to calculate the 
+    boundary of a grob.  Methods for these functions are provided
+    for all grid graphical primitives.
+
+7.  Bug fix for grid.polygon() when 'x' is not just a simple unit
+    (e.g., it is unit arithmetic);  'index' was being calculated
+    incorrectly so not all of polygon would be drawn or, if 
+    'id' or 'id.length' were used, only a single polygon would
+    be drawn (with unexpected shape).
+
+8.  New grid.curve() primitive for drawing a curve between two
+    locations.  
+
+    Together with new grobX() and grobY() provides support for
+    drawing simple node-and-edge graphs and flow diagrams.
+
+9.  New grid.clip() primitive for setting the clipping region
+    (more accurately, the clipping rectangle).  Has effect until
+    the next grid.clip() or when the current viewport is popped.
+
+10. New dim.layout() method for layout objects.  Allows easy
+    access to dimensions of layout via nrow() and ncol().
+
+11. unit.rep() deprecated in favour of unit method(s) for rep() function.
+
+12. unit.length() deprecated in favour of unit method(s) for length() function.
+
+13. New grid.polyline() primitive.  Just like grid.lines() except has
+    'id' and 'id.lengths' arguments.
+
+    These work like the corresponding arguments in grid.polygon() and
+    grid.xspline(), allowing multiple polylines to be drawn from a
+    single grid.polyline() call.
+
+14. Fixed drawing of top-level gList objects so that they 
+    (actually the grobs in the gList) are recorded on the 
+    grid display list.
+
+    Allowed a gList to be component of a gList 
+    (the gList constructor merges sub-gList into resulting gList).
+
+    Added subset method for gList objects 
+    (so that result is still a gList).
+
+15. Bug fix for grid.rect() and grid.circle() with gpar(lty="blank").
+    (problem was actually in the graphics engine).
+    
+    Reported by John Braun (private correspondence).
+
+
+Changes from grid_2.1.0 to grid_2.2.0:
+-------------------------------------
+
+1.  current.vpPath() now exported.
+
+2.  Grid now uses the 'fg' and 'bg' settings (if any) for
+    graphics devices to set the initial graphical parameter
+    settings of the top-level viewport (i.e., the 'gp' arg
+    of viewport[ROOT]).
+
+3.  Fixed bug in evaluation of grobWidth(polygonGrob()).
+    The C function L_locnBounds was not exported AND
+    the widthDetails.polygon method was not exposed properly
+    via the NAMESPACE.
+
+    Reported in private correspondence by Deepayan Sarkar.
+
+    Also corrected export of heightDetails, validDetails, and	
+    widthDetails for arrows, circle, polygon, points, rect, and
+    segments primitives.
+
+
+Changes from grid_2.0.1 to grid_2.1.0:
+------------------------------------
+
+1.  preDrawDetails(), drawDetails(), and postDrawDetails() 
+    methods are now recorded on the graphics engine
+    display list.   This means that calculations within these 
+    methods are now run when a device is resized or
+    when output is copied from one device to another.  A simple
+    example (the rectangle remains 1inch wide when resizing the
+    device -- it does not in previous versions) ...
+
+        testgrob <- grob(cl="test")
+	drawDetails.test <- function(x, recording) {
+	  w <- convertWidth(unit(1, "inches"), "npc")
+	  grid.rect(width=w)
+	}
+	grid.draw(testgrob)
+
+2.  Fixed bug in grid.text() when "rot" argument has length 0.
+    (privately reported by Emmanuel Paradis)
+
+3.  New getNames() function to return just the names of all top-level
+    grobs on the display list.
+
+4.  Recording on the grid display list is turned off within 
+    preDrawDetails(), drawDetails(), and postDrawDetails() methods.
+
+    This means that you do not need to worry about specifying
+    recording=FALSE within these methods.
+    
+5.  Grid should recover better from errors or user-interrupts
+    during drawing (i.e., not leave you in a strange viewport
+    or with strange graphical parameter settings).
+
+6.  New function grid.refresh() to redraw the grid display list.
+
+7.  New function grid.record() to capture calculations
+    with grid graphics output.  For example ...
+
+        grid.record({
+                      w <- convertWidth(unit(1, "inches"), "npc")
+	              grid.rect(width=w)
+                    },
+                    list())
+
+8.  grobWidth and grobHeight ("grobwidth" and "grobheight" units)
+    for primitives (text, rects, etc, ...) are now
+    calculated based on a bounding box for the relevant grob.
+
+    These used to be calculated assuming a grob was scalar
+    rather than vector.  For example, the following now behaves
+    much more sensibly ...
+
+        txt <- textGrob(c("This is a repeat", "This is a repeat"),
+	                y=1:2/3, rot=45)
+        grid.draw(txt)
+        grid.rect(width=grobWidth(txt), height=grobHeight(txt))
+
+    NOTE: this has changed the calculation of the size of a scalar
+    rect (or circle or lines) so that, for example, something like ...
+
+        grid.pack(frame, rectGrob())
+
+    ... needs to become ...
+
+        grid.pack(frame, rectGrob(), 
+                  width=unit(1, "null"), height=unit(1, "null"))
+
+    ... if you just want a rectangle that fills the space available.
+
+9.  New arguments "warn" and "wrap" for function grid.grab()
+    
+    If warn>0 will warn if know (or, if warn>1,  if even suspect) 
+    that the grab has not faithfully captured the output.  
+
+    If wrap=TRUE, will capture output by wrapping all non-grobs
+    on the display list in grobs.  Resulting gTree is less 
+    elegant and harder to work with, but should always faithfully
+    capture output.
+
+10. New function grid.grabExpr() which captures the output from
+    an expression (i.e., not from the current scene) without
+    doing any drawing (i.e., no impact on the current scene).
+
+11. upViewport() now (invisibly) returns the path that it goes up
+    (suggested by Ross Ihaka).
+
+    This makes it possible to do things like ...
+
+        upPath <- upViewport(n)
+	...
+	downViewport(upPath)
+
+    ... (i.e., navigate up and then back down to where you came from).
+
+12. The "gamma" gpar has been deprecated (this is a device property
+    not a property of graphical objects;  suggested by Ross Ihaka).
+
+13. New "lex" gpar;  a line width multiplier.
+    The final line width is calculated as ...
+
+        gpar("lex")*gpar("lwd")
+
+    ... and the multiplier is cumulative (like cex) ...
+
+      grid.rect(height=0.5, width=0.5, 
+                gp=gpar(lwd=16))                # lex = 1
+      pushViewport(viewport(gp=gpar(lex=0.5)))
+      grid.rect(height=0.5, width=0.5, 
+                gp=gpar(lwd=16, col="red"))     # lex = 0.5
+      pushViewport(viewport(gp=gpar(lex=0.5)))
+      grid.rect(height=0.5, width=0.5, 
+                gp=gpar(lwd=16, col="green"))   # lex = 0.25!
+
+    This (along with cex) provides support for "zooming" a grid scene.
+
+14. grid.text() now handles any language object as mathematical
+    annotation (instead of just expressions).  For example ...
+
+      grid.text(call("sin", pi))
+ 
+15. plotViewport() has default value for "margins" argument (that match
+    the default value for par(mar)).
+
+16. The "extension" argument to dataViewport() can now be vector, 
+    in which case the first value is used to extend the xscale and
+    the second value is used to extend the y scale.
+    (suggested by Ross Ihaka).
+
+17. All "just" arguments (for viewports, layouts, rectangles, text)
+    can now be numeric values (typically between 0 [left] and 1 [right])
+    as well as character values ("left", "right", ...).
+
+    For rectangles and text, there are additional "hjust" and "vjust"
+    arguments which allow numeric vectors of justification in
+    each direction (e.g., so that several pieces of text can have 
+    different justifications).  If these are specified, they
+    override the "just" argument.
+    (suggested by Ross Ihaka)
+
+18. New "edits" argument for grid.xaxis() and grid.yaxis() to
+    allow specification of on-the-fly edits to axis children
+    (when at == NULL, so children are generated on-the-fly).
+
+19. applyEdit(x, edit) returns x if target of edit (i.e., child
+    specified by a gPath) cannot be found.
+
+20. Fix for calculation of length of max/min/sum unit.  Length is
+    now (correctly) reported as 1 (was reported as length of first arg).
+
+21. Viewport names can now be any string (they used to have to be a
+    valid R symbol).
+
+    The documentation now says that grob names can be any string
+    (they always could be, but the documentation said they had to
+     be a valid R symbol)
+
+22. The "label" argument for grid.xaxis() and grid.yaxis() can now 
+    also be a language object or string vector, in which case it 
+    specifies custom labels for the tick marks.
+
+
+Changes from grid_2.0.0 to grid_2.0.1:
+------------------------------------
+
+1.  Fixed bug in grid.newpage();  it was not starting new page
+    on first grid call if there was already traditional graphics
+    output on the device (i.e., the device was "dirty" but not 
+    "grid dirty").
+
+2.  Fixed bug in grid.grab() when no viewports have been pushed.
+
+
+Changes from grid_1.9.0 to grid_2.0.0:
+------------------------------------
+
+1.  Calculation of number of circles to draw in circleGrob now
+    looks at length of y and r as well as length of x.
+
+2.  Calculation of number of rectangles to draw in rectGrob now
+    looks at length of y, w, and h as well as length of x.
+
+3.  All primitives (rectangles, lines, text, ...) now handle 
+    non-finite values (NA, Inf, -Inf, NaN) for locations and
+    sizes.
+
+    Non-finite values for locations, sizes, and scales of
+    viewports result in error messages.
+
+    There is a new vignette("nonfinite") which describes this
+    new behaviour.
+
+4.  Fixed (unreported) bug in drawing circles.  Now checks that
+    radius is non-negative.
+
+5.  downViewport() now reports the depth it went down to find a 
+    viewport.  Handy for "going back" to where you started, e.g., ...
+
+      depth <- downViewport("vpname")
+      <draw stuff>
+      upViewport(depth)
+
+6.  The "alpha" gpar() is now combined with the alpha channel of
+    colours when creating a gcontext as follows:
+
+      finalAlpha = gpar("alpha")*(R_ALPHA(col)/255)
+
+    This means that gpar(alpha=) settings now affect internal
+    colours so grid alpha transparency settings now are sent to
+    graphics devices.
+
+    The alpha setting is also cumulative.  For example, ...
+      
+      grid.rect(width=0.5, height=0.5, 
+                gp=gpar(fill="blue"))              # alpha = 1
+      pushViewport(viewport(gp=gpar(alpha=0.5)))
+      grid.rect(height=0.25, gp=gpar(fill="red"))  # alpha = 0.5
+      pushViewport(viewport(gp=gpar(alpha=0.5)))
+      grid.rect(width=0.25, gp=gpar(fill="red"))   # alpha = 0.25 !
+
+7.  Editing a gp slot in a grob is now incremental.  For example ...
+
+      grid.lines(name="line")
+      grid.edit("line", gp=gpar(col="red")) # line turns red
+      grid.edit("line", gp=gpar(lwd=3)) # line becomes thick AND STAYS red
+      
+8.  The "cex" gpar is now cumulative.  For example ...
+      
+      grid.rect(height=unit(4, "char")) # cex = 1
+      pushViewport(viewport(gp=gpar(cex=0.5)))
+      grid.rect(height=unit(4, "char")) # cex = 0.5
+      pushViewport(viewport(gp=gpar(cex=0.5)))
+      grid.rect(height=unit(4, "char")) # cex = 0.125 !!!
+
+9.  New childNames() function to list the names of children
+    of a gTree.
+
+10. The "grep" and "global" arguments have been implemented for 
+    grid.[add|edit|get|remove]Grob() functions.
+
+    The "grep" argument has also been implemented for the
+    grid.set() and setGrob().
+
+11. New function grid.grab() which creates a gTree from the 
+    current display list (i.e., the current page of output can
+    be converted into a single gTree object with all grobs
+    on the current page as children of the gTree and all the 
+    viewports used in drawing the current page in the childrenvp
+    slot of the gTree).
+
+12. New "lineend", "linejoin", and "linemitre" gpar()s:
+
+      line end can be "round", "butt", or "square".
+      line join can be "round", "mitre", or "bevel".
+      line mitre can be any number larger than 1
+        (controls when a mitre join gets turned into a bevel join;  
+         proportional to angle between lines at join;
+	 very big number means that conversion only happens for lines
+	 that are almost parallel at join).
+
+13. New grid.prompt() function for controlling whether the user is
+    prompted before starting a new page of output.
+
+    Grid no longer responds to the par(ask) setting in the "graphics"
+    package.
+
+
+Changes from grid_1.9.0 to grid_1.9.1:
+------------------------------------
+
+1.  Fixed (unreported) bug in internal calculation of unitArithmetic
+    object when op = * and numeric operand longer than unit operand
+
+2.  Fixed (unreported) bug in creation of unitArithmetic objects
+    when numeric operand is integer.  All numeric operands are now
+    coerced to real.
+
+
+Changes from grid_1.8.0 to grid_1.9.0:
+------------------------------------
+
+1.  Renamed push/pop.viewport() to push/popViewport().
+
+2.  Added upViewport(), downViewport(), and seekViewport() to 
+    allow creation and navigation of viewport tree 
+    (rather than just viewport stack).
+
+3.  Added id and id.lengths arguments to grid.polygon() to allow
+    multiple polygons within single grid.polygon() call.
+
+4.  Added vpList(), vpStack(), vpTree(), and current.vpTree()
+    to allow creation of viewport "bundles" that may be pushed
+    at once (lists are pushed in parallel, stacks in series).
+
+    current.vpTree() returns the current viewport tree.
+
+5.  Added vpPath() to allow specification of viewport path
+    in downViewport() and seekViewport().
+    
+    See ?viewports for an example of its use.
+
+    NOTE: it is also possible to specify a path directly,
+    e.g., something like "vp1::vp2", but this is only
+    advised for interactive use (in case I decide to change the
+    separator :: in later versions).
+
+6.  Added "just" argument to grid.layout() to allow justification
+    of layout relative to parent viewport *IF* the layout is not
+    the same size as the viewport.  There's an example in
+    help(grid.layout).
+
+7.  Allowed the "vp" slot in a grob to be a viewport name or a
+    vpPath.  The interpretation of these new alternatives is to
+    call downViewport() with the name or vpPath before drawing the
+    grob and upViewport() the appropriate amount after drawing the
+    grob.  Here's an example of the possible usage:
+
+        pushViewport(viewport(w=.5, h=.5, name="A"))
+	grid.rect()
+	pushViewport(viewport(w=.5, h=.5, name="B"))
+	grid.rect(gp=gpar(col="grey"))
+	upViewport(2)
+	grid.rect(vp="A", gp=gpar(fill="red"))
+	grid.rect(vp=vpPath("A", "B"), gp=gpar(fill="blue"))
+
+8.  Added engine.display.list() function.  This allows the user to
+    tell grid NOT to use the graphics engine display list and to handle
+    ALL redraws using its own display list (including redraws after
+    device resizes and copies).
+
+    This provides a way to avoid some of the problems with resizing
+    a device when you have used grid.convert(), or the gridBase package,
+    or even base functions such as legend().
+
+    There is a document discussing the use of display lists in grid
+    on the grid web site 
+    (http://www.stat.auckland.ac.nz/~paul/grid/grid.html)
+
+9.  Changed the implementation of grob objects.  They are no longer 
+    implemented as external references.  They are now regular R objects
+    which copy-by-value.  This means that they can be saved/loaded
+    like normal R objects.  In order to retain some existing grob
+    behaviour, the following changes were necessary:
+
+    - grobs all now have a "name" slot.  The grob name is used to
+      uniquely identify a "drawn" grob (i.e., a grob on the display
+      list).  
+    - grid.edit() and grid.pack() now take a grob name as the first
+      argument instead of a grob.  (Actually, they take a gPath -
+      see below)
+    - the "grobwidth" and "grobheight" units take either a grob
+      OR a grob name (actually a gPath - see below).  Only in the 
+      latter case will the unit be updated if the grob "pointed to"
+      is modified.
+
+    In addition, the following features are now possible with grobs:
+
+    - grobs now save()/load() like any normal R object.
+    - many grid.*() functions now have a *Grob() counterpart.  The
+      grid.*() version is used for its side-effect of drawing 
+      something or modifying something which has been drawn;  the
+      *Grob() version is used for its return value, which is a grob.
+      This makes it more convenient to just work with grob objects without
+      producing any graphical output (by using the *Grob() functions).
+    - there is a gTree object (derived from grob), which is a grob 
+      which can have children.  A gTree also has a "childrenvp" slot
+      which is a viewport which is pushed and then "up"ed before the
+      children are drawn;  this allows the children of a gTree to 
+      place themselves somewhere in the viewports specified in the
+      childrenvp by having a vpPath in their vp slot. 
+    - there is a gPath object, which is essentially a concatenation
+      of grob names.  This is used to specify the child of (a child of ...)
+      a gTree.
+    - there is a new API for creating/accessing/modifying grob objects:
+      grid.add(), grid.remove(), grid.edit(), grid.get() (and their
+      *Grob() counterparts can be used to add, remove, edit, or extract
+      a grob or the child of a gTree.  NOTE: the new grid.edit() API
+      is incompatible with the previous version.
+
+10. Added stringWidth(), stringHeight(), grobWidth(), and grobHeight()
+    convenience functions (they produce "strwidth", "strheight",
+    "grobwidth", and "grobheight" unit objects, respectively).
+
+11. Allowed viewports to turn off clipping altogether.  Possible settings
+    for viewport clip arg are now:
+
+      "on"      = clip to the viewport (was TRUE)
+      "inherit" = clip to whatever parent says (was FALSE)
+      "off"     = turn off clipping 
+
+    Still accept logical values (and NA maps to "off")
+
+
+Changes from grid_1.8.0 to grid_1.8.1:
+------------------------------------
+
+1.  I have effectively disabled the "mystrwidth", "mystrheight",
+    "mychars", and "mylines" units.  These are now identical in
+    behaviour to the equivalent units without the "my".
+
+    Another way to look at it is that I have modified the behaviour
+    of "lines", "chars", "strwidth", and "strheight" so that they
+    ALWAYS obey the latest gpar settings (including any gpar 
+    settings in a grob).  
+
+    Some examples ...
+
+    This text is sized AND positioned in terms of a fontsize of 6:
+
+      grid.text("small text and small lines", y=unit(2, "lines"), 
+                gp=gpar(fontsize=6))
+
+    This text is 6 pt in size, but is positioned in terms of the
+    (default on X11) fontsize 12:
+
+      push.viewport(viewport(y=unit(2, "lines")))
+      grid.text("small test and big lines", gp=gpar(fontsize=6))
+      pop.viewport()
+
+2.  Fixed a bug in the calculation of "grobwidth" and "grobheight"
+    units.  The following code demonstrates the problem (the black
+    rectangle should snugly bound the grey rectangles):
+
+      grid.newpage()
+      # Create a frame with fontsize=6
+      gf <- grid.frame(layout=grid.layout(10, 10,
+                       widths=unit(rep(1, 10), "strwidth",
+                         as.list(rep("o", 10))),
+                       heights=unit(rep(1, 10), "strheight",
+                         as.list(rep("o", 10)))),
+                     gp=gpar(fontsize=6))
+      # Add a rect to the frame
+      for (i in 1:10)
+        grid.place(gf, grid.rect(gp=gpar(col="grey"), draw=FALSE),
+                   col=i, row=i)
+      grid.draw(gf)
+      # Now draw a rect around the frame
+      grid.rect(width=unit(1, "grobwidth", gf),
+                height=unit(1, "grobheight", gf))
+
+3.  Fixed a bug in the implementation of the "cex" gpar.  This is now
+    used correctly in the transformation code in unit.c
+
+    The bug was demonstrated by the following simple example
+    (the second set of points should be twice the radius of the
+    first set of points):
+
+      grid.newpage()
+      push.viewport(viewport())
+      grid.points()
+      grid.points(gp = gpar(cex = 2))
+      
+    Another demonstration from the original bug report from David Hinds:
+
+      xyplot(1:4~1:4, cex=1:4, pch=1)
+
+4.  Fixed a bug in multiplication of scalar by unit object, when the
+    scalar has length > 1.  The following example demonstrates
+    the problem:
+
+      grid.segments(x0=1:3/4, y0=0.1, x1=1:3/4,
+                    y1=1:3/4*unit(1, "npc"))
+
+    This should behave the same as:
+
+      grid.segments(x0=1:3/4, y0=0.1, x1=1:3/4,
+                    y1=unit(1:3/4, "npc"))
+      
+
+Changes from grid_0.7-4 to grid_1.8.0:
+------------------------------------
+
+1.  grid.text() now checks that the rot argument is numeric and finite.
+
+2.  dataViewport() checks for is.null(<arg>) rather than missing(<arg>)
+    and has renamed arguments x and y to xData and yData.
+
+    All to avoid confusion with specifying x= and y= in the ... argument.
+
+    This also fortuitously fixed a bug in dataViewport where the 
+    calculation of the x-range was partially dependent on the y-range(!)
+
+    Thanks to Russell Norvell for spotting and reporting the bug.
+
+3.  unit() checks that units argument is character mode.
+
+    Fix for bug (first reported by Achim Zeileis) produced by, 
+    for example ...
+
+	unit(1, 2)
+
+4.  The function absolute.units() was recursive and now uses a loop.
+
+    Fixes the following problem (from Deepayan Sarkar):
+
+        gf <- grid.frame(layout = grid.layout(nrow=1, ncol=1), draw = FALSE)
+        grob.rect <- grid.rect(x = 1:99/100, y = 1:99/100,
+                               h = rep(.01, 100), w = rep(.05, 100),
+                               gp = gpar(col = terrain.colors(100)),
+                               draw = FALSE)
+        grid.pack(frame = gf, row = 1, col = 1,
+                  grob = grob.rect,
+                  draw = FALSE)
+        grid.draw(gf)  # Fails with stack overflow
+
+5.  There is now a grid.locator() function for interactively selecting
+    locations within the current grid viewport with a mouse.
+
+6.  There is a new grid.convert() function for converting between
+    different coordinate systems.  
+
+    The convertNative() function has been deprecated.
+
+7.  The default "top-level" viewport that is generated by grid
+    now has its "native" coordinate system set to the "native"
+    coordinate system of the device.  For example, "native"
+    units at the top-level correspond to points on a PostScript
+    device, pixels on an X11 device, and so on.
+
+    For example, try the following:
+
+        library(grid)
+	x11()
+	grid.rect(x=10, y=10, width=10, height=10,
+                 default.units="native")
+
+    This may cause consternation if you ever plot grid.points()
+    at the top-level because the default units for grid.points()
+    are "native" ... I consider this an unlikely occurrence.
+
+8.  Added a new gpar called "alpha" for specifying transparency.
+    This is supposed to be a number from 1 (opaque) to 0 (transparent).
+    No R devices will take any notice of this whatsoever as yet.
+
+9.  Modified "xaxis" and "yaxis" grobs so that they extend the 
+    "collection" class.  This means that, when a new generic function
+    is created, it may be possible to write methods just for the 
+    collection class and not also separate xaxis and yaxis methods.
+
+10. Modified unit subsetting so that logical indices work.  
+    For example ...
+
+        unit(1:4, "npc")[1:4 == 3]
+
+11. Fixed detaching/reloading of grid package (was causing an error).
+ 
+12. There is a new grid.arrows() primitive.  
+
+    See the help file for example usage.
+
+13. Grid is now a base package (hence version number leap!)
+
+
+Changes from grid_0.7-3 to grid_0.7-4:
+------------------------------------
+
+1.  Fixed the bug in the bug-fix in item 7. below.
+
+
+Changes from grid_0.7-2 to grid_0.7-3:
+------------------------------------
+
+1.  Properly removed "origin" settings from viewports.
+
+2.  Modified grid.pretty() slightly so that it would respond
+    sensibly/usefully to things like ...
+
+        grid.pretty(c(10, 0))
+
+    A side-effect of this is that the following sort of viewport
+    scale specifications become sensible/useful ...
+
+        push.viewport(viewport(layout=grid.layout(1, 2)))
+        push.viewport(viewport(layout.pos.col=1))
+        push.viewport(viewport(w=.8, h=.8,
+                               xscale=c(10,0)))
+        grid.points(1:10, 1:10/11)
+        grid.xaxis()
+        grid.yaxis()
+        pop.viewport(2)
+        push.viewport(viewport(layout.pos.col=2))
+        push.viewport(viewport(w=.8, h=.8,
+                               yscale=c(10,0)))
+        grid.points(1:10/11, 1:10)
+        grid.xaxis()
+        grid.yaxis()
+        pop.viewport(3)
+
+3.  Fixed the calculation of number of "vertices" in grid.lines so that
+    it is the maximum of length(x) and length(y).
+
+    Used to be calculated solely on length(x).
+
+4.  Grid now throws an error if you try to create a unit of length 0.
+
+    This to fix a bug reported by Bud Gibson, the essence of which was ...
+
+        grid.points(size=unit(numeric(0), "mm"))
+
+5.  The default value of the "at" argument for grid.xaxis() and
+    grid.yaxis() is NULL (was NA;  NA was inconsistent with other
+    default argument settings and basically a dumb idea)
+
+6.  Grid now throws an error if you try to create a gpar object with
+    an element of length 0.
+
+    This is to fix a bug reported by Michael Friendly (and diagnosed by
+    Brian Ripley), the essence of which was ...
+
+         grid.lines(gpar(fontsize=numeric(0)))
+
+7.  grid.text() now converts its label argument to a string.
+
+    This is to fix a bug where "grobwidth" or "grobheight" would 
+    segfault if given a text grob for which the label was not a string.
+    (The fix involved including a check for "mystrwidth" and "mystrheight"
+     units in valid.data).
+
+    The bug could be produced by ...
+    
+        grid.rect(w=unit(1, "grobwidth", data=grid.text(5)))
+    
+
+Changes from grid_0.7-1 to grid_0.7-2:
+-------------------------------------
+
+1.  Fixed some generic/method incompatibilities (pointed out by Kurt).
+
+
+Changes from grid_0.7 to grid_0.7-1:
+------------------------------------
+
+1.  Fixed a bug where layout matrix respect was not being applied to
+    the correct cell.  For example, the following caused the cell
+    1,3 to be respected rather than 1,2 ...
+
+	lt.resp <- matrix(0, 2, 3)
+	lt.resp[1,2] <- 1
+	grid.show.layout(grid.layout(2, 3, respect = lt.resp))
+
+    Reported by Deepayan Sarkar.
+
+
+Changes from grid_0.6 to grid_0.7:
+------------------------------------
+
+1.  The web pages for grid have moved to ...
+   
+	http://www.stat.auckland.ac.nz/~paul/grid/grid.html
+
+2.  Mathematical annotation is now available in grid.
+
+    Wherever grid expects a string, an expression may be used instead.
+    This covers not only producing mathematical annotation output,
+    but also correctly calculating width and height of expressions,
+    and checking for overlapping expressions.
+
+3.  If you try to save/load a grid grob, it will now fail gracefully
+    rather than seg faulting.
+
+4.  If you save a display list containing grid output, then detach
+    grid, then try to run the display list again, it will now fail 
+    gracefully rather than seg faulting.
+
+5.  All gpar() settings can now be vectors.  Well, they could always
+    be vectors, but now values other than the first one will have an
+    effect.  This will not happen in all contexts, for example, 
+    viewports will only take notice of the first value in each setting,
+    but for graphics functions where multiple items can be output,
+    multiple settings may be sensibly given.  Some examples are:
+
+    # multiple points with different colours
+    grid.points(1:10/11, 1:10/11, gp=gpar(col=1:10))
+
+    # multiple segments with different colours
+    grid.segments(1:10/11, 0, 1:10/11, 1, gp=gpar(col=1:10))
+
+    # multiple points with different sizes
+    grid.points(1:10/11, 1:10/11, size=unit(1:10, "mm"))
+
+    # multiple pieces of text with different font sizes
+    grid.text(1:10, x=1:10/11, gp=gpar(fontsize=10:20))
+
+    # multiple rects with different lineheights (and height is in "lines")
+    grid.rect(width=.05, x=1:10/11,
+              height=unit(1, "mylines"),
+              gp=gpar(lineheight=1:10))
+
+6.  (Because of a fix to R/src/main/engine.c ...)
+    Multiple-line text (i.e., text with "\n"s in it) is now correctly
+    spaced vertically (i.e., takes notice of the current value of 
+    "fontsize").
+    
+    NOTE, however, that multiple-line text still takes no notice of the
+    current value of "lineheight".
+
+7.  Fixed a bug in grid.layout().  It was the case that, if you 
+    entered widths or heights which were not unit objects, they
+    were not converted properly to unit objects.
+
+8.  Modified the defaulting of "just" arguments when a single value
+    is provided.  See the new example in grid.text.
+
+9.  Fixed a bug where grid.points(pch=NULL) would cause a crash.
+    This now defaults pch to the value 1.
+
+10. Added "fontfamily" and "fontface" gpar() settings.  The fontfamily
+    setting will mostly be ignored until devices are modified to take
+    notice of the extra information, BUT this can be used NOW to 
+    specify a Hershey Font family (on all devices).  The fontface 
+    setting is designed to take over from the old "face" setting,
+    but the latter is retained for backward compatibility.
+
+
+Changes from grid_0.5-1 to grid_0.6:
+------------------------------------
+
+1.  Some internal changes to speed up creation of unit objects.  
+    This may have a noticeable effect on drawing legends and anything 
+    that relies on grid frames (e.g., "key"s in lattice).
+
+2.  A couple of bug fixes for "grobwidth" and "grobheight" units.
+    Symptoms were legends not being allocated the correct amount of 
+    space.
+
+    Thanks to Deepayan Sarkar and Peter Kleiweg for help diagnosing
+    the bug and testing the fix.
+
+3.  Added plotViewport() and dataViewport() 
+    convenience function for creating a 
+    viewport that has the typical layout of an R plot.
+
+4.  Altered viewport() function so that layout.pos.row and layout.pos.col
+    can be specified as a sequence and only the range() of that 
+    sequence is used.
+
+5.  Removed most documentation from the package to reduce the download
+    size.  The user's guide and changes file are included with the
+    tar ball, but the other documents are only available via 
+    http://www.stat.auckland.ac.nz/PEOPLE/paul/grid/grid.html
+
+    Also changed the format of the user's guide from postscript to pdf.
+
+6.  Fixed bug in unit.length where the length of a unit.arithmetic object
+    was calculated incorrectly if the length() of the scalar multiplier
+    was longer than the unit.length() of the unit object being multiplied.
+
+7.  Allowed character settings for pch in grid.points()
+
+8.  The crash on Windows platforms when plot history is turned on
+    has been fixed in R version 1.5.  
+
+    This fix means that grid_0.6 will only run on R version >= 1.5.0
+
+9.  Added handling of NULL values for gpar elements.  Except for col
+    and fill, this now means the same as specifying no setting at all
+    for the element -- previous behaviour was a segfault.
+
+
+Changes from grid_0.5 to grid_0.5-1:
+------------------------------------
+
+1.  Fix for some grid bugs.
+    
+    The problems were:
+	(i)   grid output could not be saved in metafile format 
+	(ii)  non-grid output could not be saved in metafile format when
+	      grid was loaded
+	(iii) empty page at start of grid postscript output
+	(iv)  empty page at start of non-grid postscript output when
+	      grid was loaded
+	(v)   copying grid output from x11 to postscript (dev.copy)
+	      produced blank pages in postscript
+
+    These problems were due to two things in grid:
+	(i)  grid created a new page whenever a new device was started.
+	(ii) grid created a new page whenever the display list was
+	     replayed (e.g., when a device was resized or the output
+	     was copied from one device to another)
+
+    Grid now only creates a new page the first time grid output is
+    produced on a device AND only creates a new page for replaying
+    the display list IF there has already been grid output on the device.
+
+
+Changes from grid_0.2 to grid_0.5:
+----------------------------------
+
+1.  R has a new device API and a new graphics engine.  Grid uses these.
+
+    This means that this version will NOT work on R versions before 1.4.0
+
+    Another known "bug" is that this version of grid will crash R if
+    used in Windows with plot history recording turned on (although
+    "add"ing individual grid "plots" to the plot history should still
+    work).
+    
+2.  Added "mystrwidth" and "mystrheight" units;  basically these just
+    complete the set of units which depend on font, fontsize, and/or 
+    lineheight and therefore may refer to the current viewport settings
+    of these parameters OR to the current settings of the grob being
+    drawn.
+
+3.  Added unit.rep function (the base rep() function is not generic
+    so I could not simply write a rep.unit method).
+
+4.  Added new gpar, "gamma", for gamma-correction of colours
+    (defaults to 1).  NOTE that only windows devices will currently
+    respond to on-the-fly changes in gamma.
+
+5.  Added "clip" flag to viewports.  If "clip" is TRUE, then output
+    is clipped to the viewport.
+
+    Clipping obeys only the most recent viewport clip setting.
+    For example, if you clip to viewport1, then clip to viewport2,
+    the clipping region is determined wholly by viewport2, the
+    size and shape of viewport1 is irrelevant (until viewport2
+    is popped of course).
+
+    If a viewport is rotated (because of its own "angle" setting
+    or because it is within another viewport which is rotated) then
+    the "clip" flag is ignored.
+  
+6.  The functions grid.start() and grid.stop() have been removed.
+    grid automatically "registers" with devices.
+
+7.  Grid no longer automatically opens a device when it is loaded.
+    Instead, a device is created, if there are none open, when the
+    first drawing occurs or when the first viewport is pushed.
+
+8.  Added new functions unit.pmin() and unit.pmax() which are unit
+    versions of pmax() and pmin()
+
+9.  Added new function grid.place() which provides a simpler 
+    interface to grid.pack() and is useful for using grid "frame"s
+    as just a convenient way of defining a layout and sticking 
+    things in it.
+
+
+Changes from grid_0.1 to grid_0.2:
+----------------------------------
+
+1. Fixed bug in rotating viewports;  this should be more reliable now.
+
+2. Added grid.line.to() and grid.move.to().  These allow drawing BETWEEN
+   different coordinate systems.  See example in inst/doc/demo3.ps.
+
+3. Added some more demonstrations to the doc directory.
+
+4. Added more test code to the tests directory.
+
+5. Added "grobwidth" and "grobheight" units.  See the document
+   grid/inst/doc/advanced/parentchild.ps
+
+6. Added more detailed documentation to grid/inst/doc/advanced.  This
+   stuff is not as friendly for the reader, but may be useful if you're
+   tearing your hair out wondering why some strange effect is occurring.
+
+7. Changed frames and packing to use the new "grobwidth" and "grobheight"
+   units.  This fixes some problems with frames and packing.
+
+8. Fixed a bug where the gpar settings for "fontsize" and "lineheight"
+   _within a grob_ would not affect the location or size of the grob
+   if they were specified in "lines" or "char" units.
+
+   This required adding new "mylines" and "mychar" units (alternative
+   suggestions for names welcome !) so that you can specify whether
+   a grob's a location/size is in terms of the current viewport's
+   fontsize and lineheight ("lines" and "char") or in terms of its own
+   fontsize and lineheight ("mylines" and "mychar").
+
+9. Added grid.polygon() and grid.circle() primitives
+
+10. Added newpage=TRUE argument to grid.start() so that you can restart
+    grid graphics mode without having to move to a new page.
+
+    For example, try ...
+
+	postscript()
+	grid.start()
+	grid.polygon()
+	grid.stop()
+	grid.start() # moves to new page
+	grid.circle()
+	grid.stop()
+	grid.start(newpage=FALSE) # does NOT move to new page
+	grid.rect()
+	grid.stop()
+	dev.off()
+
+11. Changed interface for pop.viewport().  This now just takes a
+    number of viewports to pop, which defaults to 1.  
+    For example ...
+
+        push.viewport(viewport())
+	pop.viewport(current.viewport())
+
+    ... becomes ...
+    
+        push.viewport(viewport())
+	pop.viewport()
+
+    ... and ...
+
+        vp1 <- viewport()
+	vp2 <- viewport()
+	push.viewport(vp1, vp2)
+	pop.viewport(vp2, vp1)
+
+    ... becomes ...
+
+        vp1 <- viewport()
+	vp2 <- viewport()
+	push.viewport(vp1, vp2)
+	pop.viewport(2)
+	
+12. Speed-up of pushing and popping viewports.  This will probably not
+    be noticeable in normal usage, but makes a big difference for 
+    frames and packing.
+
+Changes from lattice_0.2 to grid_0.1:
+-------------------------------------
+
+0. Change of package name from "lattice" to "grid" (!!!!)
+
+   This means that most user functions have changed from l<something>
+   to grid.<something>
+
+1. Slight speed up of grid.push.viewport and grid.pop.viewport.
+
+2. Added sum() method for units.
+
+   For example, try ...
+
+       grid.rect(w=sum(unit(c(.25,.25), "npc")))
+       grid.rect(w=sum(unit(c(.25,.25), "npc"), unit(1, "cm")), border="red")
+
+3. Changed the usage of grid.edit() slightly.  If you want to specify 
+   several new values at once, you must use grid.prop.list() rather
+   than just list().  For example, for a single new value use ...
+
+       grid.edit(<grob>, col="red")
+
+   ... as before, but for multiple new values use ...
+
+       grid.edit(<grob>, grid.prop.list(col="red", lty="dashed"))
+
+   ... rather than ...
+   
+       grid.edit(<grob>, list(col="red", lty="dashed"))
+
+4. Added a new grid.frame() grob.  This acts a bit like a simple 
+   grid.collection() BUT controls the placement of its children.  
+   You add children using the grid.pack() function.
+
+5. All viewports and grobs now have a "gp" slot which contains a
+   "gpar" object.  This is a list of graphical parameters, which 
+   replaces the specification of individual graphical parameters
+   for each different type of grob.  
+
+   For example, instead of the old ...
+   
+       grid.rect(w=.8, h=.8, border="red")
+
+   ... we have the new ...
+
+       grid.rect(w=.8, h=.8, gp=gpar(border="red"))
+
+   This may seem like a loss (because you have to type more stuff),
+   and it is a loss, but the (hopefully greater) win is that (i) you only
+   have one parameter for all graphical settings, for example, ...
+
+       grid.rect(w=.8, h=.8, gp=gpar(border="red", lwd=3))
+
+   ... and (ii) this applies for all grobs, for example, ...
+
+       grid.text("hi", gp=gpar(col="red", fontsize=10))
+
+   ... and (iii) you can add more graphical parameters with minimal fuss,
+   for example, ...
+
+       grid.text("hi", gp=gpar(col="red", fontsize=10, new.par=whatever))
+
+   ... and (iv) its easier to automate things (see below).
+
+   Graphical parameter settings are "permanent" so, for example, if
+   an axis sets the colour to "red" then all of its children are
+   drawn in "red" unless they set colour to something else.
+
+   For example, try ...
+
+       grid.multipanel(vp = grid.viewport(0.5, 0.5, 0.8, 0.8, 
+                                          gp=gpar(fontsize=20)))
+
+   ... and notice that all of the components of the multipanel take
+   notice of the fontsize setting of the parent viewport (except the
+   axis labels because they explicitly set the fontsize to 20 themselves).
+
+   The setting of graphical parameters is automated;  
+   if you have a slot called "gp" in your grob, Lattice will
+   set the graphical parameters in that slot before calling
+   draw.details() and unset the parameters afterwards.
+
+6. The pushing and popping of "local" viewports has been automated.
+   If you have a slot called "vp" in your grob, Lattice will call
+   grid.push.viewport() on that slot before calling draw.details() 
+   and grid.pop.viewport() afterwards.
+
+7. "collection" grobs and "[x|y]axis" grobs no longer pass editing
+   operations down to their children.  
+
+   This was mainly (only ?) for sharing graphical parameter settings
+   and that duty is now performed by the gpar stuff in point 5 above.
+
+   This is a good thing because there are some cases where passing
+   down editing operations could cause serious damage.  For example, 
+   consider what would have happened if you had edited the "vp" slot
+   of a collection grob (!)
+