dev.xxx              package:grDevices              R Documentation

_C_o_n_t_r_o_l _M_u_l_t_i_p_l_e _D_e_v_i_c_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     These functions provide control over multiple graphics devices.

_U_s_a_g_e:

     dev.cur()
     dev.list()
     dev.next(which = dev.cur())
     dev.prev(which = dev.cur())
     dev.off(which = dev.cur())
     dev.set(which = dev.next())
     dev.new(...)
     graphics.off()

_A_r_g_u_m_e_n_t_s:

   which: An integer specifying a device number.

     ...: arguments to be passed to the device selected.

_D_e_t_a_i_l_s:

     Only one device is the 'active' device: this is the device in
     which all graphics operations occur.  There is a '"null device"'
     which is always open but is really a placeholder: any attempt to
     use it will open a new device specified by 'getOption("device")').

     Devices are associated with a name (e.g., '"X11"' or
     '"postscript"') and a number in the range 1 to 63; the '"null
     device"' is always device 1.  Once a device has been opened the
     null device is not considered as a possible active device. There
     is a list of open devices, and this is considered as a circular
     list not including the null device.  'dev.next' and 'dev.prev'
     select the next open device in the appropriate direction, unless
     no device is open.

     'dev.off' shuts down the specified (by default the current)
     device.  If the current device is shut down and any other devices
     are open, the next open device is made current.  It is an error to
     attempt to shut down device 1.  'graphics.off()' shuts down all
     open graphics devices.  Normal termination of a session runs the
     internal equivalent of 'graphics.off()'.

     'dev.set' makes the specified device the active device.  If there
     is no device with that number, it is equivalent to 'dev.next'. If
     'which = 1' it opens a new device and selects that.

     'dev.new' opens a new device.  Normally R will open a new device
     automatically when needed, but this enables you to open further
     devices in a platform-independent way.  (For which device is used
     see 'getOption("device")'.)  Note that care is needed with
     file-based devices such as 'pdf' and 'postscript' and in that case
     file names such as 'Rplots.pdf', 'Rplots1.pdf', ...,
     'Rplots999.pdf' are tried in turn.  Only named arguments are
     passed to the device, and then only if they match the argument
     list of the device.  Even so, case is needed with the
     interpretation of e.g. 'width', and for the standard bitmap
     devices 'units="in", res=72' is forced if neither is supplied but
     both 'width' and 'height' are.

_V_a_l_u_e:

     'dev.cur' returns a length-one named integer vector giving the
     number and name of the active device, or 1, the null device, if
     none is active.

     'dev.list' returns the numbers of all open devices, except device
     1, the null device.  This is a numeric vector with a 'names'
     attribute giving the device names, or 'NULL' is there is no open
     device.

     'dev.next' and 'dev.prev' return the number and name of the next /
     previous device in the list of devices.  This will be the null
     device if and only if there are no open devices.

     'dev.off' returns the number and name of the new active device
     (after the specified device has been shut down).

     'dev.set' returns the number and name of the new active device.

     'dev.new' returns the return value of the device opened, usually
     invisible 'NULL'.

_S_e_e _A_l_s_o:

     'Devices', such as 'postscript', etc.

     'layout' and its links for setting up plotting regions on the
     current device.

_E_x_a_m_p_l_e_s:

     ## Not run: 
     ## Unix-specific example
     x11()
     plot(1:10)
     x11()
     plot(rnorm(10))
     dev.set(dev.prev())
     abline(0,1)# through the 1:10 points
     dev.set(dev.next())
     abline(h=0, col="gray")# for the residual plot
     dev.set(dev.prev())
     dev.off(); dev.off()#- close the two X devices
     ## End(Not run)