/*
 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

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(e);
 }
 }

 // 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

}