File	Doc	Category	Size	Date	Package
GraphicsDevice.java	API Doc	Java SE 6 API	16419	Tue Jun 10 00:25:16 BST 2008	java.awt

GraphicsDevice

• java.lang.Object

GraphicsEnvironment ge = GraphicsEnvironment.
getLocalGraphicsEnvironment();
GraphicsDevice[] gs = ge.getScreenDevices();
for (int j = 0; j < gs.length; j++) {
GraphicsDevice gd = gs[j];
GraphicsConfiguration[] gc =
gd.getConfigurations();
for (int i=0; i < gc.length; i++) {
JFrame f = new
JFrame(gs[j].getDefaultConfiguration());
Canvas c = new Canvas(gc[i]);
Rectangle gcBounds = gc[i].getBounds();
int xoffs = gcBounds.x;
int yoffs = gcBounds.y;
f.getContentPane().add(c);
f.setLocation((i*50)+xoffs, (i*60)+yoffs);
f.show();
}
}

Fields Summary
private Window	fullScreenWindow
private AppContext	fullScreenAppContext
private final Object	fsAppContextLock
private Rectangle	windowedModeBounds
public static final int	TYPE_RASTER_SCREEN Device is a raster screen.
public static final int	TYPE_PRINTER Device is a printer.
public static final int	TYPE_IMAGE_BUFFER Device is an image buffer. This buffer can reside in device or system memory but it is not physically viewable by the user.

Constructors Summary
protected GraphicsDevice() This is an abstract class that cannot be instantiated directly. Instances must be obtained from a suitable factory or query method. see GraphicsEnvironment#getScreenDevices see GraphicsEnvironment#getDefaultScreenDevice see GraphicsConfiguration#getDevice

