Back to index...

	/*
	* Copyright (c) 2000, 2011, 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(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

	}

Back to index...