|
/*
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* -Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
* AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
* AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or intended
* for use in the design, construction, operation or maintenance of any
* nuclear facility.
*/
/**
* This test shows the different buffer capabilities for each
* GraphicsConfiguration on each GraphicsDevice.
*/
import java.awt.BorderLayout;
import java.awt.BufferCapabilities;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.GridLayout;
import java.awt.ImageCapabilities;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.BorderFactory;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* This class wraps a graphics configuration so that it can be displayed nicely
* in components.
*/
class GCWrapper {
private GraphicsConfiguration gc;
private int index;
public GCWrapper(GraphicsConfiguration gc, int index) {
this.gc = gc;
this.index = index;
}
public GraphicsConfiguration getGC() {
return gc;
}
public String toString() {
return gc.toString();
}
}
/**
* Main frame class.
*/
public class CapabilitiesTest extends JFrame implements ItemListener {
private JComboBox gcSelection = new JComboBox();
private JCheckBox imageAccelerated = new JCheckBox("Accelerated", false);
private JCheckBox imageTrueVolatile = new JCheckBox("Volatile", false);
private JCheckBox flipping = new JCheckBox("Flipping", false);
private JLabel flippingMethod = new JLabel("");
private JCheckBox fullScreen = new JCheckBox("Full Screen Only", false);
private JCheckBox multiBuffer = new JCheckBox("Multi-Buffering", false);
private JCheckBox fbAccelerated = new JCheckBox("Accelerated", false);
private JCheckBox fbTrueVolatile = new JCheckBox("Volatile", false);
private JCheckBox bbAccelerated = new JCheckBox("Accelerated", false);
private JCheckBox bbTrueVolatile = new JCheckBox("Volatile", false);
public CapabilitiesTest(GraphicsDevice dev) {
super(dev.getDefaultConfiguration());
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent ev) {
System.exit(0);
}
});
initComponents(getContentPane());
GraphicsConfiguration[] gcs = dev.getConfigurations();
for (int i = 0; i < gcs.length; i++) {
gcSelection.addItem(new GCWrapper(gcs[i], i));
}
gcSelection.addItemListener(this);
gcChanged();
}
/**
* Creates and lays out components in the container. See the comments below
* for an organizational overview by panel.
*/
private void initComponents(Container c) {
// +=c=====================================================+
// ++=gcPanel==============================================+
// ++ [gcSelection] +
// ++=capsPanel============================================+
// +++=imageCapsPanel======================================+
// +++ [imageAccelerated] +
// +++ [imageTrueVolatile] +
// +++=bufferCapsPanel=====================================+
// ++++=bufferAccessCapsPanel==============================+
// +++++=flippingPanel=====================================+
// +++++ [flipping] +
// +++++=fsPanel===========================================+
// +++++ [indentPanel][fullScreen] +
// +++++=mbPanel===========================================+
// +++++ [indentPanel][multiBuffer] +
// ++++=buffersPanel=======================================+
// +++++=fbPanel===============+=bbPanel===================+
// +++++ + +
// +++++ [fbAccelerated] + [bbAccelerated] +
// +++++ + +
// +++++ [fbTrueVolatile] + [bbTrueVolatile] +
// +++++ + +
// +=======================================================+
c.setLayout(new BorderLayout());
// Graphics Config
JPanel gcPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
c.add(gcPanel, BorderLayout.NORTH);
gcSelection.setPreferredSize(new Dimension(400, 30));
gcPanel.add(gcSelection);
// Capabilities
JPanel capsPanel = new JPanel(new BorderLayout());
c.add(capsPanel, BorderLayout.CENTER);
// Image Capabilities
JPanel imageCapsPanel = new JPanel(new GridLayout(2, 1));
capsPanel.add(imageCapsPanel, BorderLayout.NORTH);
imageCapsPanel.setBorder(BorderFactory
.createTitledBorder("Image Capabilities"));
imageAccelerated.setEnabled(false);
imageCapsPanel.add(imageAccelerated);
imageTrueVolatile.setEnabled(false);
imageCapsPanel.add(imageTrueVolatile);
// Buffer Capabilities
JPanel bufferCapsPanel = new JPanel(new BorderLayout());
capsPanel.add(bufferCapsPanel, BorderLayout.CENTER);
bufferCapsPanel.setBorder(BorderFactory
.createTitledBorder("Buffer Capabilities"));
// Buffer Access
JPanel bufferAccessCapsPanel = new JPanel(new GridLayout(3, 1));
bufferAccessCapsPanel.setPreferredSize(new Dimension(300, 88));
bufferCapsPanel.add(bufferAccessCapsPanel, BorderLayout.NORTH);
// Flipping
JPanel flippingPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
bufferAccessCapsPanel.add(flippingPanel);
flippingPanel.add(flipping);
flipping.setEnabled(false);
flippingPanel.add(flippingMethod);
// Full-screen
JPanel fsPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
bufferAccessCapsPanel.add(fsPanel);
JPanel indentPanel = new JPanel();
indentPanel.setPreferredSize(new Dimension(30, 30));
fsPanel.add(indentPanel);
fsPanel.add(fullScreen);
fullScreen.setEnabled(false);
// Multi-buffering
JPanel mbPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
bufferAccessCapsPanel.add(mbPanel);
indentPanel = new JPanel();
indentPanel.setPreferredSize(new Dimension(30, 30));
mbPanel.add(indentPanel);
mbPanel.add(multiBuffer);
multiBuffer.setEnabled(false);
// Front and Back Buffer Capabilities
JPanel buffersPanel = new JPanel(new GridLayout(1, 2));
bufferCapsPanel.add(buffersPanel, BorderLayout.CENTER);
// Front Buffer
JPanel fbPanel = new JPanel(new GridLayout(2, 1));
fbPanel.setBorder(BorderFactory.createTitledBorder("Front Buffer"));
buffersPanel.add(fbPanel);
fbPanel.add(fbAccelerated);
fbAccelerated.setEnabled(false);
fbPanel.add(fbTrueVolatile);
fbTrueVolatile.setEnabled(false);
// Back Buffer
JPanel bbPanel = new JPanel(new GridLayout(2, 1));
bbPanel.setPreferredSize(new Dimension(250, 80));
bbPanel.setBorder(BorderFactory
.createTitledBorder("Back and Intermediate Buffers"));
buffersPanel.add(bbPanel);
bbPanel.add(bbAccelerated);
bbAccelerated.setEnabled(false);
bbPanel.add(bbTrueVolatile);
bbTrueVolatile.setEnabled(false);
}
public void itemStateChanged(ItemEvent ev) {
gcChanged();
}
private void gcChanged() {
GCWrapper wrap = (GCWrapper) gcSelection.getSelectedItem();
//assert wrap != null;
GraphicsConfiguration gc = wrap.getGC();
//assert gc != null;
//Image Caps
ImageCapabilities imageCaps = gc.getImageCapabilities();
imageAccelerated.setSelected(imageCaps.isAccelerated());
imageTrueVolatile.setSelected(imageCaps.isTrueVolatile());
// Buffer Caps
BufferCapabilities bufferCaps = gc.getBufferCapabilities();
flipping.setSelected(bufferCaps.isPageFlipping());
flippingMethod.setText(getFlipText(bufferCaps.getFlipContents()));
fullScreen.setSelected(bufferCaps.isFullScreenRequired());
multiBuffer.setSelected(bufferCaps.isMultiBufferAvailable());
// Front buffer caps
imageCaps = bufferCaps.getFrontBufferCapabilities();
fbAccelerated.setSelected(imageCaps.isAccelerated());
fbTrueVolatile.setSelected(imageCaps.isTrueVolatile());
imageCaps = bufferCaps.getFrontBufferCapabilities();
// Back buffer caps
imageCaps = bufferCaps.getBackBufferCapabilities();
bbAccelerated.setSelected(imageCaps.isAccelerated());
bbTrueVolatile.setSelected(imageCaps.isTrueVolatile());
}
private static String getFlipText(BufferCapabilities.FlipContents flip) {
if (flip == null) {
return "";
} else if (flip == BufferCapabilities.FlipContents.UNDEFINED) {
return "Method Unspecified";
} else if (flip == BufferCapabilities.FlipContents.BACKGROUND) {
return "Cleared to Background";
} else if (flip == BufferCapabilities.FlipContents.PRIOR) {
return "Previous Front Buffer";
} else { // if (flip == BufferCapabilities.FlipContents.COPIED)
return "Copied";
}
}
public static void main(String[] args) {
GraphicsEnvironment ge = GraphicsEnvironment
.getLocalGraphicsEnvironment();
GraphicsDevice[] devices = ge.getScreenDevices();
for (int i = 0; i < devices.length; i++) {
CapabilitiesTest tst = new CapabilitiesTest(devices[i]);
tst.pack();
tst.setVisible(true);
}
}
}
|
