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 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 PlateauGraphique(/*int largeur, int hauteur,*/ Monopoly m) {
this.m = m;
cases = new ArrayList<CaseGraphique>();
setExtendedState(JFrame.MAXIMIZED_BOTH);
GraphicsDevice device =
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
device.setFullScreenWindow(this);
this.largeur = getContentPane().getWidth();
this.hauteur = getContentPane().getHeight();
if (largeur > hauteur) largeur = hauteur;
else hauteur = largeur;
initialiser();
addComponents(getContentPane());
for (Joueur j : m.getJoueurs()) {
((JoueurDefaut) j).addObserver(this);
}
pack();
setVisible(true);
}
/** Restores the screen's display mode. */
public void restoreScreen() {
Window window = device.getFullScreenWindow();
if (window != null) {
window.dispose();
}
device.setFullScreenWindow(null);
}
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());
}
/**
* Applies this geometry to a window. Makes sure that the window is not placed outside of the
* coordinate range of all available screens.
*
* @param window the window
*/
public void applySafe(Window window) {
Point p = new Point(topLeft);
Rectangle virtualBounds = new Rectangle();
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] gs = ge.getScreenDevices();
for (GraphicsDevice gd : gs) {
if (gd.getType() == GraphicsDevice.TYPE_RASTER_SCREEN) {
virtualBounds = virtualBounds.union(gd.getDefaultConfiguration().getBounds());
}
}
if (p.x < virtualBounds.x) {
p.x = virtualBounds.x;
} else if (p.x > virtualBounds.x + virtualBounds.width - extent.width) {
p.x = virtualBounds.x + virtualBounds.width - extent.width;
}
if (p.y < virtualBounds.y) {
p.y = virtualBounds.y;
} else if (p.y > virtualBounds.y + virtualBounds.height - extent.height) {
p.y = virtualBounds.y + virtualBounds.height - extent.height;
}
window.setLocation(p);
window.setSize(extent);
}
/** Recupera el modo de pantalla no completa */
public void recuperarPantalla() {
Window window = device.getFullScreenWindow();
if (window != null) {
window.dispose();
}
device.setFullScreenWindow(null);
}
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();
}
}
}
private boolean enterFullScreenMode() {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] devices = ge.getScreenDevices();
for (int i = 0; i < devices.length; i++) {
GraphicsDevice device = devices[i];
if (device.isFullScreenSupported() && device.getFullScreenWindow() == null) {
log.info("Switching to full screen mode.");
frame.setVisible(false);
try {
device.setFullScreenWindow(frame);
} catch (InternalError e) {
log.error("Failed to switch to full screen exclusive mode.");
e.printStackTrace();
frame.setVisible(true);
return false;
}
frame.dispose();
frame.setUndecorated(true);
frame.setVisible(true);
frame.requestFocusInWindow();
return true;
}
}
log.warn("No screens available or full screen exclusive mode is unsupported on your platform.");
postError("Full screen mode is not supported on your platform.");
return false;
}
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움직임
}
/**
* 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);
}
}
/**
* From https://java3d.dev.java.net/issues/show_bug.cgi?id=89 Finds the preferred <code>
* GraphicsConfiguration</code> object for the system. This object can then be used to create the
* Canvas3D object for this system.
*
* @param window the window in which the Canvas3D will reside
* @return The best <code>GraphicsConfiguration</code> object for the system.
*/
private static GraphicsConfiguration getPreferredConfiguration(Window window) {
if (window == null) return SimpleUniverse.getPreferredConfiguration();
GraphicsDevice device = window.getGraphicsConfiguration().getDevice();
GraphicsConfigTemplate3D template = new GraphicsConfigTemplate3D();
String stereo;
// Check if the user has set the Java 3D stereo option.
// Getting the system properties causes appletviewer to fail with a
// security exception without a try/catch.
stereo =
(String)
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction() {
public Object run() {
return System.getProperty("j3d.stereo");
}
});
// update template based on properties.
if (stereo != null) {
if (stereo.equals("REQUIRED")) template.setStereo(GraphicsConfigTemplate.REQUIRED);
else if (stereo.equals("PREFERRED")) template.setStereo(GraphicsConfigTemplate.PREFERRED);
}
// Return the GraphicsConfiguration that best fits our needs.
return device.getBestConfiguration(template);
}
public synchronized void toggleFullScreen() {
if (inFullScreen) {
this.dispose();
gd.setFullScreenWindow(null);
canvas.setSize(NES_HEIGHT * screenScaleFactor, NES_WIDTH * screenScaleFactor);
this.setUndecorated(false);
this.setVisible(true);
inFullScreen = false;
buildMenus();
// nes.resume();
} else {
setJMenuBar(null);
gd = getGraphicsConfiguration().getDevice();
if (!gd.isFullScreenSupported()) {
// then fullscreen will give a window the size of the screen instead
messageBox("Fullscreen is not supported by your OS or version of Java.");
}
this.dispose();
this.setUndecorated(true);
gd.setFullScreenWindow(this);
this.setVisible(true);
inFullScreen = true;
}
}
public int getScreenHeight() {
// Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
int height = gd.getDisplayMode().getHeight();
return height;
}
// get out of full screen
public void restoreScreen() {
Window w = vc.getFullScreenWindow();
if (w != null) {
w.dispose();
}
vc.setFullScreenWindow(null);
}
/**
* 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;
}
public int getScreenWidth() {
// Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
// double width = screenSize.getWidth();
GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
int width = gd.getDisplayMode().getWidth();
return width;
}
// 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);
}
/**
* Create the window, asking for which screen to use if there are multiple monitors and either
* forcechoice is true, or the user hasn't already picked a screen.
*
* @param part the JComponent to display
* @param forcechoice false if user shouldn't be asked twice which of several monitors to use.
*/
private void init(JComponent part, boolean forcechoice) {
if (forcechoice) {
defaultScreen = null;
}
screen = null;
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice screens[] = ge.getScreenDevices();
if (defaultScreen != null) {
for (int i = 0; i < screens.length; i++) {
if (screens[i] == defaultScreen) {
screen = defaultScreen;
}
}
}
if (screens.length == 1) {
screen = screens[0];
}
if (screen == null) {
screen = pickScreen(screens);
}
if (dead) {
return;
}
defaultScreen = screen;
DisplayMode dm = screen.getDisplayMode();
GraphicsConfiguration gc = screen.getDefaultConfiguration();
jf = new JFrame(gc);
jf.setUndecorated(true);
jf.setBounds(gc.getBounds());
jf.getContentPane().add(part);
jf.setVisible(true);
screen.setFullScreenWindow(jf);
}
/**
* 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;
}
private static GraphicsDevice getScreen(JFrame window) {
for (GraphicsDevice gd : GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()) {
if (gd.getDefaultConfiguration().getBounds().contains(window.getLocationOnScreen()))
return gd;
}
System.err.println(
window + " does not appear to be on any screen; fullscreening onto default screen");
return GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
}
public ChartingLogger() {
frame = new LogChartFrame(new LoggerComms());
// frame = new LogChartFrame(new SocketComms());
frame.pack();
// restore previous window state, size, location if saved
String[] stateItems =
ConfigurationManager.getConfigItem(ConfigurationManager.CONFIG_WINDOWSTATE, "none")
.split(",");
// Toolkit.getDefaultToolkit().getScreenSize() doesn't work for multi monitor setups
Point center = GraphicsEnvironment.getLocalGraphicsEnvironment().getCenterPoint();
Dimension frameSize = frame.getSize();
if (stateItems[0].equals("none") || stateItems.length < 5) {
frame.setLocation(center.x - frameSize.width / 2, center.y - frameSize.height / 2);
} else {
int x = Integer.parseInt(stateItems[0]);
int y = Integer.parseInt(stateItems[1]);
int width = Integer.parseInt(stateItems[2]);
int height = Integer.parseInt(stateItems[3]);
frame.setBounds(x, y, width, height);
// check bounds of saved NCL window and move within current device context if out of bounds
boolean inSceenArea = false;
for (GraphicsDevice gd :
GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()) {
for (GraphicsConfiguration graphicsConfiguration : gd.getConfigurations()) {
if (graphicsConfiguration.getBounds().outcode(x, y) == 0
|| graphicsConfiguration.getBounds().outcode(x + width, y + height) == 0) {
inSceenArea = true;
}
}
}
if (!inSceenArea) {
frame.setLocation(center.x - frameSize.width / 2, center.y - frameSize.height / 2);
}
// maximize if flagged
if (stateItems[4].equals("Max")) frame.setExtendedState(Frame.MAXIMIZED_BOTH);
}
frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
frame.addWindowListener(myWindowListener);
frame.addComponentListener(wsl);
// frame.setIconImage(Toolkit.getDefaultToolkit().getImage("graph.png"));
Image appIcon = null;
try {
appIcon = new ImageIcon(getClass().getResource("graph.png")).getImage();
} catch (Exception e) {
appIcon = frame.getIconImage();
}
frame.setIconImage(appIcon);
// frame.pack();
frame.setVisible(true);
frame.requestFocus();
}
/**
* 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);
}
}
/**
* Get the full screen size recognizing multiple monitor.
*
* @return full screen size
*/
public static Dimension getFullScreenSize() {
Rectangle2D result = new Rectangle2D.Double();
GraphicsEnvironment localGE = GraphicsEnvironment.getLocalGraphicsEnvironment();
for (GraphicsDevice gd : localGE.getScreenDevices()) {
for (GraphicsConfiguration graphicsConfiguration : gd.getConfigurations()) {
Rectangle2D.union(result, graphicsConfiguration.getBounds(), result);
}
}
return new Dimension((int) result.getWidth(), (int) result.getHeight());
}
/**
* Esta funcion recibe un modo y lo pone si es posible.
*
* @param dm Modo nuevo.
*/
public void cambiarModo(DisplayMode dm) {
try {
if (device.isDisplayChangeSupported()) {
device.setFullScreenWindow(getFullScreenWindow());
device.setDisplayMode(dm);
} else System.out.println("No se permite el cambio de resolucion");
} catch (IllegalArgumentException ex) {
System.out.println("Error de argumentos... No se ha podido poner a pantalla completa. ");
}
}
/** 将鼠标居中 */
public void mouseCenter() {
try {
GraphicsDevice device =
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
DisplayMode mode = device.getDisplayMode();
this.mouseX = this.lastMouseX = (mode.getWidth() / 2) - 10;
this.mouseY = this.lastMouseY = (mode.getHeight() / 2) - 10;
LSystem.RO_BOT.mouseMove(this.mouseX, this.mouseY);
} catch (Exception e) {
}
}
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();
}
public void toggleToFullscreen() {
GraphicsDevice device =
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
DisplayMode[] modes = device.getDisplayModes();
int i = 0; // note: there are usually several, let's pick the first
settings.setResolution(modes[i].getWidth(), modes[i].getHeight());
settings.setFrequency(modes[i].getRefreshRate());
settings.setDepthBits(modes[i].getBitDepth());
settings.setFullscreen(device.isFullScreenSupported());
restart();
}
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();
}
}