Grid TODO list

• Fix up problem where can specify non-existent gpar() settings, e.g., gpar(color="red").
• Provide a way to store user-defined "state" in a viewport.
• Pattern and gradient fills for rectangles, polygons, circles.
  
• Create PDF versions of grid documentation.
  These are now done.
• Replace "origin" slot for grid viewports (was in very early versions, but got removed; replacement motivated by email on R-help "changing coordinates?" from Richard Mueller. A better way to do this is to allow specifications for xscale and yscale of the form c(10, 0). This is what base graphics can do.
  This is now done
• An SVG device for grid(?) -- would allow hierarchical information to be retained (lost if go through R graphics engine).
  There is now a start on this; see the gridSVG package.
• Write a decent user's guide for grid.
  There is an overview document available for grid plus a book.
  
• Write some high-level plots in grid. Mostly thinking about redoing some of the base graphics plots here, but also things like the plots in the BioConductor hexbin package (which is running into trouble with arranging plots using the base graphics capabilities).
  Nichoals Lewin-Koh working on a grid version of hexbin.
• Write reverse-transformations for all coordinate systems so that, for example, it is possible to work out where a mouse click occurred in different coordinate systems.
  In R 1.8.0.
• Fix up base (separate bits out of GNewPlot and make the "valid" flag less integral) so that I can make grid images arbitrarily small (at the moment I have the annoying situation where I get an "invalid margins" error from base graphics in a grid image!).
  In R 2.0.0
• Get some sort of locator() and identify() working with grid. (Need to look at the REventLoop package to see if something more general can/should be achieved.)
  There is a grid.locator() in R 1.8.0. More support for something like a grid.identify would be useful.
• Allow more general selection of grid objects.
  There are the grid.[get/set/add/remove/edit]Grob() functions for accessing grobs and their components by name; can be quite general with use of grep and global arguments. (command-line only interface, but provides possible basis for GUI stuff).
  I have some tcl/tk code to select objects via a directory-tree listing of objects. but it doesn't work very well :(
• Implement non-linear scales for "native" coordinates.
• Reinstate the "origin" slot for viewports. It is possible to "fake" this sort of effect using unit arithmetic and/or the fact that scale ranges can be specified (highest, lowest), but as Stephen Eglen pointed out in an email, this sort of thing requires the user to know more about what is being plotted than is perhaps necessary (e.g., in order to reverse the scale you have to know the limits; in many cases, the user deliberately lets the system decide the limits so this becomes inconvenient).
• Implement non-rectangular coordinates (e.g., polar coords).
• Provide some compatibility between base and grid graphics.
  See the gridBase package (requires R 1.8.0). This provides support for mixing base and grid output.
• Make redrawing of grid objects multiple-device-aware; this currently assumes that there is only one device.
  There is a "not yet implemented" allDevices argument in grid.edit() et al aimed at serving this need.
• Make grid primitives (e.g., grid.lines(), grid.points(), ...) respond to NA values like the base counterparts.
  Done for R 2.0
  There was discussion of this on one of the R mailing lists. The general consensus seemed to be that missing x- and y-values would represent missing data, but missing graphical parameters would not (but they should probably lead to a warning or error). There's a broader issue here of what to do to represent missing values. The base graphics approach mostly corresponds to "only draw totally complete cases".
• Provide a mechanism for specifying multiple polygons in grid.polygon() (but not the way base does it with NA values). (NOTE: now wanted by Nicholas Lewin-koh as well as Deepayan)
  This is in R 1.8.1 It introduces both "id" and "id.length" arguments to distinguish between different polygons.
• Make use of Luke Tierney's work on namespaces for R packages.
  grid now has a NAMESPACE (thanks mostly to Kurt Hornik and Brain Ripley)
  It would be nice to change maintenance of grid's state information so that it occurs in C code.
• Take a closer look at Luke's external references document to see if something can be done about saving and restoring grid grobs.
  For 1.9.0, I have changed the implementation of grobs to avoid external references and make a distinction between a grob description (which gets copied like any other R object) and the structure that gets recorded when a grob description gets drawn (which can be unique) -- similar to the new implementation of viewports in R 1.9.0 This means that grobs save/load just like any other R object.
• Reimplement grid classes using the S4 class and methods system.
  Starting to see some real potential benefits from doing this: validation methods for objects (type checking of slots).
• Write a grid.delete() function to allow grobs to be interactively removed from an image.
  For R 1.9.0 there is a grid.remove() function.
• Add a "justification" slot for grid layout objects; if the layout does not entirely fill a viewport it currently centres itself -- it could left-align, right-align, ...
  Now in development version of R.
• Implement more Math and Ops group methods for unit objects (e.g., sin(), cos(), exponentiation [^], ...). Frank Harrell would like logical operators like < and >; these could at least be done for graphics which were not designed to be resized.
• Implement a "size" generic function for grobs. Similar to the existing width and height generics, but can supply an "angle" argument. NOTE that this would be used to position grobs "next" to each other, or draw lines between grobs, in directions other than left, right, up, or down. Probably best therefore if the result of this function is a (w, h) pair. NOTE that the result would have to be returned as a unit expression to be evaluated in C code (therefore need a "grobsize" unit and/or some more Math and Ops unit methods as above). The default method could calculate a size which is sqrt(2*max(width, height)^2)? (i.e., circle surrounding square of max possible width/height?)
  In the development version of R (to become 2.3.0) there are now grobX() and grobY() functions, which accept a theta argument and return the a location on the boundary of an object at angle theta. This document describes the use of these functions, in conjunction with new X-spline and curve primitives, to draw node-and-edge graphs and flow diagrams in R.
• Expand the interface for dealing with viewports: allow a viewport "vector" and/or a viewport "tree" to be pushed/popped; allow viewports to be pushed by name; allow units to have a "vp" slot specified (like grobs currently have).
  The R-grid branch has a viewport "tree" rather than a viewport "stack", viewports have a "name" slot and there are new upViewport(), downViewport(), and seekViewport() functions for navigating the tree. There are also vpStack(), vpList(), and vpTree() functions for creating descriptions of multiple viewports (and their relationships).
• Allow grid.pack() to accept multiple grobs to pack and have a default "direction" to pack them in (e.g., "left", "right", "up", "down", 45 [meaning at an angle of 45 degrees]?)
• Implement an "arrows" primitive. Allow different head styles and specification of head length and width in any unit.
  In R 1.8.0
• Modify the circle() primitive so that use can choose how to resolve ambiguous radius (e.g., radius=unit(.5, "npc")). At the moment this is done as "minimum" of npc-width and npc-height. Could allow "max", "width", "height"(, "average"?) as well.
• Implement an "ellipse" and/or "arc" primitive.
• Add some more control to grid.xaxis and grid.yaxis to allow, for example, user control of tick sizes and direction.
• Patrick Conolly suggested creating a "grid.options" or somesuch to allow global control of things like the default.units settings.
• Investigate allowing angles to be specified using a unit object (suggestion by Frank Harrell).

Grid Bugs

• The transformations in unit.c do not take into account cex gpar settings.

  grid.rect(y=.66,
            height=unit(1, "grobheight",
                        grid.text("Hi There", y=.66, gp=gpar(cex=2))))
  grid.rect(y=.33,
            height=unit(1, "grobheight",
                        grid.text("Hi There", y=.33, gp=gpar(fontsize=24))))
  

  Fixed in development version.
• (From Damon Wischik)
  [On Windows ...] gpar(col=NULL) doesn't behave as I expect it to.

  library(grid)
  grid.newpage()
  grid.circle(gp=gpar(fill="yellow",col=NULL))
  # Draws a yellow circle with no border, as it should.
  # But if you resize the graphics window,
  # the circle acquires a black border.