Methods Summary
public int	getAvailableAcceleratedMemory() This method returns the number of bytes available in accelerated memory on this device. Some images are created or cached in accelerated memory on a first-come, first-served basis. On some operating systems, this memory is a finite resource. Calling this method and scheduling the creation and flushing of images carefully may enable applications to make the most efficient use of that finite resource. Note that the number returned is a snapshot of how much memory is available; some images may still have problems being allocated into that memory. For example, depending on operating system, driver, memory configuration, and thread situations, the full extent of the size reported may not be available for a given image. There are further inquiry methods on the {@link ImageCapabilities} object associated with a VolatileImage that can be used to determine whether a particular VolatileImage has been created in accelerated memory. return number of bytes available in accelerated memory. A negative return value indicates that the amount of accelerated memory on this GraphicsDevice is indeterminate. see java.awt.image.VolatileImage#flush see ImageCapabilities#isAccelerated since 1.4 return -1;
public java.awt.GraphicsConfiguration	getBestConfiguration(java.awt.GraphicsConfigTemplate gct) Returns the "best" configuration possible that passes the criteria defined in the {@link GraphicsConfigTemplate}. param gct the GraphicsConfigTemplate object used to obtain a valid GraphicsConfiguration return a GraphicsConfiguration that passes the criteria defined in the specified GraphicsConfigTemplate. see GraphicsConfigTemplate GraphicsConfiguration[] configs = getConfigurations(); return gct.getBestConfiguration(configs);
public abstract java.awt.GraphicsConfiguration[]	getConfigurations() Returns all of the GraphicsConfiguration objects associated with this GraphicsDevice. return an array of GraphicsConfiguration objects that are associated with this GraphicsDevice.
public abstract java.awt.GraphicsConfiguration	getDefaultConfiguration() Returns the default GraphicsConfiguration associated with this GraphicsDevice. return the default GraphicsConfiguration of this GraphicsDevice.
public java.awt.DisplayMode	getDisplayMode() Returns the current display mode of this GraphicsDevice. The returned display mode is allowed to have a refresh rate {@link DisplayMode#REFRESH_RATE_UNKNOWN} if it is indeterminate. Likewise, the returned display mode is allowed to have a bit depth {@link DisplayMode#BIT_DEPTH_MULTI} if it is indeterminate or if multiple bit depths are supported. return the current display mode of this graphics device. see #setDisplayMode(DisplayMode) since 1.4 GraphicsConfiguration gc = getDefaultConfiguration(); Rectangle r = gc.getBounds(); ColorModel cm = gc.getColorModel(); return new DisplayMode(r.width, r.height, cm.getPixelSize(), 0);
public java.awt.DisplayMode[]	getDisplayModes() Returns all display modes available for this GraphicsDevice. The returned display modes are allowed to have a refresh rate {@link DisplayMode#REFRESH_RATE_UNKNOWN} if it is indeterminate. Likewise, the returned display modes are allowed to have a bit depth {@link DisplayMode#BIT_DEPTH_MULTI} if it is indeterminate or if multiple bit depths are supported. return all of the display modes available for this graphics device. since 1.4 return new DisplayMode[] { getDisplayMode() };
public java.awt.Window	getFullScreenWindow() Returns the Window object representing the full-screen window if the device is in full-screen mode. return the full-screen window, or null if the device is not in full-screen mode. see #setFullScreenWindow(Window) since 1.4 Window returnWindow = null; synchronized (fsAppContextLock) { // Only return a handle to the current fs window if we are in the // same AppContext that set the fs window if (fullScreenAppContext == AppContext.getAppContext()) { returnWindow = fullScreenWindow; } } return returnWindow;
public abstract java.lang.String	getIDstring() Returns the identification string associated with this GraphicsDevice. A particular program might use more than one GraphicsDevice in a GraphicsEnvironment. This method returns a String identifying a particular GraphicsDevice in the local GraphicsEnvironment. Although there is no public method to set this String, a programmer can use the String for debugging purposes. Vendors of the JavaTM Runtime Environment can format the return value of the String. To determine how to interpret the value of the String, contact the vendor of your Java Runtime. To find out who the vendor is, from your program, call the {@link System#getProperty(String) getProperty} method of the System class with "java.vendor". return a String that is the identification of this GraphicsDevice.
public abstract int	getType() Returns the type of this GraphicsDevice. return the type of this GraphicsDevice, which can either be TYPE_RASTER_SCREEN, TYPE_PRINTER or TYPE_IMAGE_BUFFER. see #TYPE_RASTER_SCREEN see #TYPE_PRINTER see #TYPE_IMAGE_BUFFER
public boolean	isDisplayChangeSupported() Returns true if this GraphicsDevice supports low-level display changes. On some platforms low-level display changes may only be allowed in full-screen exclusive mode (i.e., if {@link #isFullScreenSupported()} returns {@code true} and the application has already entered full-screen mode using {@link #setFullScreenWindow}). return whether low-level display changes are supported for this graphics device. see #isFullScreenSupported see #setDisplayMode see #setFullScreenWindow since 1.4 return false;
public boolean	isFullScreenSupported() Returns true if this GraphicsDevice supports full-screen exclusive mode. If a SecurityManager is installed, its checkPermission method will be called with AWTPermission("fullScreenExclusive"). isFullScreenSupported returns true only if that permission is granted. return whether full-screen exclusive mode is available for this graphics device see java.awt.AWTPermission since 1.4 return false;
public void	setDisplayMode(java.awt.DisplayMode dm) Sets the display mode of this graphics device. This is only allowed if {@link #isDisplayChangeSupported()} returns {@code true} and may require first entering full-screen exclusive mode using {@link #setFullScreenWindow} providing that full-screen exclusive mode is supported (i.e., {@link #isFullScreenSupported()} returns {@code true}). The display mode must be one of the display modes returned by {@link #getDisplayModes()}, with one exception: passing a display mode with {@link DisplayMode#REFRESH_RATE_UNKNOWN} refresh rate will result in selecting a display mode from the list of available display modes with matching width, height and bit depth. However, passing a display mode with {@link DisplayMode#BIT_DEPTH_MULTI} for bit depth is only allowed if such mode exists in the list returned by {@link #getDisplayModes()}. Example code: Frame frame; DisplayMode newDisplayMode; GraphicsDevice gd; // create a Frame, select desired DisplayMode from the list of modes // returned by gd.getDisplayModes() ... if (gd.isFullScreenSupported()) { gd.setFullScreenWindow(frame); } else { // proceed in non-full-screen mode frame.setSize(...); frame.setLocation(...); frame.setVisible(true); } if (gd.isDisplayChangeSupported()) { gd.setDisplayMode(newDisplayMode); } param dm The new display mode of this graphics device. exception IllegalArgumentException if the DisplayMode supplied is null, or is not available in the array returned by getDisplayModes exception UnsupportedOperationException if isDisplayChangeSupported returns false see #getDisplayMode see #getDisplayModes see #isDisplayChangeSupported since 1.4 throw new UnsupportedOperationException("Cannot change display mode");
public void	setFullScreenWindow(java.awt.Window w) Enter full-screen mode, or return to windowed mode. The entered full-screen mode may be either exclusive or simulated. Exclusive mode is only available if isFullScreenSupported returns true. Exclusive mode implies: Windows cannot overlap the full-screen window. All other application windows will always appear beneath the full-screen window in the Z-order. There can be only one full-screen window on a device at any time, so calling this method while there is an existing full-screen Window will cause the existing full-screen window to return to windowed mode. Input method windows are disabled. It is advisable to call Component.enableInputMethods(false) to make a component a non-client of the input method framework. Simulated full-screen mode resizes the window to the size of the screen and positions it at (0,0). When entering full-screen mode, if the window to be used as the full-screen window is not visible, this method will make it visible. It will remain visible when returning to windowed mode. When returning to windowed mode from an exclusive full-screen window, any display changes made by calling setDisplayMode are automatically restored to their original state. param w a window to use as the full-screen window; null if returning to windowed mode. Some platforms expect the fullscreen window to be a top-level component (i.e., a Frame); therefore it is preferable to use a Frame here rather than a Window. see #isFullScreenSupported see #getFullScreenWindow see #setDisplayMode see Component#enableInputMethods see Component#setVisible since 1.4 if (fullScreenWindow != null && windowedModeBounds != null) { fullScreenWindow.setBounds(windowedModeBounds); } // Set the full screen window synchronized (fsAppContextLock) { // Associate fullscreen window with current AppContext if (w == null) { fullScreenAppContext = null; } else { fullScreenAppContext = AppContext.getAppContext(); } fullScreenWindow = w; } if (fullScreenWindow != null) { windowedModeBounds = fullScreenWindow.getBounds(); // Note that we use the graphics configuration of the device, // not the window's, because we're setting the fs window for // this device. Rectangle screenBounds = getDefaultConfiguration().getBounds(); fullScreenWindow.setBounds(screenBounds.x, screenBounds.y, screenBounds.width, screenBounds.height); fullScreenWindow.setVisible(true); fullScreenWindow.toFront(); }