public static DisplayMode getDesktopDisplayMode() {
GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice device = genv.getDefaultScreenDevice();
java.awt.DisplayMode mode = device.getDisplayMode();
return new LwjglApplicationConfigurationDisplayMode(
mode.getWidth(), mode.getHeight(), mode.getRefreshRate(), mode.getBitDepth());
}
/**
* Creates a new ZPixmapDataBuffer with a specified width and height.
*
* @param d the X display
* @param w the width
* @param h the height
*/
ZPixmapDataBuffer(int w, int h) {
super(TYPE_BYTE, w * h * 3); // TODO: Support non-24-bit-resolutions.
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
XGraphicsDevice dev = (XGraphicsDevice) env.getDefaultScreenDevice();
Display d = dev.getDisplay();
zpixmap = new ZPixmap(d, w, h, d.default_pixmap_format);
}
public static BufferedImage convertIconToBufferedImage(final Icon icon) {
if (icon == null) {
return null;
}
if (icon instanceof ImageIcon) {
final Image ret = ((ImageIcon) icon).getImage();
if (ret instanceof BufferedImage) {
return (BufferedImage) ret;
}
}
final int w = icon.getIconWidth();
final int h = icon.getIconHeight();
final GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
final GraphicsDevice gd = ge.getDefaultScreenDevice();
final GraphicsConfiguration gc = gd.getDefaultConfiguration();
final BufferedImage image = gc.createCompatibleImage(w, h, Transparency.TRANSLUCENT);
final Graphics2D g = image.createGraphics();
g.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
// g.setColor(Color.RED);
// g.fillRect(0, 0, w, h);
icon.paintIcon(null, g, 0, 0);
g.dispose();
return image;
}
public void beginExecution() {
if (cam == null) {
int numBuffers = 2;
env = GraphicsEnvironment.getLocalGraphicsEnvironment();
device = env.getDefaultScreenDevice();
// MultiBufferTest test = new MultiBufferTest(numBuffers, device);
try {
GraphicsConfiguration gc = device.getDefaultConfiguration();
mainFrame = new Frame(gc);
mainFrame.setUndecorated(true);
mainFrame.setIgnoreRepaint(true);
device.setFullScreenWindow(mainFrame);
if (device.isDisplayChangeSupported()) {
chooseBestDisplayMode(device);
}
mainFrame.createBufferStrategy(numBuffers);
bufferStrategy = mainFrame.getBufferStrategy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* Create possibly volatile scratch image for fast painting. A scratch image can become
* invalidated, when this happens any actions involving it are ignored, and it needs to be
* recreated. Use isScratchImageValid() to check this.
*/
public static Image createScratchImage(int width, int height) {
try {
Image img =
(Image)
tryMethod(
output_comp,
"createVolatileImage",
new Object[] {new Integer(width), new Integer(height)});
if (img == null) {
// no such method -> create regular image
return output_comp.createImage(width, height);
}
// if (img.validate(output_comp.getGraphicsConfiguration())
// == VolatileImage.IMAGE_INCOMPATIBLE) {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gs = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gs.getDefaultConfiguration();
Integer valid = (Integer) tryMethod(img, "validate", new Object[] {gc});
// output_comp.getGraphicsConfiguration() });
if (valid.intValue() == 2) { // I checked, IMAGE_INCOMPATIBLE=2
// Hmm, somehow it didn't work. Create regular image.
return output_comp.createImage(width, height);
}
return img;
} catch (java.security.AccessControlException e) {
// we're not allowed to do this (we're probably an applet)
return output_comp.createImage(width, height);
}
}
public static DisplayMode[] getDisplayModes() {
GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice device = genv.getDefaultScreenDevice();
java.awt.DisplayMode desktopMode = device.getDisplayMode();
java.awt.DisplayMode[] displayModes = device.getDisplayModes();
ArrayList<DisplayMode> modes = new ArrayList<DisplayMode>();
int idx = 0;
for (java.awt.DisplayMode mode : displayModes) {
boolean duplicate = false;
for (int i = 0; i < modes.size(); i++) {
if (modes.get(i).width == mode.getWidth()
&& modes.get(i).height == mode.getHeight()
&& modes.get(i).bitsPerPixel == mode.getBitDepth()) {
duplicate = true;
break;
}
}
if (duplicate) continue;
if (mode.getBitDepth() != desktopMode.getBitDepth()) continue;
modes.add(
new LwjglApplicationConfigurationDisplayMode(
mode.getWidth(), mode.getHeight(), mode.getRefreshRate(), mode.getBitDepth()));
}
return modes.toArray(new DisplayMode[modes.size()]);
}
public MafiaMainClass() {
setLayout(card); // BorderLayout
// add("WR",wr);
add("LOG", login); // window창 위에 penal을 올린다
setTitle("MAFIA GAME - LOGIN");
setSize(1280, 985); // window 크기
/* // 창을 중앙에 띄운다.
Dimension screen=Toolkit.getDefaultToolkit().getScreenSize();
Dimension ex_size = this.getSize();
int xpos=(int)(screen.getWidth()/2 - this.getWidth()/2);
int ypos=(int)(screen.getHeight()/2 - this.getHeight()/2);
this.setLocation(xpos,ypos);
*/
// 전체화면
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
setUndecorated(true);
gd.setFullScreenWindow(this);
setVisible(true); // window 보이기
setResizable(false); // 화면크기 고정
addMouseListener(this); // mouse움직임
}
/**
* ZombieFrame's constructor.
*
* @param contents Optional JPanel(s) to add to content pane. Arguments > 0 are ignored.
*/
public ZombieFrame(JPanel... contents) {
super("ZombieHouse");
// Request keyboard focus for the frame.
setFocusable(true);
requestFocusInWindow();
requestFocus();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setUndecorated(true);
setResizable(false);
setBackground(Color.BLACK);
// The content pane. An optional JPanel may be passed into the
// constructor. It creates an empty pane with a black background if
// one isn't provided.
pane = getContentPane();
pane.setBackground(Color.BLACK);
pane.setFocusable(false);
pane.setVisible(true);
if (contents.length > 0) {
pane.add(contents[0]);
}
keys = new ZombieKeyBinds((JComponent) pane);
// Get the graphics device information.
GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice graphics = environment.getDefaultScreenDevice();
pack();
// Go full screen, if supported.
if (graphics.isFullScreenSupported()) {
try {
graphics.setFullScreenWindow(this);
// Having gone full screen, retrieve the display size.
// size = Toolkit.getDefaultToolkit().getScreenSize();
// This double-switching of setVisible is to fix a bug with
// full-screen-exclusive mode on OS X. Versions 10.8 and later
// don't send keyboard events properly without it.
if (System.getProperty("os.name").contains("OS X")) {
setVisible(false);
}
} catch (HeadlessException ex) {
System.err.println(
"Error: primary display not set or found. "
+ "Your experience of life may be suboptimal.");
ex.printStackTrace();
}
} else {
// If full-screen-exclusive mode isn't supported, switch to
// maximized window mode.
System.err.println("Full-screen-exclusive mode not supported.");
setExtendedState(Frame.MAXIMIZED_BOTH);
}
setVisible(true);
}
public static BufferedImage createEmptyImage(final int w, final int h) {
final GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
final GraphicsDevice gd = ge.getDefaultScreenDevice();
final GraphicsConfiguration gc = gd.getDefaultConfiguration();
final BufferedImage image = gc.createCompatibleImage(w, h, Transparency.BITMASK);
return image;
}
/**
* Creates a device compatible BufferedImage
*
* @param width the width in pixels
* @param height the height in pixels
*/
public static BufferedImage getDeviceCompatibleImage(int width, int height) {
GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice screenDevice = graphicsEnvironment.getDefaultScreenDevice();
GraphicsConfiguration graphicConfiguration = screenDevice.getDefaultConfiguration();
BufferedImage image = graphicConfiguration.createCompatibleImage(width, height);
return image;
}
// TODO not used
private void showNotification() {
final WebDialog dialog = new WebDialog();
dialog.setUndecorated(true);
dialog.setBackground(Color.BLACK);
dialog.setBackground(StyleConstants.transparent);
WebNotificationPopup popup = new WebNotificationPopup(PopupStyle.dark);
popup.setIcon(Utils.getIcon("kontalk_small.png"));
popup.setMargin(View.MARGIN_DEFAULT);
popup.setDisplayTime(6000);
popup.addNotificationListener(
new NotificationListener() {
@Override
public void optionSelected(NotificationOption option) {}
@Override
public void accepted() {}
@Override
public void closed() {
dialog.dispose();
}
});
// content
WebPanel panel = new WebPanel();
panel.setMargin(View.MARGIN_DEFAULT);
panel.setOpaque(false);
WebLabel title = new WebLabel("A new Message!");
title.setFontSize(View.FONT_SIZE_BIG);
title.setForeground(Color.WHITE);
panel.add(title, BorderLayout.NORTH);
String text = "this is some message, and some longer text was added";
WebLabel message = new WebLabel(text);
message.setForeground(Color.WHITE);
panel.add(message, BorderLayout.CENTER);
popup.setContent(panel);
// popup.packPopup();
dialog.setSize(popup.getPreferredSize());
// set position on screen
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gd.getDefaultConfiguration();
Rectangle screenBounds = gc.getBounds();
// get height of the task bar
// doesn't work on all environments
// Insets toolHeight = toolkit.getScreenInsets(popup.getGraphicsConfiguration());
int toolHeight = 40;
dialog.setLocation(
screenBounds.width - dialog.getWidth() - 10,
screenBounds.height - toolHeight - dialog.getHeight());
dialog.setVisible(true);
NotificationManager.showNotification(dialog, popup);
}
/**
* Retrieves transparent image of specified dimension.
*
* @param width Image width.
* @param height Image height.
* @return Transparent image of specified dimension.
*/
public static BufferedImage getBlankImage(int width, int height) {
if (UIUtil.isRetina()) {
return new JBHiDPIScaledImage(width, height, BufferedImage.TYPE_INT_ARGB);
} else {
GraphicsEnvironment e = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice d = e.getDefaultScreenDevice();
GraphicsConfiguration c = d.getDefaultConfiguration();
return c.createCompatibleImage(width, height, Transparency.TRANSLUCENT);
}
}
public static WGLGraphicsConfig getGC(WComponentPeer peer) {
if (peer != null) {
return (WGLGraphicsConfig) peer.getGraphicsConfiguration();
} else {
// REMIND: this should rarely (never?) happen, but what if
// default config is not WGL?
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = env.getDefaultScreenDevice();
return (WGLGraphicsConfig) gd.getDefaultConfiguration();
}
}
private static D3DGraphicsConfig getGC(WComponentPeer peer) {
GraphicsConfiguration gc;
if (peer != null) {
gc = peer.getGraphicsConfiguration();
} else {
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = env.getDefaultScreenDevice();
gc = gd.getDefaultConfiguration();
}
return (gc instanceof D3DGraphicsConfig) ? (D3DGraphicsConfig) gc : null;
}
public static void main(String[] args) {
GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice displayDevice = environment.getDefaultScreenDevice();
frame = new Frame(displayDevice.getDefaultConfiguration());
frame.setBackground(new Color(0xCC, 0xCC, 0xCC));
frame.setTitle("TestBug735Inv0AppletAWT");
try {
Class<?> c =
Thread.currentThread()
.getContextClassLoader()
.loadClass(Bug735Inv0AppletAWT.class.getName());
applet = (Bug735Inv0AppletAWT) c.newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
frame.setLayout(null);
frame.add(applet);
frame.pack();
frame.setResizable(false);
applet.init();
Insets insets = frame.getInsets();
int windowW = applet.width + insets.left + insets.right;
int windowH = applet.height + insets.top + insets.bottom;
frame.setSize(windowW, windowH);
Rectangle screenRect = displayDevice.getDefaultConfiguration().getBounds();
frame.setLocation(
screenRect.x + (screenRect.width - applet.width) / 2,
screenRect.y + (screenRect.height - applet.height) / 2);
int usableWindowH = windowH - insets.top - insets.bottom;
applet.setBounds(
(windowW - applet.width) / 2,
insets.top + (usableWindowH - applet.height) / 2,
applet.width,
applet.height);
// This allows to close the frame.
frame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
applet.initGL();
frame.setVisible(true);
applet.start();
}
/**
* Generate array with all avalaible resolutions.
*
* @return array of resolution strings
*/
private ResolutionString[] generateResolutionStrings() {
GraphicsEnvironment g = GraphicsEnvironment.getLocalGraphicsEnvironment();
DisplayMode[] display_mods = g.getDefaultScreenDevice().getDisplayModes();
ResolutionString[] resolution_strings = new ResolutionString[display_mods.length];
for (int i = 0; i < display_mods.length; i++) {
resolution_strings[i] = new ResolutionString(display_mods[i]);
}
return resolution_strings;
}
/** Realiza la inicializacion previa del modo pantalla completa. */
private void init() {
env = GraphicsEnvironment.getLocalGraphicsEnvironment();
graphicsDevice = env.getDefaultScreenDevice();
oldDisplayMode = graphicsDevice.getDisplayMode();
if (!graphicsDevice.isFullScreenSupported()) {
System.out.println("Full screen mode failed");
System.exit(1);
} else {
GraphicsConfiguration gc = graphicsDevice.getDefaultConfiguration();
window = new Frame(gc);
}
}
// This method returns a buffered image with the contents of an image
public static BufferedImage toBufferedImage(Image image) {
if (image instanceof BufferedImage) {
return (BufferedImage) image;
}
// This code ensures that all the pixels in the image are loaded
image = new ImageIcon(image).getImage();
// Determine if the image has transparent pixels;
// for this method's
// implementation, see Determining If an Image Has
// Transparent Pixels
boolean hasAlpha = hasAlpha(image);
// Create a buffered image with a format that's compatible
// with the screen
BufferedImage bimage = null;
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
try {
// Determine the type of transparency of the new
// buffered image
int transparency = Transparency.OPAQUE;
if (hasAlpha) {
transparency = Transparency.BITMASK;
}
// Create the buffered image
GraphicsDevice gs = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gs.getDefaultConfiguration();
bimage = gc.createCompatibleImage(image.getWidth(null), image.getHeight(null), transparency);
} catch (HeadlessException e) {
// The system does not have a screen
}
if (bimage == null) {
// Create a buffered image using the default color model
int type = BufferedImage.TYPE_INT_RGB;
if (hasAlpha) {
type = BufferedImage.TYPE_INT_ARGB;
}
bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
}
// Copy image to buffered image
Graphics g = bimage.createGraphics();
// Paint the image onto the buffered image
g.drawImage(image, 0, 0, null);
g.dispose();
return bimage;
}
public TransparentSurface(int width, int height) {
// create the offscreen buffer
GraphicsEnvironment local = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice screen = local.getDefaultScreenDevice();
GraphicsConfiguration conf = screen.getDefaultConfiguration();
surface = conf.createCompatibleImage(width, height, Transparency.TRANSLUCENT);
// create the graphics interface
graphics = (Graphics2D) surface.createGraphics();
// clear it
clear();
}
/** Create empty image with given alpha mode that should be efficient on this display */
public static BufferedImage createCompatibleImage(int width, int height, int transparency) {
// try {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gs = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gs.getDefaultConfiguration();
// always use bitmask transparency
BufferedImage bimage = gc.createCompatibleImage(width, height, transparency);
return bimage;
// } catch (HeadlessException e) { // this exception is not in 1.2
// The system does not have a screen
// e.printStackTrace();
// return null;
// }
}
private static BufferedImage createCompatibleImage(
final BufferedImage img, final boolean translucent) {
final GraphicsEnvironment e = GraphicsEnvironment.getLocalGraphicsEnvironment();
final GraphicsDevice d = e.getDefaultScreenDevice();
final GraphicsConfiguration c = d.getDefaultConfiguration();
final int t = translucent ? Transparency.TRANSLUCENT : Transparency.BITMASK;
final BufferedImage ret = c.createCompatibleImage(img.getWidth(), img.getHeight(), t);
final Graphics2D g = ret.createGraphics();
g.drawImage(img, 0, 0, null);
g.dispose();
return ret;
}
/**
* GraphicsManager maintains graphics context information that maybe useful for many aspects of
* graphics rendering. This means that many of the fields are computer dependent and are placed here
* so they are only calculated once.
*/
public class GraphicsManager {
/** get GraphicConfiguration for default screen - this should only be done once at startup * */
private static GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
private static GraphicsDevice gs = ge.getDefaultScreenDevice();
public static GraphicsConfiguration gc = gs.getDefaultConfiguration();
private static final int MAX_RECYCLED_IMAGES = 50;
private static int numRecycledImages = 0;
private static HashMap<Dimension, List<BufferedImage>> recycledImages =
new HashMap<Dimension, List<BufferedImage>>();
/**
* Functionally equivalent to gc.createCompatibleImage(width, height, Transparency.TRANSLUCENT)
* but allows reusing released images.
*/
public static BufferedImage getGCCompatibleImage(int width, int height) {
List<BufferedImage> imgList = recycledImages.get(new Dimension(width, height));
if (imgList == null || imgList.isEmpty())
return gc.createCompatibleImage(width, height, Transparency.TRANSLUCENT);
numRecycledImages--;
BufferedImage img = imgList.remove(imgList.size() - 1);
// Clear the image
Graphics2D g2D = img.createGraphics();
g2D.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
Rectangle2D.Double rect = new Rectangle2D.Double(0, 0, width, height);
g2D.fill(rect);
return img;
}
/**
* Add an image to the recycled images list (or if img = null, does nothing). Note: the passed
* variable should be immediately set to null to avoid aliasing bugs.
*/
public static void recycleGCCompatibleImage(BufferedImage img) {
if (img == null) return;
// Make sure we don't waste too much memory
if (numRecycledImages >= MAX_RECYCLED_IMAGES) {
recycledImages.clear();
}
Dimension dim = new Dimension(img.getWidth(), img.getHeight());
List<BufferedImage> imgList = recycledImages.get(dim);
if (imgList == null) {
imgList = new ArrayList<BufferedImage>();
recycledImages.put(dim, imgList);
}
imgList.add(img);
}
}
public Image iconToImage(Icon icon) {
if (icon instanceof ImageIcon) {
return ((ImageIcon) icon).getImage();
} else {
int w = icon.getIconWidth();
int h = icon.getIconHeight();
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gd.getDefaultConfiguration();
BufferedImage image = gc.createCompatibleImage(w, h);
Graphics2D g = image.createGraphics();
icon.paintIcon(null, g, 0, 0);
g.dispose();
return image;
}
}
private VolatileImage createVolatileImage(int width, int height, int transparency) {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
VolatileImage image = null;
image = gc.createCompatibleVolatileImage(width, height, transparency);
int valid = image.validate(gc);
if (valid == VolatileImage.IMAGE_INCOMPATIBLE) {
image = this.createVolatileImage(width, height, transparency);
return image;
}
return image;
}
private static void test(BufferedImage bi, int type) throws IOException {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
VolatileImage vi = gc.createCompatibleVolatileImage(511, 255, type);
BufferedImage gold = gc.createCompatibleImage(511, 255, type);
// draw to compatible Image
Graphics2D big = gold.createGraphics();
// force scaled blit
big.drawImage(bi, 7, 11, 127, 111, 7, 11, 127 * 2, 111, null);
big.dispose();
// draw to volatile image
BufferedImage snapshot;
while (true) {
vi.validate(gc);
if (vi.validate(gc) != VolatileImage.IMAGE_OK) {
try {
Thread.sleep(100);
} catch (final InterruptedException ignored) {
}
continue;
}
Graphics2D vig = vi.createGraphics();
// force scaled blit
vig.drawImage(bi, 7, 11, 127, 111, 7, 11, 127 * 2, 111, null);
vig.dispose();
snapshot = vi.getSnapshot();
if (vi.contentsLost()) {
try {
Thread.sleep(100);
} catch (final InterruptedException ignored) {
}
continue;
}
break;
}
// validate images
for (int x = 7; x < 127; ++x) {
for (int y = 11; y < 111; ++y) {
if (gold.getRGB(x, y) != snapshot.getRGB(x, y)) {
ImageIO.write(gold, "png", new File("gold.png"));
ImageIO.write(snapshot, "png", new File("bi.png"));
throw new RuntimeException("Test failed.");
}
}
}
}
static {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
Enumeration keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
Object value = UIManager.get(key);
if (value instanceof Font) {
Font f = (Font) value;
UIManager.put(key, f.deriveFont(Font.BOLD, f.getSize() * 1.2f));
}
}
} catch (ClassNotFoundException
| InstantiationException
| IllegalAccessException
| UnsupportedLookAndFeelException e) {
e.printStackTrace();
}
localGraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
defaultScreenDevice = localGraphicsEnvironment.getDefaultScreenDevice();
displayMode = defaultScreenDevice.getDisplayMode();
for (GraphicsDevice device : localGraphicsEnvironment.getScreenDevices()) {
System.out.println(device.toString());
}
reloadFonts();
Config.addConfigChangeListener(
new String[] {
"font1_file", "font1_size", "font2_file", "font2_size",
},
new ConfigChangeListener() {
@Override
public void configChanged(ConfigChangeEvent e) {
reloadFonts();
MainFrame.getInstance().repaint();
ProgramWindow.getInstance().repaint();
}
});
instance = new MainFrame();
}
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) {
logger.error(e.getMessage(), e);
}
System.exit(0);
}
public static GraphicsConfiguration getTranslucencyCapableGC() {
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsConfiguration ret = env.getDefaultScreenDevice().getDefaultConfiguration();
if (AWTUtilitiesWrapper.isTranslucencyCapable(ret)) {
return ret;
} else {
GraphicsDevice[] devices = env.getScreenDevices();
for (int i = 0; i < devices.length; i++) {
GraphicsConfiguration[] configs = devices[i].getConfigurations();
for (int j = 0; j < configs.length; j++) {
if (AWTUtilitiesWrapper.isTranslucencyCapable(configs[j])) {
return configs[j];
}
}
}
return null;
}
}
@Override
public void start() {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
gd = ge.getDefaultScreenDevice();
if (!gd.isFullScreenSupported()) {
onError("Full-screen exclusive mode not supported");
System.exit(0);
}
// switch on FSEM
// gd.setFullScreenWindow(window);
window.setVisible(true);
renderThread.start();
updateThread.start();
inputThread.start();
}
public kra() throws Exception {
GraphicsEnvironment var1 = GraphicsEnvironment.getLocalGraphicsEnvironment();
this.b = var1.getDefaultScreenDevice();
if (!this.b.isFullScreenSupported()) {
GraphicsDevice[] var2 = var1.getScreenDevices();
GraphicsDevice[] var3 = var2;
for (int var4 = 0; ~var4 > ~var3.length; ++var4) {
GraphicsDevice var5 = var3[var4];
if (null != var5 && var5.isFullScreenSupported()) {
this.b = var5;
return;
}
}
throw new Exception();
}
}