Java/2D Graphics GUI/Full Screen
Содержание
Full screen: Capabilities Test
<source lang="java"> /*
* 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);
}
}
}
</source>
Full screen: Display Mode Test
<source lang="java"> /*
* 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.
*/
/*
test @(#)DisplayModeTest.java 1.4 01/07/17 @bug 4189326 @summary Tests changing display mode @author martak@eng: area=FullScreen @ignore This test enters full-screen mode, if available, and should not be run as an applet or as part of the test harness. */
/**
* This test generates a table of all available display modes, enters * full-screen mode, if available, and allows you to change the display mode. * The application should look fine under each enumerated display mode. On UNIX, * only a single display mode should be available, and on Microsoft Windows, * display modes should depend on direct draw availability and the type of * graphics card. */
import java.awt.BorderLayout; import java.awt.Container; import java.awt.Dimension; import java.awt.DisplayMode; import java.awt.FlowLayout; import java.awt.GraphicsDevice; import java.awt.GraphicsEnvironment; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JScrollPane; import javax.swing.JTable; import javax.swing.ListSelectionModel; import javax.swing.event.ListSelectionEvent; import javax.swing.event.ListSelectionListener; import javax.swing.table.DefaultTableModel; import javax.swing.table.TableColumn; class DisplayModeModel extends DefaultTableModel {
private DisplayMode[] modes;
public DisplayModeModel(DisplayMode[] modes) {
this.modes = modes;
}
public DisplayMode getDisplayMode(int r) {
return modes[r];
}
public String getColumnName(int c) {
return DisplayModeTest.COLUMN_NAMES[c];
}
public int getColumnCount() {
return DisplayModeTest.COLUMN_WIDTHS.length;
}
public boolean isCellEditable(int r, int c) {
return false;
}
public int getRowCount() {
if (modes == null) {
return 0;
}
return modes.length;
}
public Object getValueAt(int rowIndex, int colIndex) {
DisplayMode dm = modes[rowIndex];
switch (colIndex) {
case DisplayModeTest.INDEX_WIDTH:
return Integer.toString(dm.getWidth());
case DisplayModeTest.INDEX_HEIGHT:
return Integer.toString(dm.getHeight());
case DisplayModeTest.INDEX_BITDEPTH: {
int bitDepth = dm.getBitDepth();
String ret;
if (bitDepth == DisplayMode.BIT_DEPTH_MULTI) {
ret = "Multi";
} else {
ret = Integer.toString(bitDepth);
}
return ret;
}
case DisplayModeTest.INDEX_REFRESHRATE: {
int refreshRate = dm.getRefreshRate();
String ret;
if (refreshRate == DisplayMode.REFRESH_RATE_UNKNOWN) {
ret = "Unknown";
} else {
ret = Integer.toString(refreshRate);
}
return ret;
}
}
throw new ArrayIndexOutOfBoundsException("Invalid column value");
}
} public class DisplayModeTest extends JFrame implements ActionListener,
ListSelectionListener {
private boolean waiting = false;
private GraphicsDevice device;
private DisplayMode originalDM;
private JButton exit = new JButton("Exit");
private JButton changeDM = new JButton("Set Display");
private JLabel currentDM = new JLabel();
private JTable dmList = new JTable();
private JScrollPane dmPane = new JScrollPane(dmList);
private boolean isFullScreen = false;
public static final int INDEX_WIDTH = 0;
public static final int INDEX_HEIGHT = 1;
public static final int INDEX_BITDEPTH = 2;
public static final int INDEX_REFRESHRATE = 3;
public static final int[] COLUMN_WIDTHS = new int[] { 100, 100, 100, 100 };
public static final String[] COLUMN_NAMES = new String[] { "Width",
"Height", "Bit Depth", "Refresh Rate" };
public DisplayModeTest(GraphicsDevice device) {
super(device.getDefaultConfiguration());
this.device = device;
setTitle("Display Mode Test");
originalDM = device.getDisplayMode();
setDMLabel(originalDM);
setDefaultCloseOperation(EXIT_ON_CLOSE);
// Make sure a DM is always selected in the list
exit.addActionListener(this);
changeDM.addActionListener(this);
changeDM.setEnabled(device.isDisplayChangeSupported());
}
public void actionPerformed(ActionEvent ev) {
Object source = ev.getSource();
if (source == exit) {
device.setDisplayMode(originalDM);
System.exit(0);
} else { // if (source == changeDM)
int index = dmList.getSelectionModel().getAnchorSelectionIndex();
if (index >= 0) {
DisplayModeModel model = (DisplayModeModel) dmList.getModel();
DisplayMode dm = model.getDisplayMode(index);
device.setDisplayMode(dm);
setDMLabel(dm);
setSize(new Dimension(dm.getWidth(), dm.getHeight()));
validate();
}
}
}
public void valueChanged(ListSelectionEvent ev) {
changeDM.setEnabled(device.isDisplayChangeSupported());
}
private void initComponents(Container c) {
setContentPane(c);
c.setLayout(new BorderLayout());
// Current DM
JPanel currentPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
c.add(currentPanel, BorderLayout.NORTH);
JLabel current = new JLabel("Current Display Mode : ");
currentPanel.add(current);
currentPanel.add(currentDM);
// Display Modes
JPanel modesPanel = new JPanel(new GridLayout(1, 2));
c.add(modesPanel, BorderLayout.CENTER);
// List of display modes
for (int i = 0; i < COLUMN_WIDTHS.length; i++) {
TableColumn col = new TableColumn(i, COLUMN_WIDTHS[i]);
col.setIdentifier(COLUMN_NAMES[i]);
col.setHeaderValue(COLUMN_NAMES[i]);
dmList.addColumn(col);
}
dmList.getSelectionModel().setSelectionMode(
ListSelectionModel.SINGLE_SELECTION);
dmList.getSelectionModel().addListSelectionListener(this);
modesPanel.add(dmPane);
// Controls
JPanel controlsPanelA = new JPanel(new BorderLayout());
modesPanel.add(controlsPanelA);
JPanel controlsPanelB = new JPanel(new GridLayout(2, 1));
controlsPanelA.add(controlsPanelB, BorderLayout.NORTH);
// Exit
JPanel exitPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
controlsPanelB.add(exitPanel);
exitPanel.add(exit);
// Change DM
JPanel changeDMPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
controlsPanelB.add(changeDMPanel);
changeDMPanel.add(changeDM);
controlsPanelA.add(new JPanel(), BorderLayout.CENTER);
}
public void setVisible(boolean isVis) {
super.setVisible(isVis);
if (isVis) {
dmList.setModel(new DisplayModeModel(device.getDisplayModes()));
}
}
public void setDMLabel(DisplayMode newMode) {
int bitDepth = newMode.getBitDepth();
int refreshRate = newMode.getRefreshRate();
String bd, rr;
if (bitDepth == DisplayMode.BIT_DEPTH_MULTI) {
bd = "Multi";
} else {
bd = Integer.toString(bitDepth);
}
if (refreshRate == DisplayMode.REFRESH_RATE_UNKNOWN) {
rr = "Unknown";
} else {
rr = Integer.toString(refreshRate);
}
currentDM.setText(COLUMN_NAMES[INDEX_WIDTH] + ": " + newMode.getWidth()
+ " " + COLUMN_NAMES[INDEX_HEIGHT] + ": " + newMode.getHeight()
+ " " + COLUMN_NAMES[INDEX_BITDEPTH] + ": " + bd + " "
+ COLUMN_NAMES[INDEX_REFRESHRATE] + ": " + rr);
}
public void begin() {
isFullScreen = device.isFullScreenSupported();
setUndecorated(isFullScreen);
setResizable(!isFullScreen);
if (isFullScreen) {
// Full-screen mode
device.setFullScreenWindow(this);
validate();
} else {
// Windowed mode
pack();
setVisible(true);
}
}
public static void main(String[] args) {
GraphicsEnvironment env = GraphicsEnvironment
.getLocalGraphicsEnvironment();
GraphicsDevice[] devices = env.getScreenDevices();
// REMIND : Multi-monitor full-screen mode not yet supported
for (int i = 0; i < 1 /* devices.length */; i++) {
DisplayModeTest test = new DisplayModeTest(devices[i]);
test.initComponents(test.getContentPane());
test.begin();
}
}
}
</source>
Full screen:MultiBuffer Test
<source lang="java"> /*
* 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 takes a number up to 13 as an argument (assumes 2 by default) and * creates a multiple buffer strategy with the number of buffers given. This * application enters full-screen mode, if available, and flips back and forth * between each buffer (each signified by a different color). */
import java.awt.Color; import java.awt.DisplayMode; import java.awt.Frame; import java.awt.Graphics; import java.awt.GraphicsConfiguration; import java.awt.GraphicsDevice; import java.awt.GraphicsEnvironment; import java.awt.Rectangle; import java.awt.image.BufferStrategy; public class MultiBufferTest {
private static Color[] COLORS = new Color[] { Color.red, Color.blue,
Color.green, Color.white, Color.black, Color.yellow, Color.gray,
Color.cyan, Color.pink, Color.lightGray, Color.magenta,
Color.orange, Color.darkGray };
private static DisplayMode[] BEST_DISPLAY_MODES = new DisplayMode[] {
new DisplayMode(640, 480, 32, 0), new DisplayMode(640, 480, 16, 0),
new DisplayMode(640, 480, 8, 0) };
Frame mainFrame;
public MultiBufferTest(int numBuffers, GraphicsDevice device) {
try {
GraphicsConfiguration gc = device.getDefaultConfiguration();
mainFrame = new Frame(gc);
mainFrame.setUndecorated(true);
mainFrame.setIgnoreRepaint(true);
device.setFullScreenWindow(mainFrame);
if (device.isDisplayChangeSupported()) {
chooseBestDisplayMode(device);
}
Rectangle bounds = mainFrame.getBounds();
mainFrame.createBufferStrategy(numBuffers);
BufferStrategy bufferStrategy = mainFrame.getBufferStrategy();
for (float lag = 2000.0f; lag > 0.00000006f; lag = lag / 1.33f) {
for (int i = 0; i < numBuffers; i++) {
Graphics g = bufferStrategy.getDrawGraphics();
if (!bufferStrategy.contentsLost()) {
g.setColor(COLORS[i]);
g.fillRect(0, 0, bounds.width, bounds.height);
bufferStrategy.show();
g.dispose();
}
try {
Thread.sleep((int) lag);
} catch (InterruptedException e) {
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
device.setFullScreenWindow(null);
}
}
private static DisplayMode getBestDisplayMode(GraphicsDevice device) {
for (int x = 0; x < BEST_DISPLAY_MODES.length; x++) {
DisplayMode[] modes = device.getDisplayModes();
for (int i = 0; i < modes.length; i++) {
if (modes[i].getWidth() == BEST_DISPLAY_MODES[x].getWidth()
&& modes[i].getHeight() == BEST_DISPLAY_MODES[x]
.getHeight()
&& modes[i].getBitDepth() == BEST_DISPLAY_MODES[x]
.getBitDepth()) {
return BEST_DISPLAY_MODES[x];
}
}
}
return null;
}
public static void chooseBestDisplayMode(GraphicsDevice device) {
DisplayMode best = getBestDisplayMode(device);
if (best != null) {
device.setDisplayMode(best);
}
}
public static void main(String[] args) {
try {
int numBuffers = 2;
if (args != null && args.length > 0) {
numBuffers = Integer.parseInt(args[0]);
if (numBuffers < 2 || numBuffers > COLORS.length) {
System.err.println("Must specify between 2 and "
+ COLORS.length + " buffers");
System.exit(1);
}
}
GraphicsEnvironment env = GraphicsEnvironment
.getLocalGraphicsEnvironment();
GraphicsDevice device = env.getDefaultScreenDevice();
MultiBufferTest test = new MultiBufferTest(numBuffers, device);
} catch (Exception e) {
e.printStackTrace();
}
System.exit(0);
}
}
</source>
Full screen test
<source lang="java"> import java.awt.Color; import java.awt.DisplayMode; import java.awt.Frame; import java.awt.Graphics; import java.awt.GraphicsDevice; import java.awt.GraphicsEnvironment; import java.awt.Rectangle; import java.awt.image.BufferStrategy; public class FullScreen {
private static int counter = 0;
private static final int MAX = 50;
private static DisplayMode MODES[] = new DisplayMode[] {
new DisplayMode(640, 480, 32, 0), new DisplayMode(640, 480, 16, 0),
new DisplayMode(640, 480, 8, 0) };
private static DisplayMode getBestDisplayMode(GraphicsDevice device) {
for (int x = 0, xn = MODES.length; x < xn; x++) {
DisplayMode[] modes = device.getDisplayModes();
for (int i = 0, in = modes.length; i < in; i++) {
if (modes[i].getWidth() == MODES[x].getWidth()
&& modes[i].getHeight() == MODES[x].getHeight()
&& modes[i].getBitDepth() == MODES[x].getBitDepth()) {
return MODES[x];
}
}
}
return null;
}
public static void main(String args[]) {
GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
GraphicsDevice graphicsDevice = graphicsEnvironment
.getDefaultScreenDevice();
DisplayMode originalDisplayMode = graphicsDevice.getDisplayMode();
try {
Frame frame = new Frame();
frame.setUndecorated(true);
frame.setIgnoreRepaint(true);
graphicsDevice.setFullScreenWindow(frame);
if (graphicsDevice.isDisplayChangeSupported()) {
graphicsDevice
.setDisplayMode(getBestDisplayMode(graphicsDevice));
}
frame.createBufferStrategy(2); // 2 buffers
Rectangle bounds = frame.getBounds();
BufferStrategy bufferStrategy = frame.getBufferStrategy();
while (!done()) {
Graphics g = null;
try {
g = bufferStrategy.getDrawGraphics();
if ((counter <= 2)) { // 2 buffers
g.setColor(Color.CYAN);
g.fillRect(0, 0, bounds.width, bounds.height);
}
g.setColor(Color.RED);
// redraw prior line, too, since 2 buffers
if (counter != 1) {
g.drawLine(counter - 1, (counter - 1) * 5,
bounds.width, bounds.height);
}
g.drawLine(counter, counter * 5, bounds.width,
bounds.height);
bufferStrategy.show();
} finally {
if (g != null) {
g.dispose();
}
}
try {
Thread.sleep(250);
} catch (InterruptedException ignored) {
}
}
} finally {
graphicsDevice.setDisplayMode(originalDisplayMode);
graphicsDevice.setFullScreenWindow(null);
}
System.exit(0);
}
private static boolean done() {
return (counter++ == MAX);
}
}
</source>
