|
Java example source code file (GraphicsDevice.java)
The GraphicsDevice.java Java example source code/* * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.awt; import java.awt.image.ColorModel; import sun.awt.AWTAccessor; import sun.awt.AppContext; import sun.awt.SunToolkit; /** * The <code>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 {@link GraphicsEnvironment}. Each * graphics device has one or more {@link GraphicsConfiguration} objects * associated with it. These objects specify the different configurations * in which the <code>GraphicsDevice can be used. * <p> * In a multi-screen environment, the <code>GraphicsConfiguration * objects can be used to render components on multiple screens. The * following code sample demonstrates how to create a <code>JFrame * object for each <code>GraphicsConfiguration on each screen * device in the <code>GraphicsEnvironment: * <pre>{@code * 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(); * } * } * }</pre> * <p> * For more information on full-screen exclusive mode API, see the * <a href="http://docs.oracle.com/javase/tutorial/extra/fullscreen/index.html"> * Full-Screen Exclusive Mode API Tutorial</a>. * * @see GraphicsEnvironment * @see GraphicsConfiguration */ public abstract class GraphicsDevice { private Window fullScreenWindow; private AppContext fullScreenAppContext; // tracks which AppContext // created the FS window // this lock is used for making synchronous changes to the AppContext's // current full screen window private final Object fsAppContextLock = new Object(); private Rectangle windowedModeBounds; /** * 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 */ protected GraphicsDevice() { } /** * Device is a raster screen. */ public final static int TYPE_RASTER_SCREEN = 0; /** * Device is a printer. */ public final static int TYPE_PRINTER = 1; /** * Device is an image buffer. This buffer can reside in device * or system memory but it is not physically viewable by the user. */ public final static int TYPE_IMAGE_BUFFER = 2; /** * Kinds of translucency supported by the underlying system. * * @see #isWindowTranslucencySupported * * @since 1.7 */ public static enum WindowTranslucency { /** * Represents support in the underlying system for windows each pixel * of which is guaranteed to be either completely opaque, with * an alpha value of 1.0, or completely transparent, with an alpha * value of 0.0. */ PERPIXEL_TRANSPARENT, /** * Represents support in the underlying system for windows all of * the pixels of which have the same alpha value between or including * 0.0 and 1.0. */ TRANSLUCENT, /** * Represents support in the underlying system for windows that * contain or might contain pixels with arbitrary alpha values * between and including 0.0 and 1.0. */ PERPIXEL_TRANSLUCENT; } /** * Returns the type of this <code>GraphicsDevice. * @return the type of this <code>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 abstract int getType(); /** * Returns the identification string associated with this * <code>GraphicsDevice. * <p> * A particular program might use more than one * <code>GraphicsDevice in a
*
* @param dm The new display mode of this graphics device.
* @exception IllegalArgumentException if the <code>DisplayMode
* supplied is <code>null, or is not available in the array returned
* by <code>getDisplayModes
* @exception UnsupportedOperationException if
* <code>isDisplayChangeSupported returns false
* @see #getDisplayMode
* @see #getDisplayModes
* @see #isDisplayChangeSupported
* @since 1.4
*/
public void setDisplayMode(DisplayMode dm) {
throw new UnsupportedOperationException("Cannot change display mode");
}
/**
* Returns the current display mode of this
* <code>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
*/
public DisplayMode getDisplayMode() {
GraphicsConfiguration gc = getDefaultConfiguration();
Rectangle r = gc.getBounds();
ColorModel cm = gc.getColorModel();
return new DisplayMode(r.width, r.height, cm.getPixelSize(), 0);
}
/**
* Returns all display modes available for this
* <code>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
*/
public DisplayMode[] getDisplayModes() {
return new DisplayMode[] { getDisplayMode() };
}
/**
* 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.
* <br>
* 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
*/
public int getAvailableAcceleratedMemory() {
return -1;
}
/**
* Returns whether the given level of translucency is supported by
* this graphics device.
*
* @param translucencyKind a kind of translucency support
* @return whether the given translucency kind is supported
*
* @since 1.7
*/
public boolean isWindowTranslucencySupported(WindowTranslucency translucencyKind) {
switch (translucencyKind) {
case PERPIXEL_TRANSPARENT:
return isWindowShapingSupported();
case TRANSLUCENT:
return isWindowOpacitySupported();
case PERPIXEL_TRANSLUCENT:
return isWindowPerpixelTranslucencySupported();
}
return false;
}
/**
* Returns whether the windowing system supports changing the shape
* of top-level windows.
* Note that this method may sometimes return true, but the native
* windowing system may still not support the concept of
* shaping (due to the bugs in the windowing system).
*/
static boolean isWindowShapingSupported() {
Toolkit curToolkit = Toolkit.getDefaultToolkit();
if (!(curToolkit instanceof SunToolkit)) {
return false;
}
return ((SunToolkit)curToolkit).isWindowShapingSupported();
}
/**
* Returns whether the windowing system supports changing the opacity
* value of top-level windows.
* Note that this method may sometimes return true, but the native
* windowing system may still not support the concept of
* translucency (due to the bugs in the windowing system).
*/
static boolean isWindowOpacitySupported() {
Toolkit curToolkit = Toolkit.getDefaultToolkit();
if (!(curToolkit instanceof SunToolkit)) {
return false;
}
return ((SunToolkit)curToolkit).isWindowOpacitySupported();
}
boolean isWindowPerpixelTranslucencySupported() {
/*
* Per-pixel alpha is supported if all the conditions are TRUE:
* 1. The toolkit is a sort of SunToolkit
* 2. The toolkit supports translucency in general
* (isWindowTranslucencySupported())
* 3. There's at least one translucency-capable
* GraphicsConfiguration
*/
Toolkit curToolkit = Toolkit.getDefaultToolkit();
if (!(curToolkit instanceof SunToolkit)) {
return false;
}
if (!((SunToolkit)curToolkit).isWindowTranslucencySupported()) {
return false;
}
// TODO: cache translucency capable GC
return getTranslucencyCapableGC() != null;
}
GraphicsConfiguration getTranslucencyCapableGC() {
// If the default GC supports translucency return true.
// It is important to optimize the verification this way,
// see CR 6661196 for more details.
GraphicsConfiguration defaultGC = getDefaultConfiguration();
if (defaultGC.isTranslucencyCapable()) {
return defaultGC;
}
// ... otherwise iterate through all the GCs.
GraphicsConfiguration[] configs = getConfigurations();
for (int j = 0; j < configs.length; j++) {
if (configs[j].isTranslucencyCapable()) {
return configs[j];
}
}
return null;
}
}
Other Java examples (source code examples)Here is a short list of links related to this Java GraphicsDevice.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.