001: /*
002: * Copyright 2000-2006 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: package java.awt;
027:
028: /**
029: * Capabilities and properties of buffers.
030: *
031: * @see java.awt.image.BufferStrategy#getCapabilities()
032: * @see GraphicsConfiguration#getBufferCapabilities
033: * @author Michael Martak
034: * @since 1.4
035: */
036: public class BufferCapabilities implements Cloneable {
037:
038: private ImageCapabilities frontCaps;
039: private ImageCapabilities backCaps;
040: private FlipContents flipContents;
041:
042: /**
043: * Creates a new object for specifying buffering capabilities
044: * @param frontCaps the capabilities of the front buffer; cannot be
045: * <code>null</code>
046: * @param backCaps the capabilities of the back and intermediate buffers;
047: * cannot be <code>null</code>
048: * @param flipContents the contents of the back buffer after page-flipping,
049: * <code>null</code> if page flipping is not used (implies blitting)
050: * @exception IllegalArgumentException if frontCaps or backCaps are
051: * <code>null</code>
052: */
053: public BufferCapabilities(ImageCapabilities frontCaps,
054: ImageCapabilities backCaps, FlipContents flipContents) {
055: if (frontCaps == null || backCaps == null) {
056: throw new IllegalArgumentException(
057: "Image capabilities specified cannot be null");
058: }
059: this .frontCaps = frontCaps;
060: this .backCaps = backCaps;
061: this .flipContents = flipContents;
062: }
063:
064: /**
065: * @return the image capabilities of the front (displayed) buffer
066: */
067: public ImageCapabilities getFrontBufferCapabilities() {
068: return frontCaps;
069: }
070:
071: /**
072: * @return the image capabilities of all back buffers (intermediate buffers
073: * are considered back buffers)
074: */
075: public ImageCapabilities getBackBufferCapabilities() {
076: return backCaps;
077: }
078:
079: /**
080: * @return whether or not the buffer strategy uses page flipping; a set of
081: * buffers that uses page flipping
082: * can swap the contents internally between the front buffer and one or
083: * more back buffers by switching the video pointer (or by copying memory
084: * internally). A non-flipping set of
085: * buffers uses blitting to copy the contents from one buffer to
086: * another; when this is the case, <code>getFlipContents</code> returns
087: * <code>null</code>
088: */
089: public boolean isPageFlipping() {
090: return (getFlipContents() != null);
091: }
092:
093: /**
094: * @return the resulting contents of the back buffer after page-flipping.
095: * This value is <code>null</code> when the <code>isPageFlipping</code>
096: * returns <code>false</code>, implying blitting. It can be one of
097: * <code>FlipContents.UNDEFINED</code>
098: * (the assumed default), <code>FlipContents.BACKGROUND</code>,
099: * <code>FlipContents.PRIOR</code>, or
100: * <code>FlipContents.COPIED</code>.
101: * @see #isPageFlipping
102: * @see FlipContents#UNDEFINED
103: * @see FlipContents#BACKGROUND
104: * @see FlipContents#PRIOR
105: * @see FlipContents#COPIED
106: */
107: public FlipContents getFlipContents() {
108: return flipContents;
109: }
110:
111: /**
112: * @return whether page flipping is only available in full-screen mode. If this
113: * is <code>true</code>, full-screen exclusive mode is required for
114: * page-flipping.
115: * @see #isPageFlipping
116: * @see GraphicsDevice#setFullScreenWindow
117: */
118: public boolean isFullScreenRequired() {
119: return false;
120: }
121:
122: /**
123: * @return whether or not
124: * page flipping can be performed using more than two buffers (one or more
125: * intermediate buffers as well as the front and back buffer).
126: * @see #isPageFlipping
127: */
128: public boolean isMultiBufferAvailable() {
129: return false;
130: }
131:
132: /**
133: * @return a copy of this BufferCapabilities object.
134: */
135: public Object clone() {
136: try {
137: return super .clone();
138: } catch (CloneNotSupportedException e) {
139: // Since we implement Cloneable, this should never happen
140: throw new InternalError();
141: }
142: }
143:
144: // Inner class FlipContents
145: /**
146: * A type-safe enumeration of the possible back buffer contents after
147: * page-flipping
148: * @since 1.4
149: */
150: public static final class FlipContents extends AttributeValue {
151:
152: private static int I_UNDEFINED = 0;
153: private static int I_BACKGROUND = 1;
154: private static int I_PRIOR = 2;
155: private static int I_COPIED = 3;
156:
157: private static final String NAMES[] = { "undefined",
158: "background", "prior", "copied" };
159:
160: /**
161: * When flip contents are <code>UNDEFINED</code>, the
162: * contents of the back buffer are undefined after flipping.
163: * @see #isPageFlipping
164: * @see #getFlipContents
165: * @see #BACKGROUND
166: * @see #PRIOR
167: * @see #COPIED
168: */
169: public static final FlipContents UNDEFINED = new FlipContents(
170: I_UNDEFINED);
171:
172: /**
173: * When flip contents are <code>BACKGROUND</code>, the
174: * contents of the back buffer are cleared with the background color after
175: * flipping.
176: * @see #isPageFlipping
177: * @see #getFlipContents
178: * @see #UNDEFINED
179: * @see #PRIOR
180: * @see #COPIED
181: */
182: public static final FlipContents BACKGROUND = new FlipContents(
183: I_BACKGROUND);
184:
185: /**
186: * When flip contents are <code>PRIOR</code>, the
187: * contents of the back buffer are the prior contents of the front buffer
188: * (a true page flip).
189: * @see #isPageFlipping
190: * @see #getFlipContents
191: * @see #UNDEFINED
192: * @see #BACKGROUND
193: * @see #COPIED
194: */
195: public static final FlipContents PRIOR = new FlipContents(
196: I_PRIOR);
197:
198: /**
199: * When flip contents are <code>COPIED</code>, the
200: * contents of the back buffer are copied to the front buffer when
201: * flipping.
202: * @see #isPageFlipping
203: * @see #getFlipContents
204: * @see #UNDEFINED
205: * @see #BACKGROUND
206: * @see #PRIOR
207: */
208: public static final FlipContents COPIED = new FlipContents(
209: I_COPIED);
210:
211: private FlipContents(int type) {
212: super (type, NAMES);
213: }
214:
215: } // Inner class FlipContents
216:
217: }
| 