/* * Copyright (c) 2000, 2006, 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; /** * Capabilities and properties of buffers. * * @see java.awt.image.BufferStrategy#getCapabilities() * @see GraphicsConfiguration#getBufferCapabilities * @author Michael Martak * @since 1.4 */public class BufferCapabilities implements Cloneable {     private ImageCapabilities frontCaps;    private ImageCapabilities backCaps;    private FlipContents flipContents;     /**     * Creates a new object for specifying buffering capabilities     * @param frontCaps the capabilities of the front buffer; cannot be     * <code>null</code>     * @param backCaps the capabilities of the back and intermediate buffers;     * cannot be <code>null</code>     * @param flipContents the contents of the back buffer after page-flipping,     * <code>null</code> if page flipping is not used (implies blitting)     * @exception IllegalArgumentException if frontCaps or backCaps are     * <code>null</code>     */    public BufferCapabilities(ImageCapabilities frontCaps,        ImageCapabilities backCaps, FlipContents flipContents) {        if (frontCaps == null || backCaps == null) {            throw new IllegalArgumentException(                "Image capabilities specified cannot be null");        }        this.frontCaps = frontCaps;        this.backCaps = backCaps;        this.flipContents = flipContents;    }     /**     * @return the image capabilities of the front (displayed) buffer     */    public ImageCapabilities getFrontBufferCapabilities() {        return frontCaps;    }     /**     * @return the image capabilities of all back buffers (intermediate buffers     * are considered back buffers)     */    public ImageCapabilities getBackBufferCapabilities() {        return backCaps;    }     /**     * @return whether or not the buffer strategy uses page flipping; a set of     * buffers that uses page flipping     * can swap the contents internally between the front buffer and one or     * more back buffers by switching the video pointer (or by copying memory     * internally).  A non-flipping set of     * buffers uses blitting to copy the contents from one buffer to     * another; when this is the case, <code>getFlipContents</code> returns     * <code>null</code>     */    public boolean isPageFlipping() {        return (getFlipContents() != null);    }     /**     * @return the resulting contents of the back buffer after page-flipping.     * This value is <code>null</code> when the <code>isPageFlipping</code>     * returns <code>false</code>, implying blitting.  It can be one of     * <code>FlipContents.UNDEFINED</code>     * (the assumed default), <code>FlipContents.BACKGROUND</code>,     * <code>FlipContents.PRIOR</code>, or     * <code>FlipContents.COPIED</code>.     * @see #isPageFlipping     * @see FlipContents#UNDEFINED     * @see FlipContents#BACKGROUND     * @see FlipContents#PRIOR     * @see FlipContents#COPIED     */    public FlipContents getFlipContents() {        return flipContents;    }     /**     * @return whether page flipping is only available in full-screen mode.  If this     * is <code>true</code>, full-screen exclusive mode is required for     * page-flipping.     * @see #isPageFlipping     * @see GraphicsDevice#setFullScreenWindow     */    public boolean isFullScreenRequired() {        return false;    }     /**     * @return whether or not     * page flipping can be performed using more than two buffers (one or more     * intermediate buffers as well as the front and back buffer).     * @see #isPageFlipping     */    public boolean isMultiBufferAvailable() {        return false;    }     /**     * @return a copy of this BufferCapabilities object.     */    public Object clone() {        try {            return super.clone();        } catch (CloneNotSupportedException e) {            // Since we implement Cloneable, this should never happen            throw new InternalError();        }    }     // Inner class FlipContents    /**     * A type-safe enumeration of the possible back buffer contents after     * page-flipping     * @since 1.4     */    public static final class FlipContents extends AttributeValue {         private static int I_UNDEFINED = 0;        private static int I_BACKGROUND = 1;        private static int I_PRIOR = 2;        private static int I_COPIED = 3;         private static final String NAMES[] =            { "undefined", "background", "prior", "copied" };         /**         * When flip contents are <code>UNDEFINED</code>, the         * contents of the back buffer are undefined after flipping.         * @see #isPageFlipping         * @see #getFlipContents         * @see #BACKGROUND         * @see #PRIOR         * @see #COPIED         */        public static final FlipContents UNDEFINED =            new FlipContents(I_UNDEFINED);         /**         * When flip contents are <code>BACKGROUND</code>, the         * contents of the back buffer are cleared with the background color after         * flipping.         * @see #isPageFlipping         * @see #getFlipContents         * @see #UNDEFINED         * @see #PRIOR         * @see #COPIED         */        public static final FlipContents BACKGROUND =            new FlipContents(I_BACKGROUND);         /**         * When flip contents are <code>PRIOR</code>, the         * contents of the back buffer are the prior contents of the front buffer         * (a true page flip).         * @see #isPageFlipping         * @see #getFlipContents         * @see #UNDEFINED         * @see #BACKGROUND         * @see #COPIED         */        public static final FlipContents PRIOR =            new FlipContents(I_PRIOR);         /**         * When flip contents are <code>COPIED</code>, the         * contents of the back buffer are copied to the front buffer when         * flipping.         * @see #isPageFlipping         * @see #getFlipContents         * @see #UNDEFINED         * @see #BACKGROUND         * @see #PRIOR         */        public static final FlipContents COPIED =            new FlipContents(I_COPIED);         private FlipContents(int type) {            super(type, NAMES);        }     } // Inner class FlipContents }