| |
|
| java.lang.Object
 java.awt.GraphicsDevice
| GraphicsDevice | | abstract public class GraphicsDevice (Code) | | The GraphicsDevice class describes the graphics devices
that might be available in a particular graphics environment. These
include screen and printer devices. Note that there can be many screens
and many printers in an instance of
GraphicsEnvironment . Each
graphics device has one or more
GraphicsConfiguration objects
associated with it. These objects specify the different configurations
in which the GraphicsDevice can be used.
In a multi-screen environment, the GraphicsConfiguration
objects can be used to render components on multiple screens. The
following code sample demonstrates how to create a JFrame
object for each GraphicsConfiguration on each screen
device in the GraphicsEnvironment:
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();
}
}
For more information on full-screen exclusive mode API, see the
Full-Screen Exclusive Mode API Tutorial.
See Also: GraphicsEnvironment
See Also: GraphicsConfiguration
version:
1.47, 05/05/07 |
| Constructor Summary | |
| protected | GraphicsDevice()
This is an abstract class that cannot be instantiated directly. |
| TYPE_IMAGE_BUFFER | | final public static int TYPE_IMAGE_BUFFER(Code) | | Device is an image buffer. This buffer can reside in device
or system memory but it is not physically viewable by the user.
|
| TYPE_PRINTER | | final public static int TYPE_PRINTER(Code) | | Device is a printer.
|
| TYPE_RASTER_SCREEN | | final public static int TYPE_RASTER_SCREEN(Code) | | Device is a raster screen.
|
| getAvailableAcceleratedMemory | | public int getAvailableAcceleratedMemory()(Code) | | 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
ImageCapabilities object
associated with a VolatileImage that can be used to determine
whether a particular VolatileImage has been created in accelerated
memory.
number of bytes available in accelerated memory.A negative return value indicates that the amount of accelerated memoryon this GraphicsDevice is indeterminate.
See Also: java.awt.image.VolatileImage.flush
See Also: ImageCapabilities.isAccelerated
since:
1.4 |
| getConfigurations | | abstract public GraphicsConfiguration[] getConfigurations()(Code) | | Returns all of the GraphicsConfiguration
objects associated with this GraphicsDevice.
an array of GraphicsConfigurationobjects that are associated with this GraphicsDevice. |
| getDefaultConfiguration | | abstract public GraphicsConfiguration getDefaultConfiguration()(Code) | | Returns the default GraphicsConfiguration
associated with this GraphicsDevice.
the default GraphicsConfigurationof this GraphicsDevice. |
| getDisplayModes | | public DisplayMode[] getDisplayModes()(Code) | | Returns all display modes available for this
GraphicsDevice.
The returned display modes are allowed to have a refresh rate
DisplayMode.REFRESH_RATE_UNKNOWN if it is indeterminate.
Likewise, the returned display modes are allowed to have a bit depth
DisplayMode.BIT_DEPTH_MULTI if it is indeterminate or if multiple
bit depths are supported.
all of the display modes available for this graphics device.
since:
1.4 |
| getFullScreenWindow | | public Window getFullScreenWindow()(Code) | | Returns the Window object representing the
full-screen window if the device is in full-screen mode.
the full-screen window, or null if the device isnot in full-screen mode.
See Also: GraphicsDevice.setFullScreenWindow(Window)
since:
1.4 |
| getIDstring | | abstract public String getIDstring()(Code) | | 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
System.getProperty(String) getProperty method of the
System class with "java.vendor".
a String that is the identificationof this GraphicsDevice. |
| isFullScreenSupported | | public boolean isFullScreenSupported()(Code) | | 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.
whether full-screen exclusive mode is available forthis graphics device
See Also: java.awt.AWTPermission
since:
1.4 |
| setFullScreenWindow | | public void setFullScreenWindow(Window w)(Code) | | 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.
Parameters:
w - a window to use as the full-screen window; nullif returning to windowed mode. Some platforms expect thefullscreen window to be a top-level component (i.e., a Frame);therefore it is preferable to use a Frame here rather than aWindow.
See Also: GraphicsDevice.isFullScreenSupported
See Also: GraphicsDevice.getFullScreenWindow
See Also: GraphicsDevice.setDisplayMode
See Also: Component.enableInputMethods
See Also: Component.setVisible
since:
1.4 |
|
|
|