BiomedEngX/CircosHeatmap-aardio
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity
CircosHeatmap-aardio/dist/lib/r-library/grid/doc/changes.txt

1733 lines
61 KiB
Plaintext
Raw Permalink Normal View History

首次上传
2025-01-12 00:52:51 +08:00
Changes from grid_4.3.* to grid_4.4.0:
-------------------------------------
1. Bug fix: pattern/gradient fills are now correctly resolved relative to a
viewport EVEN IF 'fill' is NOT the first value specified in gpar().
For example, this is now resolved relative the viewport ...
pushViewport(viewport(gp=gpar(col=NA, fill=linearGradient())))
grid.rect(x=.75, width=.5, y=.75, height=.5)
... whereas, prior to the fix, only this worked ...
pushViewport(viewport(gp=gpar(fill=linearGradient())))
grid.rect(x=.75, width=.5, y=.75, height=.5)
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 (!)
Reference in New Issue Copy Permalink