| |
| R version 3.6.2 Patched (2020-02-12 r77795) -- "Dark and Stormy Night" |
| Copyright (C) 2020 The R Foundation for Statistical Computing |
| Platform: x86_64-pc-linux-gnu (64-bit) |
| |
| R is free software and comes with ABSOLUTELY NO WARRANTY. |
| You are welcome to redistribute it under certain conditions. |
| Type 'license()' or 'licence()' for distribution details. |
| |
| Natural language support but running in an English locale |
| |
| R is a collaborative project with many contributors. |
| Type 'contributors()' for more information and |
| 'citation()' on how to cite R or R packages in publications. |
| |
| Type 'demo()' for some demos, 'help()' for on-line help, or |
| 'help.start()' for an HTML browser interface to help. |
| Type 'q()' to quit R. |
| |
| > pkgname <- "grid" |
| > source(file.path(R.home("share"), "R", "examples-header.R")) |
| > options(warn = 1) |
| > library('grid') |
| > |
| > base::assign(".oldSearch", base::search(), pos = 'CheckExEnv') |
| > base::assign(".old_wd", base::getwd(), pos = 'CheckExEnv') |
| > cleanEx() |
| > nameEx("Grid") |
| > ### * Grid |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: Grid |
| > ### Title: Grid Graphics |
| > ### Aliases: Grid |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > ## Diagram of a simple layout |
| > grid.show.layout(grid.layout(4,2, |
| + heights=unit(rep(1, 4), |
| + c("lines", "lines", "lines", "null")), |
| + widths=unit(c(1, 1), "inches"))) |
| > ## Diagram of a sample viewport |
| > grid.show.viewport(viewport(x=0.6, y=0.6, |
| + w=unit(1, "inches"), h=unit(1, "inches"))) |
| > ## A flash plotting example |
| > grid.multipanel(vp=viewport(0.5, 0.5, 0.8, 0.8)) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("arrow") |
| > ### * arrow |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: arrow |
| > ### Title: Describe arrows to add to a line. |
| > ### Aliases: arrow |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > arrow() |
| $angle |
| [1] 30 |
| |
| $length |
| [1] 0.25inches |
| |
| $ends |
| [1] 2 |
| |
| $type |
| [1] 1 |
| |
| attr(,"class") |
| [1] "arrow" |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("calcStringMetric") |
| > ### * calcStringMetric |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: calcStringMetric |
| > ### Title: Calculate Metric Information for Text |
| > ### Aliases: calcStringMetric |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > grid.segments(.01, .5, .99, .5, gp=gpar(col="grey")) |
| > metrics <- calcStringMetric(letters) |
| > grid.rect(x=1:26/27, |
| + width=unit(metrics$width, "inches"), |
| + height=unit(metrics$ascent, "inches"), |
| + just="bottom", |
| + gp=gpar(col="red")) |
| > grid.rect(x=1:26/27, |
| + width=unit(metrics$width, "inches"), |
| + height=unit(metrics$descent, "inches"), |
| + just="top", |
| + gp=gpar(col="red")) |
| > grid.text(letters, x=1:26/27, just="bottom") |
| > |
| > test <- function(x) { |
| + grid.text(x, just="bottom") |
| + metric <- calcStringMetric(x) |
| + if (is.character(x)) { |
| + grid.rect(width=unit(metric$width, "inches"), |
| + height=unit(metric$ascent, "inches"), |
| + just="bottom", |
| + gp=gpar(col=rgb(1,0,0,.5))) |
| + grid.rect(width=unit(metric$width, "inches"), |
| + height=unit(metric$descent, "inches"), |
| + just="top", |
| + gp=gpar(col=rgb(1,0,0,.5))) |
| + } else { |
| + grid.rect(width=unit(metric$width, "inches"), |
| + y=unit(.5, "npc") + unit(metric[2], "inches"), |
| + height=unit(metric$ascent, "inches"), |
| + just="bottom", |
| + gp=gpar(col=rgb(1,0,0,.5))) |
| + grid.rect(width=unit(metric$width, "inches"), |
| + height=unit(metric$descent, "inches"), |
| + just="bottom", |
| + gp=gpar(col=rgb(1,0,0,.5))) |
| + } |
| + } |
| > |
| > tests <- list("t", |
| + "test", |
| + "testy", |
| + "test\ntwo", |
| + expression(x), |
| + expression(y), |
| + expression(x + y), |
| + expression(a + b), |
| + expression(atop(x + y, 2))) |
| > |
| > grid.newpage() |
| > nrowcol <- n2mfrow(length(tests)) |
| > pushViewport(viewport(layout=grid.layout(nrowcol[1], nrowcol[2]), |
| + gp=gpar(cex=5, lwd=.5))) |
| > for (i in 1:length(tests)) { |
| + col <- (i - 1) %% nrowcol[2] + 1 |
| + row <- (i - 1) %/% nrowcol[2] + 1 |
| + pushViewport(viewport(layout.pos.row=row, layout.pos.col=col)) |
| + test(tests[[i]]) |
| + popViewport() |
| + } |
| > |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("current.viewport") |
| > ### * current.viewport |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: Querying the Viewport Tree |
| > ### Title: Get the Current Grid Viewport (Tree) |
| > ### Aliases: current.viewport current.parent current.vpTree current.vpPath |
| > ### current.transform current.rotation |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > pushViewport(viewport(width=0.8, height=0.8, name="A")) |
| > pushViewport(viewport(x=0.1, width=0.3, height=0.6, |
| + just="left", name="B")) |
| > upViewport(1) |
| > pushViewport(viewport(x=0.5, width=0.4, height=0.8, |
| + just="left", name="C")) |
| > pushViewport(viewport(width=0.8, height=0.8, name="D")) |
| > current.vpPath() |
| GRID.VP.65::A::C::D |
| > upViewport(1) |
| > current.vpPath() |
| GRID.VP.65::A::C |
| > current.vpTree() |
| viewport[ROOT]->(viewport[GRID.VP.65]->(viewport[A]->(viewport[B], viewport[C]->(viewport[D])))) |
| > current.viewport() |
| viewport[C] |
| > current.vpTree(all=FALSE) |
| viewport[C]->(viewport[D]) |
| > popViewport(0) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("depth") |
| > ### * depth |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: depth |
| > ### Title: Determine the number of levels in an object. |
| > ### Aliases: depth depth.viewport depth.path |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > vp <- viewport() |
| > depth(vp) |
| [1] 1 |
| > depth(vpStack(vp, vp)) |
| [1] 2 |
| > depth(vpList(vpStack(vp, vp), vp)) |
| [1] 1 |
| > depth(vpPath("vp")) |
| [1] 1 |
| > depth(vpPath("vp1", "vp2")) |
| [1] 2 |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("deviceLoc") |
| > ### * deviceLoc |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: deviceLoc |
| > ### Title: Convert Viewport Location to Device Location |
| > ### Aliases: deviceLoc deviceDim |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > ## A tautology |
| > grid.newpage() |
| > pushViewport(viewport()) |
| > deviceLoc(unit(1, "inches"), unit(1, "inches")) |
| $x |
| [1] 1in |
| |
| $y |
| [1] 1in |
| |
| > |
| > ## Something less obvious |
| > grid.newpage() |
| > pushViewport(viewport(width=.5, height=.5)) |
| > grid.rect() |
| > x <- unit(1, "in") |
| > y <- unit(1, "in") |
| > grid.circle(x, y, r=unit(2, "mm")) |
| > loc <- deviceLoc(x, y) |
| > loc |
| $x |
| [1] 2.7in |
| |
| $y |
| [1] 2.75in |
| |
| > upViewport() |
| > grid.circle(loc$x, loc$y, r=unit(1, "mm"), gp=gpar(fill="black")) |
| > |
| > ## Something even less obvious |
| > grid.newpage() |
| > pushViewport(viewport(width=.5, height=.5, angle=30)) |
| > grid.rect() |
| > x <- unit(.2, "npc") |
| > y <- unit(2, "in") |
| > grid.circle(x, y, r=unit(2, "mm")) |
| > loc <- deviceLoc(x, y) |
| > loc |
| $x |
| [1] 2.39165408813987in |
| |
| $y |
| [1] 3.20650635094611in |
| |
| > upViewport() |
| > grid.circle(loc$x, loc$y, r=unit(1, "mm"), gp=gpar(fill="black")) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("explode") |
| > ### * explode |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: explode |
| > ### Title: Explode a path into its components. |
| > ### Aliases: explode explode.character explode.path |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > explode("vp1::vp2") |
| [1] "vp1" "vp2" |
| > explode(vpPath("vp1", "vp2")) |
| [1] "vp1" "vp2" |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("gEdit") |
| > ### * gEdit |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: gEdit |
| > ### Title: Create and Apply Edit Objects |
| > ### Aliases: gEdit gEditList applyEdit applyEdits |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.rect(gp=gpar(col="red")) |
| > # same thing, but more verbose |
| > grid.draw(applyEdit(rectGrob(), gEdit(gp=gpar(col="red")))) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("gPath") |
| > ### * gPath |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: gPath |
| > ### Title: Concatenate Grob Names |
| > ### Aliases: gPath |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > gPath("g1", "g2") |
| g1::g2 |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("getNames") |
| > ### * getNames |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: getNames |
| > ### Title: List the names of grobs on the display list |
| > ### Aliases: getNames |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.grill() |
| > getNames() |
| [1] "GRID.text.171" "GRID.rect.172" "GRID.circle.173" |
| [4] "GRID.circle.174" "GRID.rect.175" "GRID.rect.176" |
| [7] "GRID.segments.177" "GRID.segments.178" |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("gpar") |
| > ### * gpar |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: gpar |
| > ### Title: Handling Grid Graphical Parameters |
| > ### Aliases: gpar get.gpar |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > gp <- get.gpar() |
| > utils::str(gp) |
| List of 14 |
| $ fill : chr "transparent" |
| $ col : chr "black" |
| $ lty : chr "solid" |
| $ lwd : num 1 |
| $ cex : num 1 |
| $ fontsize : num 12 |
| $ lineheight: num 1.2 |
| $ font : int 1 |
| $ fontfamily: chr "" |
| $ alpha : num 1 |
| $ lineend : chr "round" |
| $ linejoin : chr "round" |
| $ linemitre : num 10 |
| $ lex : num 1 |
| - attr(*, "class")= chr "gpar" |
| > ## These *do* nothing but produce a "gpar" object: |
| > gpar(col = "red") |
| $col |
| [1] "red" |
| |
| > gpar(col = "blue", lty = "solid", lwd = 3, fontsize = 16) |
| $col |
| [1] "blue" |
| |
| $lty |
| [1] "solid" |
| |
| $lwd |
| [1] 3 |
| |
| $fontsize |
| [1] 16 |
| |
| > get.gpar(c("col", "lty")) |
| $col |
| [1] "black" |
| |
| $lty |
| [1] "solid" |
| |
| > grid.newpage() |
| > vp <- viewport(w = .8, h = .8, gp = gpar(col="blue")) |
| > grid.draw(gTree(children=gList(rectGrob(gp = gpar(col="red")), |
| + textGrob(paste("The rect is its own colour (red)", |
| + "but this text is the colour", |
| + "set by the gTree (green)", |
| + sep = "\n"))), |
| + gp = gpar(col="green"), vp = vp)) |
| > grid.text("This text is the colour set by the viewport (blue)", |
| + y = 1, just = c("center", "bottom"), |
| + gp = gpar(fontsize=20), vp = vp) |
| > grid.newpage() |
| > ## example with multiple values for a parameter |
| > pushViewport(viewport()) |
| > grid.points(1:10/11, 1:10/11, gp = gpar(col=1:10)) |
| > popViewport() |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.DLapply") |
| > ### * grid.DLapply |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.DLapply |
| > ### Title: Modify the Grid Display List |
| > ### Aliases: grid.DLapply |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > grid.rect(width=.4, height=.4, x=.25, y=.75, gp=gpar(fill="black"), name="r1") |
| > grid.rect(width=.4, height=.4, x=.5, y=.5, gp=gpar(fill="grey"), name="r2") |
| > grid.rect(width=.4, height=.4, x=.75, y=.25, gp=gpar(fill="white"), name="r3") |
| > grid.DLapply(function(x) { if (is.grob(x)) x$gp <- gpar(); x }) |
| NULL |
| > grid.refresh() |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.bezier") |
| > ### * grid.bezier |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.bezier |
| > ### Title: Draw a Bezier Curve |
| > ### Aliases: grid.bezier bezierGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > x <- c(0.2, 0.2, 0.4, 0.4) |
| > y <- c(0.2, 0.4, 0.4, 0.2) |
| > |
| > grid.newpage() |
| > grid.bezier(x, y) |
| > grid.bezier(c(x, x + .4), c(y + .4, y + .4), |
| + id=rep(1:2, each=4)) |
| > grid.segments(.4, .6, .6, .6) |
| > grid.bezier(x, y, |
| + gp=gpar(lwd=3, fill="black"), |
| + arrow=arrow(type="closed"), |
| + vp=viewport(x=.9)) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.cap") |
| > ### * grid.cap |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.cap |
| > ### Title: Capture a raster image |
| > ### Aliases: grid.cap |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.clip") |
| > ### * grid.clip |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.clip |
| > ### Title: Set the Clipping Region |
| > ### Aliases: grid.clip clipGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # draw across entire viewport, but clipped |
| > grid.clip(x = 0.3, width = 0.1) |
| > grid.lines(gp=gpar(col="green", lwd=5)) |
| > # draw across entire viewport, but clipped (in different place) |
| > grid.clip(x = 0.7, width = 0.1) |
| > grid.lines(gp=gpar(col="red", lwd=5)) |
| > # Viewport sets new clip region |
| > pushViewport(viewport(width=0.5, height=0.5, clip=TRUE)) |
| > grid.lines(gp=gpar(col="grey", lwd=3)) |
| > # Return to original viewport; get |
| > # clip region from previous grid.clip() |
| > # (NOT from previous viewport clip region) |
| > popViewport() |
| > grid.lines(gp=gpar(col="black")) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.convert") |
| > ### * grid.convert |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.convert |
| > ### Title: Convert Between Different grid Coordinate Systems |
| > ### Aliases: convertUnit convertX convertY convertWidth convertHeight |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > ## A tautology |
| > convertX(unit(1, "inches"), "inches") |
| [1] 1inches |
| > ## The physical units |
| > convertX(unit(2.54, "cm"), "inches") |
| [1] 1inches |
| > convertX(unit(25.4, "mm"), "inches") |
| [1] 1inches |
| > convertX(unit(72.27, "points"), "inches") |
| [1] 1inches |
| > convertX(unit(1/12*72.27, "picas"), "inches") |
| [1] 1inches |
| > convertX(unit(72, "bigpts"), "inches") |
| [1] 1inches |
| > convertX(unit(1157/1238*72.27, "dida"), "inches") |
| [1] 1inches |
| > convertX(unit(1/12*1157/1238*72.27, "cicero"), "inches") |
| [1] 1inches |
| > convertX(unit(65536*72.27, "scaledpts"), "inches") |
| [1] 1inches |
| > convertX(unit(1/2.54, "inches"), "cm") |
| [1] 1cm |
| > convertX(unit(1/25.4, "inches"), "mm") |
| [1] 1mm |
| > convertX(unit(1/72.27, "inches"), "points") |
| [1] 1points |
| > convertX(unit(1/(1/12*72.27), "inches"), "picas") |
| [1] 1picas |
| > convertX(unit(1/72, "inches"), "bigpts") |
| [1] 1bigpts |
| > convertX(unit(1/(1157/1238*72.27), "inches"), "dida") |
| [1] 1dida |
| > convertX(unit(1/(1/12*1157/1238*72.27), "inches"), "cicero") |
| [1] 1cicero |
| > convertX(unit(1/(65536*72.27), "inches"), "scaledpts") |
| [1] 1scaledpts |
| > |
| > pushViewport(viewport(width=unit(1, "inches"), |
| + height=unit(2, "inches"), |
| + xscale=c(0, 1), |
| + yscale=c(1, 3))) |
| > ## Location versus dimension |
| > convertY(unit(2, "native"), "inches") |
| [1] 1inches |
| > convertHeight(unit(2, "native"), "inches") |
| [1] 2inches |
| > ## From "x" to "y" (the conversion is via "inches") |
| > convertUnit(unit(1, "native"), "native", |
| + axisFrom="x", axisTo="y") |
| [1] 2native |
| > ## Convert several values at once |
| > convertX(unit(c(0.5, 2.54), c("npc", "cm")), |
| + c("inches", "native")) |
| [1] 0.5inches 1native |
| > popViewport() |
| > ## Convert a complex unit |
| > convertX(unit(1, "strwidth", "Hello"), "native") |
| [1] 0.0558333333333333native |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.curve") |
| > ### * grid.curve |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.curve |
| > ### Title: Draw a Curve Between Locations |
| > ### Aliases: grid.curve curveGrob arcCurvature |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > curveTest <- function(i, j, ...) { |
| + pushViewport(viewport(layout.pos.col=j, layout.pos.row=i)) |
| + do.call("grid.curve", c(list(x1=.25, y1=.25, x2=.75, y2=.75), list(...))) |
| + grid.text(sub("list\\((.*)\\)", "\\1", |
| + deparse(substitute(list(...)))), |
| + y=unit(1, "npc")) |
| + popViewport() |
| + } |
| > # grid.newpage() |
| > pushViewport(plotViewport(c(0, 0, 1, 0), |
| + layout=grid.layout(2, 1, heights=c(2, 1)))) |
| > pushViewport(viewport(layout.pos.row=1, |
| + layout=grid.layout(3, 3, respect=TRUE))) |
| > curveTest(1, 1) |
| > curveTest(1, 2, inflect=TRUE) |
| > curveTest(1, 3, angle=135) |
| > curveTest(2, 1, arrow=arrow()) |
| > curveTest(2, 2, ncp=8) |
| > curveTest(2, 3, shape=0) |
| > curveTest(3, 1, curvature=-1) |
| > curveTest(3, 2, square=FALSE) |
| > curveTest(3, 3, debug=TRUE) |
| > popViewport() |
| > pushViewport(viewport(layout.pos.row=2, |
| + layout=grid.layout(3, 3))) |
| > curveTest(1, 1) |
| > curveTest(1, 2, inflect=TRUE) |
| > curveTest(1, 3, angle=135) |
| > curveTest(2, 1, arrow=arrow()) |
| > curveTest(2, 2, ncp=8) |
| > curveTest(2, 3, shape=0) |
| > curveTest(3, 1, curvature=-1) |
| > curveTest(3, 2, square=FALSE) |
| > curveTest(3, 3, debug=TRUE) |
| > popViewport(2) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.delay") |
| > ### * grid.delay |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.delay |
| > ### Title: Encapsulate calculations and generating a grob |
| > ### Aliases: grid.delay delayGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.delay({ |
| + w <- convertWidth(unit(1, "inches"), "npc") |
| + rectGrob(width=w) |
| + }, |
| + list()) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.draw") |
| > ### * grid.draw |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.draw |
| > ### Title: Draw a grid grob |
| > ### Aliases: grid.draw |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > ## Create a graphical object, but don't draw it |
| > l <- linesGrob() |
| > ## Draw it |
| > grid.draw(l) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.edit") |
| > ### * grid.edit |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.edit |
| > ### Title: Edit the Description of a Grid Graphical Object |
| > ### Aliases: grid.edit grid.gedit editGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > grid.xaxis(name = "xa", vp = viewport(width=.5, height=.5)) |
| > grid.edit("xa", gp = gpar(col="red")) |
| > # won't work because no ticks (at is NULL) |
| > try(grid.edit(gPath("xa", "ticks"), gp = gpar(col="green"))) |
| Error in editDLfromGPath(gPath, specs, strict, grep, global, redraw) : |
| 'gPath' (xa::ticks) not found |
| > grid.edit("xa", at = 1:4/5) |
| > # Now it should work |
| > try(grid.edit(gPath("xa", "ticks"), gp = gpar(col="green"))) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.force") |
| > ### * grid.force |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.force |
| > ### Title: Force a grob into its components |
| > ### Aliases: grid.force grid.force.default grid.force.gPath grid.force.grob |
| > ### forceGrob grid.revert grid.revert.gPath grid.revert.grob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > pushViewport(viewport(width=.5, height=.5)) |
| > # Draw xaxis |
| > grid.xaxis(name="xax") |
| > grid.ls() |
| GRID.text.253 |
| xax |
| > # Force xaxis |
| > grid.force() |
| > grid.ls() |
| GRID.text.253 |
| xax |
| major |
| ticks |
| labels |
| > # Revert xaxis |
| > grid.revert() |
| > grid.ls() |
| GRID.text.253 |
| xax |
| > # Draw and force yaxis |
| > grid.force(yaxisGrob(), draw=TRUE) |
| forcedgrob[GRID.yaxis.254] |
| > grid.ls() |
| GRID.text.253 |
| xax |
| GRID.yaxis.254 |
| major |
| ticks |
| labels |
| > # Revert yaxis |
| > grid.revert() |
| > grid.ls() |
| GRID.text.253 |
| xax |
| GRID.yaxis.254 |
| > # Force JUST xaxis |
| > grid.force("xax") |
| > grid.ls() |
| GRID.text.253 |
| xax |
| major |
| ticks |
| labels |
| GRID.yaxis.254 |
| > # Force ALL |
| > grid.force() |
| > grid.ls() |
| GRID.text.253 |
| xax |
| major |
| ticks |
| labels |
| GRID.yaxis.254 |
| major |
| ticks |
| labels |
| > # Revert JUST xaxis |
| > grid.revert("xax") |
| > grid.ls() |
| GRID.text.253 |
| xax |
| GRID.yaxis.254 |
| major |
| ticks |
| labels |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.frame") |
| > ### * grid.frame |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.frame |
| > ### Title: Create a Frame for Packing Objects |
| > ### Aliases: grid.frame frameGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > grid.frame(name="gf", draw=TRUE) |
| > grid.pack("gf", rectGrob(gp=gpar(fill="grey")), width=unit(1, "null")) |
| > grid.pack("gf", textGrob("hi there"), side="right") |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.function") |
| > ### * grid.function |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.function |
| > ### Title: Draw a curve representing a function |
| > ### Aliases: grid.function functionGrob grid.abline |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # abline |
| > # NOTE: in ROOT viewport on screen, (0, 0) at top-left |
| > # and "native" is pixels! |
| > grid.function(function(x) list(x=x, y=0 + 1*x)) |
| > # a more "normal" viewport with default normalized "native" coords |
| > grid.newpage() |
| > pushViewport(viewport()) |
| > grid.function(function(x) list(x=x, y=0 + 1*x)) |
| > # slightly simpler |
| > grid.newpage() |
| > pushViewport(viewport()) |
| > grid.abline() |
| > # sine curve |
| > grid.newpage() |
| > pushViewport(viewport(xscale=c(0, 2*pi), yscale=c(-1, 1))) |
| > grid.function(function(x) list(x=x, y=sin(x))) |
| > # constrained sine curve |
| > grid.newpage() |
| > pushViewport(viewport(xscale=c(0, 2*pi), yscale=c(-1, 1))) |
| > grid.function(function(x) list(x=x, y=sin(x)), |
| + range=0:1) |
| > # inverse sine curve |
| > grid.newpage() |
| > pushViewport(viewport(xscale=c(-1, 1), yscale=c(0, 2*pi))) |
| > grid.function(function(y) list(x=sin(y), y=y), |
| + range="y") |
| > # parametric function |
| > grid.newpage() |
| > pushViewport(viewport(xscale=c(-1, 1), yscale=c(-1, 1))) |
| > grid.function(function(t) list(x=cos(t), y=sin(t)), |
| + range=c(0, 9*pi/5)) |
| > # physical abline |
| > grid.newpage() |
| > grid.function(function(x) list(x=x, y=0 + 1*x), |
| + units="in") |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.get") |
| > ### * grid.get |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.get |
| > ### Title: Get a Grid Graphical Object |
| > ### Aliases: grid.get grid.gget getGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.xaxis(name="xa") |
| > grid.get("xa") |
| xaxis[xa] |
| > grid.get(gPath("xa", "ticks")) |
| NULL |
| > |
| > grid.draw(gTree(name="gt", children=gList(xaxisGrob(name="axis")))) |
| > grid.get(gPath("gt", "axis", "ticks")) |
| NULL |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.grab") |
| > ### * grid.grab |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.grab |
| > ### Title: Grab the current grid output |
| > ### Aliases: grid.grab grid.grabExpr |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > pushViewport(viewport(w=.5, h=.5)) |
| > grid.rect() |
| > grid.points(stats::runif(10), stats::runif(10)) |
| > popViewport() |
| > grab <- grid.grab() |
| > grid.newpage() |
| > grid.draw(grab) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.grep") |
| > ### * grid.grep |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.grep |
| > ### Title: Search for grobs |
| > ### Aliases: grid.grep |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # A gTree, called "grandparent", with child gTree, |
| > # called "parent", with childrenvp vpStack (vp2 within vp1) |
| > # and child grob, called "child", with vp vpPath (down to vp2) |
| > sampleGTree <- gTree(name="grandparent", |
| + children=gList(gTree(name="parent", |
| + children=gList(grob(name="child", vp="vp1::vp2")), |
| + childrenvp=vpStack(viewport(name="vp1"), |
| + viewport(name="vp2"))))) |
| > # Searching for grobs |
| > grid.grep("parent", sampleGTree) |
| grandparent::parent |
| > grid.grep("parent", sampleGTree, strict=TRUE) |
| character(0) |
| > grid.grep("grandparent", sampleGTree, strict=TRUE) |
| grandparent |
| > grid.grep("grandparent::parent", sampleGTree) |
| grandparent::parent |
| > grid.grep("parent::child", sampleGTree) |
| grandparent::parent::child |
| > grid.grep("[a-z]", sampleGTree, grep=TRUE) |
| grandparent |
| > grid.grep("[a-z]", sampleGTree, grep=TRUE, global=TRUE) |
| [[1]] |
| grandparent |
| |
| [[2]] |
| grandparent::parent |
| |
| [[3]] |
| grandparent::parent::child |
| |
| > # Searching for viewports |
| > grid.grep("vp1", sampleGTree, viewports=TRUE) |
| vp1 |
| > grid.grep("vp2", sampleGTree, viewports=TRUE) |
| vp1::vp2 |
| > grid.grep("vp", sampleGTree, viewports=TRUE, grep=TRUE) |
| vp1 |
| > grid.grep("vp2", sampleGTree, viewports=TRUE, strict=TRUE) |
| character(0) |
| > grid.grep("vp1::vp2", sampleGTree, viewports=TRUE) |
| vp1::vp2 |
| > # Searching for both |
| > grid.grep("[a-z]", sampleGTree, viewports=TRUE, grep=TRUE, global=TRUE) |
| [[1]] |
| grandparent |
| |
| [[2]] |
| grandparent::parent |
| |
| [[3]] |
| vp1 |
| |
| [[4]] |
| vp1::vp2 |
| |
| [[5]] |
| grandparent::parent::child |
| |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.layout") |
| > ### * grid.layout |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.layout |
| > ### Title: Create a Grid Layout |
| > ### Aliases: grid.layout |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > ## A variety of layouts (some a bit mid-bending ...) |
| > layout.torture() |
| > ## Demonstration of layout justification |
| > grid.newpage() |
| > testlay <- function(just="centre") { |
| + pushViewport(viewport(layout=grid.layout(1, 1, widths=unit(1, "inches"), |
| + heights=unit(0.25, "npc"), |
| + just=just))) |
| + pushViewport(viewport(layout.pos.col=1, layout.pos.row=1)) |
| + grid.rect() |
| + grid.text(paste(just, collapse="-")) |
| + popViewport(2) |
| + } |
| > testlay() |
| > testlay(c("left", "top")) |
| > testlay(c("right", "top")) |
| > testlay(c("right", "bottom")) |
| > testlay(c("left", "bottom")) |
| > testlay(c("left")) |
| > testlay(c("right")) |
| > testlay(c("bottom")) |
| > testlay(c("top")) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.lines") |
| > ### * grid.lines |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.lines |
| > ### Title: Draw Lines in a Grid Viewport |
| > ### Aliases: grid.lines linesGrob grid.polyline polylineGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.lines() |
| > # Using id (NOTE: locations are not in consecutive blocks) |
| > grid.newpage() |
| > grid.polyline(x=c((0:4)/10, rep(.5, 5), (10:6)/10, rep(.5, 5)), |
| + y=c(rep(.5, 5), (10:6/10), rep(.5, 5), (0:4)/10), |
| + id=rep(1:5, 4), |
| + gp=gpar(col=1:5, lwd=3)) |
| > # Using id.lengths |
| > grid.newpage() |
| > grid.polyline(x=outer(c(0, .5, 1, .5), 5:1/5), |
| + y=outer(c(.5, 1, .5, 0), 5:1/5), |
| + id.lengths=rep(4, 5), |
| + gp=gpar(col=1:5, lwd=3)) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.locator") |
| > ### * grid.locator |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.locator |
| > ### Title: Capture a Mouse Click |
| > ### Aliases: grid.locator |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > if (dev.interactive()) { |
| + ## Need to write a more sophisticated unit as.character method |
| + unittrim <- function(unit) { |
| + sub("^([0-9]+|[0-9]+[.][0-9])[0-9]*", "\\1", as.character(unit)) |
| + } |
| + do.click <- function(unit) { |
| + click.locn <- grid.locator(unit) |
| + grid.segments(unit.c(click.locn$x, unit(0, "npc")), |
| + unit.c(unit(0, "npc"), click.locn$y), |
| + click.locn$x, click.locn$y, |
| + gp=gpar(lty="dashed", col="grey")) |
| + grid.points(click.locn$x, click.locn$y, pch=16, size=unit(1, "mm")) |
| + clickx <- unittrim(click.locn$x) |
| + clicky <- unittrim(click.locn$y) |
| + grid.text(paste0("(", clickx, ", ", clicky, ")"), |
| + click.locn$x + unit(2, "mm"), click.locn$y, |
| + just="left") |
| + } |
| + |
| + grid.newpage() # (empty slate) |
| + ## device |
| + do.click("inches") |
| + Sys.sleep(1) |
| + |
| + pushViewport(viewport(width=0.5, height=0.5, |
| + xscale=c(0, 100), yscale=c(0, 10))) |
| + grid.rect() |
| + grid.xaxis() |
| + grid.yaxis() |
| + do.click("native") |
| + popViewport() |
| + } |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.ls") |
| > ### * grid.ls |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.ls |
| > ### Title: List the names of grobs or viewports |
| > ### Aliases: grid.ls nestedListing pathListing grobPathListing |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # A gTree, called "parent", with childrenvp vpTree (vp2 within vp1) |
| > # and child grob, called "child", with vp vpPath (down to vp2) |
| > sampleGTree <- gTree(name="parent", |
| + children=gList(grob(name="child", vp="vp1::vp2")), |
| + childrenvp=vpTree(parent=viewport(name="vp1"), |
| + children=vpList(viewport(name="vp2")))) |
| > grid.ls(sampleGTree) |
| parent |
| child |
| > # Show viewports too |
| > grid.ls(sampleGTree, view=TRUE) |
| parent |
| vp1 |
| vp2 |
| 2 |
| vp1 |
| vp2 |
| child |
| 2 |
| > # Only show viewports |
| > grid.ls(sampleGTree, view=TRUE, grob=FALSE) |
| vp1 |
| vp2 |
| 2 |
| vp1 |
| vp2 |
| 2 |
| > # Alternate displays |
| > # nested listing, custom indent |
| > grid.ls(sampleGTree, view=TRUE, print=nestedListing, gindent="--") |
| parent |
| --vp1 |
| ----vp2 |
| ------2 |
| --vp1 |
| ----vp2 |
| ------child |
| ------2 |
| > # path listing |
| > grid.ls(sampleGTree, view=TRUE, print=pathListing) |
| | parent |
| vp1 |
| vp1::vp2 |
| vp1::vp2::2 |
| vp1 |
| vp1::vp2 |
| vp1::vp2 | parent::child |
| vp1::vp2::2 |
| > # path listing, without grobs aligned |
| > grid.ls(sampleGTree, view=TRUE, print=pathListing, gAlign=FALSE) |
| | parent |
| vp1 |
| vp1::vp2 |
| vp1::vp2::2 |
| vp1 |
| vp1::vp2 |
| vp1::vp2 | parent::child |
| vp1::vp2::2 |
| > # grob path listing |
| > grid.ls(sampleGTree, view=TRUE, print=grobPathListing) |
| | parent |
| vp1::vp2 | parent::child |
| > # path listing, grobs only |
| > grid.ls(sampleGTree, print=pathListing) |
| | parent |
| | parent::child |
| > # path listing, viewports only |
| > grid.ls(sampleGTree, view=TRUE, grob=FALSE, print=pathListing) |
| vp1 |
| vp1::vp2 |
| vp1::vp2::2 |
| vp1 |
| vp1::vp2 |
| vp1::vp2::2 |
| > # raw flat listing |
| > str(grid.ls(sampleGTree, view=TRUE, print=FALSE)) |
| List of 6 |
| $ name : chr [1:8] "parent" "vp1" "vp2" "2" ... |
| $ gDepth : num [1:8] 0 1 1 1 1 1 1 1 |
| $ vpDepth: num [1:8] 0 0 1 2 0 1 2 2 |
| $ gPath : chr [1:8] "" "parent" "parent" "parent" ... |
| $ vpPath : chr [1:8] "" "" "vp1" "vp1::vp2" ... |
| $ type : chr [1:8] "gTreeListing" "vpListing" "vpListing" "vpUpListing" ... |
| - attr(*, "class")= chr "flatGridListing" |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.move.to") |
| > ### * grid.move.to |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.move.to |
| > ### Title: Move or Draw to a Specified Position |
| > ### Aliases: grid.move.to grid.line.to moveToGrob lineToGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > grid.move.to(0.5, 0.5) |
| > grid.line.to(1, 1) |
| > grid.line.to(0.5, 0) |
| > pushViewport(viewport(x=0, y=0, w=0.25, h=0.25, just=c("left", "bottom"))) |
| > grid.rect() |
| > grid.grill() |
| > grid.line.to(0.5, 0.5) |
| > popViewport() |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.null") |
| > ### * grid.null |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.null |
| > ### Title: Null Graphical Object |
| > ### Aliases: grid.null nullGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > grid.null(name="ref") |
| > grid.rect(height=grobHeight("ref")) |
| > grid.segments(0, 0, grobX("ref", 0), grobY("ref", 0)) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.path") |
| > ### * grid.path |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.path |
| > ### Title: Draw a Path |
| > ### Aliases: grid.path pathGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > pathSample <- function(x, y, rule, gp = gpar()) { |
| + if (is.na(rule)) |
| + grid.path(x, y, id = rep(1:2, each = 4), gp = gp) |
| + else |
| + grid.path(x, y, id = rep(1:2, each = 4), rule = rule, gp = gp) |
| + if (!is.na(rule)) |
| + grid.text(paste("Rule:", rule), y = 0, just = "bottom") |
| + } |
| > |
| > pathTriplet <- function(x, y, title) { |
| + pushViewport(viewport(height = 0.9, layout = grid.layout(1, 3), |
| + gp = gpar(cex = .7))) |
| + grid.rect(y = 1, height = unit(1, "char"), just = "top", |
| + gp = gpar(col = NA, fill = "grey")) |
| + grid.text(title, y = 1, just = "top") |
| + pushViewport(viewport(layout.pos.col = 1)) |
| + pathSample(x, y, rule = "winding", |
| + gp = gpar(fill = "grey")) |
| + popViewport() |
| + pushViewport(viewport(layout.pos.col = 2)) |
| + pathSample(x, y, rule = "evenodd", |
| + gp = gpar(fill = "grey")) |
| + popViewport() |
| + pushViewport(viewport(layout.pos.col = 3)) |
| + pathSample(x, y, rule = NA) |
| + popViewport() |
| + popViewport() |
| + } |
| > |
| > pathTest <- function() { |
| + grid.newpage() |
| + pushViewport(viewport(layout = grid.layout(5, 1))) |
| + pushViewport(viewport(layout.pos.row = 1)) |
| + pathTriplet(c(.1, .1, .9, .9, .2, .2, .8, .8), |
| + c(.1, .9, .9, .1, .2, .8, .8, .2), |
| + "Nested rectangles, both clockwise") |
| + popViewport() |
| + pushViewport(viewport(layout.pos.row = 2)) |
| + pathTriplet(c(.1, .1, .9, .9, .2, .8, .8, .2), |
| + c(.1, .9, .9, .1, .2, .2, .8, .8), |
| + "Nested rectangles, outer clockwise, inner anti-clockwise") |
| + popViewport() |
| + pushViewport(viewport(layout.pos.row = 3)) |
| + pathTriplet(c(.1, .1, .4, .4, .6, .9, .9, .6), |
| + c(.1, .4, .4, .1, .6, .6, .9, .9), |
| + "Disjoint rectangles") |
| + popViewport() |
| + pushViewport(viewport(layout.pos.row = 4)) |
| + pathTriplet(c(.1, .1, .6, .6, .4, .4, .9, .9), |
| + c(.1, .6, .6, .1, .4, .9, .9, .4), |
| + "Overlapping rectangles, both clockwise") |
| + popViewport() |
| + pushViewport(viewport(layout.pos.row = 5)) |
| + pathTriplet(c(.1, .1, .6, .6, .4, .9, .9, .4), |
| + c(.1, .6, .6, .1, .4, .4, .9, .9), |
| + "Overlapping rectangles, one clockwise, other anti-clockwise") |
| + popViewport() |
| + popViewport() |
| + } |
| > |
| > pathTest() |
| > |
| > # Drawing multiple paths at once |
| > holed_rect <- cbind(c(.15, .15, -.15, -.15, .1, .1, -.1, -.1), |
| + c(.15, -.15, -.15, .15, .1, -.1, -.1, .1)) |
| > holed_rects <- rbind( |
| + holed_rect + matrix(c(.7, .2), nrow = 8, ncol = 2, byrow = TRUE), |
| + holed_rect + matrix(c(.7, .8), nrow = 8, ncol = 2, byrow = TRUE), |
| + holed_rect + matrix(c(.2, .5), nrow = 8, ncol = 2, byrow = TRUE) |
| + ) |
| > grid.newpage() |
| > grid.path(x = holed_rects[, 1], y = holed_rects[, 2], |
| + id = rep(1:6, each = 4), pathId = rep(1:3, each = 8), |
| + gp = gpar(fill = c('red', 'blue', 'green')), |
| + rule = 'evenodd') |
| > |
| > # Not specifying pathId will treat all points as part of the same path, thus |
| > # having same fill |
| > grid.newpage() |
| > grid.path(x = holed_rects[, 1], y = holed_rects[, 2], |
| + id = rep(1:6, each = 4), |
| + gp = gpar(fill = c('red', 'blue', 'green')), |
| + rule = 'evenodd') |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.plot.and.legend") |
| > ### * grid.plot.and.legend |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.plot.and.legend |
| > ### Title: A Simple Plot and Legend Demo |
| > ### Aliases: grid.plot.and.legend |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.plot.and.legend() |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.polygon") |
| > ### * grid.polygon |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.polygon |
| > ### Title: Draw a Polygon |
| > ### Aliases: grid.polygon polygonGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.polygon() |
| > # Using id (NOTE: locations are not in consecutive blocks) |
| > grid.newpage() |
| > grid.polygon(x=c((0:4)/10, rep(.5, 5), (10:6)/10, rep(.5, 5)), |
| + y=c(rep(.5, 5), (10:6/10), rep(.5, 5), (0:4)/10), |
| + id=rep(1:5, 4), |
| + gp=gpar(fill=1:5)) |
| > # Using id.lengths |
| > grid.newpage() |
| > grid.polygon(x=outer(c(0, .5, 1, .5), 5:1/5), |
| + y=outer(c(.5, 1, .5, 0), 5:1/5), |
| + id.lengths=rep(4, 5), |
| + gp=gpar(fill=1:5)) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.raster") |
| > ### * grid.raster |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.raster |
| > ### Title: Render a raster object |
| > ### Aliases: grid.raster rasterGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > redGradient <- matrix(hcl(0, 80, seq(50, 80, 10)), |
| + nrow=4, ncol=5) |
| > # interpolated |
| > grid.newpage() |
| > grid.raster(redGradient) |
| > # blocky |
| > grid.newpage() |
| > grid.raster(redGradient, interpolate=FALSE) |
| > # blocky and stretched |
| > grid.newpage() |
| > grid.raster(redGradient, interpolate=FALSE, height=unit(1, "npc")) |
| > |
| > # The same raster drawn several times |
| > grid.newpage() |
| > grid.raster(0, x=1:3/4, y=1:3/4, w=.1, interp=FALSE) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.record") |
| > ### * grid.record |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.record |
| > ### Title: Encapsulate calculations and drawing |
| > ### Aliases: grid.record recordGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.record({ |
| + w <- convertWidth(unit(1, "inches"), "npc") |
| + grid.rect(width=w) |
| + }, |
| + list()) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.reorder") |
| > ### * grid.reorder |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.reorder |
| > ### Title: Reorder the children of a gTree |
| > ### Aliases: grid.reorder reorderGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # gTree with two children, "red-rect" and "blue-rect" (in that order) |
| > gt <- gTree(children=gList( |
| + rectGrob(gp=gpar(col=NA, fill="red"), |
| + width=.8, height=.2, name="red-rect"), |
| + rectGrob(gp=gpar(col=NA, fill="blue"), |
| + width=.2, height=.8, name="blue-rect")), |
| + name="gt") |
| > grid.newpage() |
| > grid.draw(gt) |
| > # Spec entire order as numeric (blue-rect, red-rect) |
| > grid.reorder("gt", 2:1) |
| > # Spec entire order as character |
| > grid.reorder("gt", c("red-rect", "blue-rect")) |
| > # Only spec the one I want behind as character |
| > grid.reorder("gt", "blue-rect") |
| > # Only spec the one I want in front as character |
| > grid.reorder("gt", "blue-rect", back=FALSE) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.roundrect") |
| > ### * grid.roundrect |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: roundrect |
| > ### Title: Draw a rectangle with rounded corners |
| > ### Aliases: roundrect grid.roundrect roundrectGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.roundrect(width=.5, height=.5, name="rr") |
| > theta <- seq(0, 360, length=50) |
| > for (i in 1:50) |
| + grid.circle(x=grobX("rr", theta[i]), |
| + y=grobY("rr", theta[i]), |
| + r=unit(1, "mm"), |
| + gp=gpar(fill="black")) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.show.layout") |
| > ### * grid.show.layout |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.show.layout |
| > ### Title: Draw a Diagram of a Grid Layout |
| > ### Aliases: grid.show.layout |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > ## Diagram of a simple layout |
| > grid.show.layout(grid.layout(4,2, |
| + heights=unit(rep(1, 4), |
| + c("lines", "lines", "lines", "null")), |
| + widths=unit(c(1, 1), "inches"))) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.show.viewport") |
| > ### * grid.show.viewport |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.show.viewport |
| > ### Title: Draw a Diagram of a Grid Viewport |
| > ### Aliases: grid.show.viewport |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > ## Diagram of a sample viewport |
| > grid.show.viewport(viewport(x=0.6, y=0.6, |
| + w=unit(1, "inches"), h=unit(1, "inches"))) |
| > grid.show.viewport(viewport(layout.pos.row=2, layout.pos.col=2:3), |
| + grid.layout(3, 4)) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.text") |
| > ### * grid.text |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.text |
| > ### Title: Draw Text |
| > ### Aliases: grid.text textGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > x <- stats::runif(20) |
| > y <- stats::runif(20) |
| > rot <- stats::runif(20, 0, 360) |
| > grid.text("SOMETHING NICE AND BIG", x=x, y=y, rot=rot, |
| + gp=gpar(fontsize=20, col="grey")) |
| > grid.text("SOMETHING NICE AND BIG", x=x, y=y, rot=rot, |
| + gp=gpar(fontsize=20), check=TRUE) |
| > grid.newpage() |
| > draw.text <- function(just, i, j) { |
| + grid.text("ABCD", x=x[j], y=y[i], just=just) |
| + grid.text(deparse(substitute(just)), x=x[j], y=y[i] + unit(2, "lines"), |
| + gp=gpar(col="grey", fontsize=8)) |
| + } |
| > x <- unit(1:4/5, "npc") |
| > y <- unit(1:4/5, "npc") |
| > grid.grill(h=y, v=x, gp=gpar(col="grey")) |
| > draw.text(c("bottom"), 1, 1) |
| > draw.text(c("left", "bottom"), 2, 1) |
| > draw.text(c("right", "bottom"), 3, 1) |
| > draw.text(c("centre", "bottom"), 4, 1) |
| > draw.text(c("centre"), 1, 2) |
| > draw.text(c("left", "centre"), 2, 2) |
| > draw.text(c("right", "centre"), 3, 2) |
| > draw.text(c("centre", "centre"), 4, 2) |
| > draw.text(c("top"), 1, 3) |
| > draw.text(c("left", "top"), 2, 3) |
| > draw.text(c("right", "top"), 3, 3) |
| > draw.text(c("centre", "top"), 4, 3) |
| > draw.text(c(), 1, 4) |
| > draw.text(c("left"), 2, 4) |
| > draw.text(c("right"), 3, 4) |
| > draw.text(c("centre"), 4, 4) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("grid.xspline") |
| > ### * grid.xspline |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: grid.xspline |
| > ### Title: Draw an Xspline |
| > ### Aliases: grid.xspline xsplineGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > x <- c(0.25, 0.25, 0.75, 0.75) |
| > y <- c(0.25, 0.75, 0.75, 0.25) |
| > |
| > xsplineTest <- function(s, i, j, open) { |
| + pushViewport(viewport(layout.pos.col=j, layout.pos.row=i)) |
| + grid.points(x, y, default.units="npc", pch=16, size=unit(2, "mm")) |
| + grid.xspline(x, y, shape=s, open=open, gp=gpar(fill="grey")) |
| + grid.text(s, gp=gpar(col="grey"), |
| + x=unit(x, "npc") + unit(c(-1, -1, 1, 1), "mm"), |
| + y=unit(y, "npc") + unit(c(-1, 1, 1, -1), "mm"), |
| + hjust=c(1, 1, 0, 0), |
| + vjust=c(1, 0, 0, 1)) |
| + popViewport() |
| + } |
| > |
| > pushViewport(viewport(width=.5, x=0, just="left", |
| + layout=grid.layout(3, 3, respect=TRUE))) |
| > pushViewport(viewport(layout.pos.row=1)) |
| > grid.text("Open Splines", y=1, just="bottom") |
| > popViewport() |
| > xsplineTest(c(0, -1, -1, 0), 1, 1, TRUE) |
| > xsplineTest(c(0, -1, 0, 0), 1, 2, TRUE) |
| > xsplineTest(c(0, -1, 1, 0), 1, 3, TRUE) |
| > xsplineTest(c(0, 0, -1, 0), 2, 1, TRUE) |
| > xsplineTest(c(0, 0, 0, 0), 2, 2, TRUE) |
| > xsplineTest(c(0, 0, 1, 0), 2, 3, TRUE) |
| > xsplineTest(c(0, 1, -1, 0), 3, 1, TRUE) |
| > xsplineTest(c(0, 1, 0, 0), 3, 2, TRUE) |
| > xsplineTest(c(0, 1, 1, 0), 3, 3, TRUE) |
| > popViewport() |
| > pushViewport(viewport(width=.5, x=1, just="right", |
| + layout=grid.layout(3, 3, respect=TRUE))) |
| > pushViewport(viewport(layout.pos.row=1)) |
| > grid.text("Closed Splines", y=1, just="bottom") |
| > popViewport() |
| > xsplineTest(c(-1, -1, -1, -1), 1, 1, FALSE) |
| > xsplineTest(c(-1, -1, 0, -1), 1, 2, FALSE) |
| > xsplineTest(c(-1, -1, 1, -1), 1, 3, FALSE) |
| > xsplineTest(c( 0, 0, -1, 0), 2, 1, FALSE) |
| > xsplineTest(c( 0, 0, 0, 0), 2, 2, FALSE) |
| > xsplineTest(c( 0, 0, 1, 0), 2, 3, FALSE) |
| > xsplineTest(c( 1, 1, -1, 1), 3, 1, FALSE) |
| > xsplineTest(c( 1, 1, 0, 1), 3, 2, FALSE) |
| > xsplineTest(c( 1, 1, 1, 1), 3, 3, FALSE) |
| > popViewport() |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("legendGrob") |
| > ### * legendGrob |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: legendGrob |
| > ### Title: Constructing a Legend Grob |
| > ### Aliases: legendGrob grid.legend |
| > ### Keywords: aplot |
| > |
| > ### ** Examples |
| > |
| > ## Data: |
| > n <- 10 |
| > x <- stats::runif(n) ; y1 <- stats::runif(n) ; y2 <- stats::runif(n) |
| > ## Construct the grobs : |
| > plot <- gTree(children=gList(rectGrob(), |
| + pointsGrob(x, y1, pch=21, gp=gpar(col=2, fill="gray")), |
| + pointsGrob(x, y2, pch=22, gp=gpar(col=3, fill="gray")), |
| + xaxisGrob(), |
| + yaxisGrob())) |
| > legd <- legendGrob(c("Girls", "Boys", "Other"), pch=21:23, |
| + gp=gpar(col = 2:4, fill = "gray")) |
| > gg <- packGrob(packGrob(frameGrob(), plot), |
| + legd, height=unit(1,"null"), side="right") |
| > |
| > ## Now draw it on a new device page: |
| > grid.newpage() |
| > pushViewport(viewport(width=0.8, height=0.8)) |
| > grid.draw(gg) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("resolveRasterSize") |
| > ### * resolveRasterSize |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: resolveRasterSize |
| > ### Title: Utility function to resolve the size of a raster grob |
| > ### Aliases: resolveRasterSize |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # Square raster |
| > rg <- rasterGrob(matrix(0)) |
| > # Fill the complete page (if page is square) |
| > grid.newpage() |
| > resolveRasterSize(rg)$height |
| [1] 6.8inches |
| > grid.draw(rg) |
| > # Forced to fit tall thin region |
| > grid.newpage() |
| > pushViewport(viewport(width=.1)) |
| > resolveRasterSize(rg)$height |
| [1] 0.68inches |
| > grid.draw(rg) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("showGrob") |
| > ### * showGrob |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: showGrob |
| > ### Title: Label grid grobs. |
| > ### Aliases: showGrob |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > gt <- gTree(childrenvp=vpStack( |
| + viewport(x=0, width=.5, just="left", name="vp"), |
| + viewport(y=.5, height=.5, just="bottom", name="vp2")), |
| + children=gList(rectGrob(vp="vp::vp2", name="child")), |
| + name="parent") |
| > grid.draw(gt) |
| > showGrob() |
| > showGrob(gPath="child") |
| > showGrob(recurse=FALSE) |
| > showGrob(depth=1) |
| > showGrob(depth=2) |
| > showGrob(depth=1:2) |
| > showGrob(gt) |
| > showGrob(gt, gPath="child") |
| > showGrob(just="left", gp=gpar(col="red", cex=.5), rot=45) |
| > showGrob(labelfun=function(grob, ...) { |
| + x <- grobX(grob, "west") |
| + y <- grobY(grob, "north") |
| + gTree(children=gList(rectGrob(x=x, y=y, |
| + width=stringWidth(grob$name) + unit(2, "mm"), |
| + height=stringHeight(grob$name) + unit(2, "mm"), |
| + gp=gpar(col=NA, fill=rgb(1, 0, 0, .5)), |
| + just=c("left", "top")), |
| + textGrob(grob$name, |
| + x=x + unit(1, "mm"), y=y - unit(1, "mm"), |
| + just=c("left", "top")))) |
| + }) |
| > |
| > ## Not run: |
| > ##D # Examples from higher-level packages |
| > ##D |
| > ##D library(lattice) |
| > ##D # Ctrl-c after first example |
| > ##D example(histogram) |
| > ##D showGrob() |
| > ##D showGrob(gPath="plot_01.ylab") |
| > ##D |
| > ##D library(ggplot2) |
| > ##D # Ctrl-c after first example |
| > ##D example(qplot) |
| > ##D showGrob() |
| > ##D showGrob(recurse=FALSE) |
| > ##D showGrob(gPath="panel-3-3") |
| > ##D showGrob(gPath="axis.title", grep=TRUE) |
| > ##D showGrob(depth=2) |
| > ## End(Not run) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("showViewport") |
| > ### * showViewport |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: showViewport |
| > ### Title: Display grid viewports. |
| > ### Aliases: showViewport |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > showViewport(viewport(width=.5, height=.5, name="vp")) |
| > |
| > grid.newpage() |
| > pushViewport(viewport(width=.5, height=.5, name="vp")) |
| > upViewport() |
| > showViewport(vpPath("vp")) |
| > |
| > showViewport(vpStack(viewport(width=.5, height=.5, name="vp1"), |
| + viewport(width=.5, height=.5, name="vp2")), |
| + newpage=TRUE) |
| > |
| > showViewport(vpStack(viewport(width=.5, height=.5, name="vp1"), |
| + viewport(width=.5, height=.5, name="vp2")), |
| + fill=rgb(1:0, 0:1, 0, .1), |
| + newpage=TRUE) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("unit") |
| > ### * unit |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: unit |
| > ### Title: Function to Create a Unit Object |
| > ### Aliases: unit |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > unit(1, "npc") |
| [1] 1npc |
| > unit(1:3/4, "npc") |
| [1] 0.25npc 0.5npc 0.75npc |
| > unit(1:3/4, "npc") + unit(1, "inches") |
| [1] 0.25npc+1inches 0.5npc+1inches 0.75npc+1inches |
| > min(unit(0.5, "npc"), unit(1, "inches")) |
| [1] min(0.5npc, 1inches) |
| > unit.c(unit(0.5, "npc"), unit(2, "inches") + unit(1:3/4, "npc"), |
| + unit(1, "strwidth", "hi there")) |
| [1] 0.5npc 2inches+0.25npc 2inches+0.5npc 2inches+0.75npc |
| [5] 1strwidth |
| > x <- unit(1:5, "npc") |
| > x[2:4] |
| [1] 2npc 3npc 4npc |
| > x[2:4] <- unit(1, "mm") |
| > x |
| [1] 1npc 1mm 1mm 1mm 5npc |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("unit.length") |
| > ### * unit.length |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: unit.length |
| > ### Title: Length of a Unit Object |
| > ### Aliases: unit.length |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > length(unit(1:3, "npc")) |
| [1] 3 |
| > length(unit(1:3, "npc") + unit(1, "inches")) |
| [1] 3 |
| > length(max(unit(1:3, "npc") + unit(1, "inches"))) |
| [1] 1 |
| > length(max(unit(1:3, "npc") + unit(1, "strwidth", "a"))*4) |
| [1] 1 |
| > length(unit(1:3, "npc") + unit(1, "strwidth", "a")*4) |
| [1] 3 |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("unit.pmin") |
| > ### * unit.pmin |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: unit.pmin |
| > ### Title: Parallel Unit Minima and Maxima |
| > ### Aliases: unit.pmin unit.pmax |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > max(unit(1:3, "cm"), unit(0.5, "npc")) |
| [1] max(1cm, 2cm, 3cm, 0.5npc) |
| > unit.pmax(unit(1:3, "cm"), unit(0.5, "npc")) |
| [1] max(1cm, 0.5npc) max(2cm, 0.5npc) max(3cm, 0.5npc) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("unit.rep") |
| > ### * unit.rep |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: unit.rep |
| > ### Title: Replicate Elements of Unit Objects |
| > ### Aliases: unit.rep |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > rep(unit(1:3, "npc"), 3) |
| [1] 1npc 2npc 3npc 1npc 2npc 3npc 1npc 2npc 3npc |
| > rep(unit(1:3, "npc"), 1:3) |
| [1] 1npc 2npc 2npc 3npc 3npc 3npc |
| > rep(unit(1:3, "npc") + unit(1, "inches"), 3) |
| [1] 1npc+1inches 2npc+1inches 3npc+1inches 1npc+1inches 2npc+1inches |
| [6] 3npc+1inches 1npc+1inches 2npc+1inches 3npc+1inches |
| > rep(max(unit(1:3, "npc") + unit(1, "inches")), 3) |
| [1] max(1npc+1inches, 2npc+1inches, 3npc+1inches) |
| [2] max(1npc+1inches, 2npc+1inches, 3npc+1inches) |
| [3] max(1npc+1inches, 2npc+1inches, 3npc+1inches) |
| > rep(max(unit(1:3, "npc") + unit(1, "strwidth", "a"))*4, 3) |
| [1] 4*max(1npc+1strwidth, 2npc+1strwidth, 3npc+1strwidth) |
| [2] 4*max(1npc+1strwidth, 2npc+1strwidth, 3npc+1strwidth) |
| [3] 4*max(1npc+1strwidth, 2npc+1strwidth, 3npc+1strwidth) |
| > rep(unit(1:3, "npc") + unit(1, "strwidth", "a")*4, 3) |
| [1] 1npc+4*1strwidth 2npc+4*1strwidth 3npc+4*1strwidth 1npc+4*1strwidth |
| [5] 2npc+4*1strwidth 3npc+4*1strwidth 1npc+4*1strwidth 2npc+4*1strwidth |
| [9] 3npc+4*1strwidth |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("viewport") |
| > ### * viewport |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: Grid Viewports |
| > ### Title: Create a Grid Viewport |
| > ### Aliases: viewport vpList vpStack vpTree |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # Diagram of a sample viewport |
| > grid.show.viewport(viewport(x=0.6, y=0.6, |
| + w=unit(1, "inches"), h=unit(1, "inches"))) |
| > # Demonstrate viewport clipping |
| > clip.demo <- function(i, j, clip1, clip2) { |
| + pushViewport(viewport(layout.pos.col=i, |
| + layout.pos.row=j)) |
| + pushViewport(viewport(width=0.6, height=0.6, clip=clip1)) |
| + grid.rect(gp=gpar(fill="white")) |
| + grid.circle(r=0.55, gp=gpar(col="red", fill="pink")) |
| + popViewport() |
| + pushViewport(viewport(width=0.6, height=0.6, clip=clip2)) |
| + grid.polygon(x=c(0.5, 1.1, 0.6, 1.1, 0.5, -0.1, 0.4, -0.1), |
| + y=c(0.6, 1.1, 0.5, -0.1, 0.4, -0.1, 0.5, 1.1), |
| + gp=gpar(col="blue", fill="light blue")) |
| + popViewport(2) |
| + } |
| > |
| > grid.newpage() |
| > grid.rect(gp=gpar(fill="grey")) |
| > pushViewport(viewport(layout=grid.layout(2, 2))) |
| > clip.demo(1, 1, FALSE, FALSE) |
| > clip.demo(1, 2, TRUE, FALSE) |
| > clip.demo(2, 1, FALSE, TRUE) |
| > clip.demo(2, 2, TRUE, TRUE) |
| > popViewport() |
| > # Demonstrate turning clipping off |
| > grid.newpage() |
| > pushViewport(viewport(w=.5, h=.5, clip="on")) |
| > grid.rect() |
| > grid.circle(r=.6, gp=gpar(lwd=10)) |
| > pushViewport(viewport(clip="inherit")) |
| > grid.circle(r=.6, gp=gpar(lwd=5, col="grey")) |
| > pushViewport(viewport(clip="off")) |
| > grid.circle(r=.6) |
| > popViewport(3) |
| > # Demonstrate vpList, vpStack, and vpTree |
| > grid.newpage() |
| > tree <- vpTree(viewport(w=0.8, h=0.8, name="A"), |
| + vpList(vpStack(viewport(x=0.1, y=0.1, w=0.5, h=0.5, |
| + just=c("left", "bottom"), name="B"), |
| + viewport(x=0.1, y=0.1, w=0.5, h=0.5, |
| + just=c("left", "bottom"), name="C"), |
| + viewport(x=0.1, y=0.1, w=0.5, h=0.5, |
| + just=c("left", "bottom"), name="D")), |
| + viewport(x=0.5, w=0.4, h=0.9, |
| + just="left", name="E"))) |
| > pushViewport(tree) |
| > for (i in LETTERS[1:5]) { |
| + seekViewport(i) |
| + grid.rect() |
| + grid.text(current.vpTree(FALSE), |
| + x=unit(1, "mm"), y=unit(1, "npc") - unit(1, "mm"), |
| + just=c("left", "top"), |
| + gp=gpar(fontsize=8)) |
| + } |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("viewports") |
| > ### * viewports |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: Working with Viewports |
| > ### Title: Maintaining and Navigating the Grid Viewport Tree |
| > ### Aliases: pushViewport downViewport seekViewport popViewport upViewport |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > # push the same viewport several times |
| > grid.newpage() |
| > vp <- viewport(width=0.5, height=0.5) |
| > pushViewport(vp) |
| > grid.rect(gp=gpar(col="blue")) |
| > grid.text("Quarter of the device", |
| + y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="blue")) |
| > pushViewport(vp) |
| > grid.rect(gp=gpar(col="red")) |
| > grid.text("Quarter of the parent viewport", |
| + y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="red")) |
| > popViewport(2) |
| > # push several viewports then navigate amongst them |
| > grid.newpage() |
| > grid.rect(gp=gpar(col="grey")) |
| > grid.text("Top-level viewport", |
| + y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="grey")) |
| > if (interactive()) Sys.sleep(1.0) |
| > pushViewport(viewport(width=0.8, height=0.7, name="A")) |
| > grid.rect(gp=gpar(col="blue")) |
| > grid.text("1. Push Viewport A", |
| + y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="blue")) |
| > if (interactive()) Sys.sleep(1.0) |
| > pushViewport(viewport(x=0.1, width=0.3, height=0.6, |
| + just="left", name="B")) |
| > grid.rect(gp=gpar(col="red")) |
| > grid.text("2. Push Viewport B (in A)", |
| + y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="red")) |
| > if (interactive()) Sys.sleep(1.0) |
| > upViewport(1) |
| > grid.text("3. Up from B to A", |
| + y=unit(1, "npc") - unit(2, "lines"), gp=gpar(col="blue")) |
| > if (interactive()) Sys.sleep(1.0) |
| > pushViewport(viewport(x=0.5, width=0.4, height=0.8, |
| + just="left", name="C")) |
| > grid.rect(gp=gpar(col="green")) |
| > grid.text("4. Push Viewport C (in A)", |
| + y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="green")) |
| > if (interactive()) Sys.sleep(1.0) |
| > pushViewport(viewport(width=0.8, height=0.6, name="D")) |
| > grid.rect() |
| > grid.text("5. Push Viewport D (in C)", |
| + y=unit(1, "npc") - unit(1, "lines")) |
| > if (interactive()) Sys.sleep(1.0) |
| > upViewport(0) |
| > grid.text("6. Up from D to top-level", |
| + y=unit(1, "npc") - unit(2, "lines"), gp=gpar(col="grey")) |
| > if (interactive()) Sys.sleep(1.0) |
| > downViewport("D") |
| > grid.text("7. Down from top-level to D", |
| + y=unit(1, "npc") - unit(2, "lines")) |
| > if (interactive()) Sys.sleep(1.0) |
| > seekViewport("B") |
| > grid.text("8. Seek from D to B", |
| + y=unit(1, "npc") - unit(2, "lines"), gp=gpar(col="red")) |
| > pushViewport(viewport(width=0.9, height=0.5, name="A")) |
| > grid.rect() |
| > grid.text("9. Push Viewport A (in B)", |
| + y=unit(1, "npc") - unit(1, "lines")) |
| > if (interactive()) Sys.sleep(1.0) |
| > seekViewport("A") |
| > grid.text("10. Seek from B to A (in ROOT)", |
| + y=unit(1, "npc") - unit(3, "lines"), gp=gpar(col="blue")) |
| > if (interactive()) Sys.sleep(1.0) |
| > seekViewport(vpPath("B", "A")) |
| > grid.text("11. Seek from\nA (in ROOT)\nto A (in B)") |
| > popViewport(0) |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("vpPath") |
| > ### * vpPath |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: vpPath |
| > ### Title: Concatenate Viewport Names |
| > ### Aliases: vpPath |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > vpPath("vp1", "vp2") |
| vp1::vp2 |
| > |
| > |
| > |
| > cleanEx() |
| > nameEx("xsplinePoints") |
| > ### * xsplinePoints |
| > |
| > flush(stderr()); flush(stdout()) |
| > |
| > ### Name: xsplinePoints |
| > ### Title: Return the points that would be used to draw an Xspline (or a |
| > ### Bezier curve). |
| > ### Aliases: xsplinePoints bezierPoints |
| > ### Keywords: dplot |
| > |
| > ### ** Examples |
| > |
| > grid.newpage() |
| > xsg <- xsplineGrob(c(.1, .1, .9, .9), c(.1, .9, .9, .1), shape=1) |
| > grid.draw(xsg) |
| > trace <- xsplinePoints(xsg) |
| > grid.circle(trace$x, trace$y, default.units="inches", r=unit(.5, "mm")) |
| > |
| > grid.newpage() |
| > vp <- viewport(width=.5) |
| > xg <- xsplineGrob(x=c(0, .2, .4, .2, .5, .7, .9, .7), |
| + y=c(.5, 1, .5, 0, .5, 1, .5, 0), |
| + id=rep(1:2, each=4), |
| + shape=1, |
| + vp=vp) |
| > grid.draw(xg) |
| > trace <- xsplinePoints(xg) |
| > pushViewport(vp) |
| > invisible(lapply(trace, function(t) grid.lines(t$x, t$y, gp=gpar(col="red")))) |
| > popViewport() |
| > |
| > grid.newpage() |
| > bg <- bezierGrob(c(.2, .2, .8, .8), c(.2, .8, .8, .2)) |
| > grid.draw(bg) |
| > trace <- bezierPoints(bg) |
| > grid.circle(trace$x, trace$y, default.units="inches", r=unit(.5, "mm")) |
| > |
| > |
| > |
| > ### * <FOOTER> |
| > ### |
| > cleanEx() |
| > options(digits = 7L) |
| > base::cat("Time elapsed: ", proc.time() - base::get("ptime", pos = 'CheckExEnv'),"\n") |
| Time elapsed: 1.675 0.023 1.706 0 0 |
| > grDevices::dev.off() |
| null device |
| 1 |
| > ### |
| > ### Local variables: *** |
| > ### mode: outline-minor *** |
| > ### outline-regexp: "\\(> \\)?### [*]+" *** |
| > ### End: *** |
| > quit('no') |
