JDK 1.4 - Full Screen Exclusive Mode - WebStart - RMI
Jeg tænkte at jeg ville prøve nogen af de nye ting i 1.4, så jeg besluttede mig for at lave en spil.Mit problem er følgende.
Jeg har indtil vidre en JFrame (bare med et baggrundsbillede), og en JDialog der spg. brugeren om han vil hoste eller joine et spil. Hvis jeg kun laver min JFrame går det godt, den kommer i fuldscreen og den skifter til den rigtige opløsning. Hvis jeg tilføjer min JDialog er det ligesom om at den ikke opdatere grafikken.
Herudover køre der noget RMI, men det virker fint hvis jeg bare bruger system.out.
Jeg tror at det er noget med den repaint der er i full screen klassen. Eller kan det evt. være at jeg skal lave mit eget paint loop?
KODE FOR FULL SCREEN KLASSEN.
//*************************************************************************
// COPYRIGHT & LEGAL NOTICE
// This source code is copyright (c) 2001 Electric Funstuff, Inc.
// Non-commercial, private (personal) use is permitted.
//
// This file is not to be posted for public access or distributed
// in any form without prior written consent.
//
// The Author and Electric Funstuff, Inc. make no warranty of any kind, expressed or implied,
// with regard to this program. The Author and Electric Funstuff, Inc. shall not
// be liable in any event for incidental or consequential damages in
// connection with, or arising out of, the furnishing, performance, or
// use of this program.
//
// Please send us your comments at: feedback@electricfunstuff.com
//*************************************************************************
package dk.lyhr.game.gui;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
/**
* A class to encapsulate steps involved in manipulating the
* the graphical display for a program.
*
* Requires a Frame to work with. ScreenManager can work with applets
* if the applets create their own frame. Applets must have security access
* to use fullscreen mode.
*
* Usage:
* DisplayMode prefMode = new DisplayMode(640, 480, 32, -1);
* mgr = new ScreenManager(frame)
* mgr.setUndecorated(); // optional
* mgr.addPreferredDisplayMode(prefMode); // repeat as necessary
* mgr.init();
*/
public class ScreenManager
{
private GraphicsDevice currentDevice;
protected Vector preferredModeList = new Vector();
protected DisplayMode originalMode;
protected DisplayMode currentMode;
protected boolean forceFullScreen = true;
protected boolean undecorated = true;
protected Frame topLevelFrame;
//private boolean isFullScreen = false;
private DisplayMode[] modeList;
private boolean waiting = false;
private Object exitLock = new Object();
// has the display mode been changed?
private boolean displayModeChanged = false;
private ComponentListener moveListener;
private Point frameLocation;
//-----------------------------------------------------
// constructor
//-----------------------------------------------------
public ScreenManager(Frame f)
{
if(f == null) throw new IllegalArgumentException("Invalid frame passed to ScreenManager");
topLevelFrame = f;
frameLocation = f.getLocation();
moveListener =
new ComponentAdapter()
{
public void componentMoved(ComponentEvent ev)
{
Component comp = (Component) ev.getSource();
comp.setLocation(frameLocation.x, frameLocation.y);
}
};
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] devices = env.getScreenDevices();
currentDevice = devices[0];
originalMode = currentDevice.getDisplayMode();
// get all supported modes
modeList = currentDevice.getDisplayModes();
}
//-----------------------------------------------------
// accessors
//-----------------------------------------------------
/**
* this only applies to frames that will become full screen.
* otherwise it is ignored.
*/
public void setUndecorated()
{
undecorated = true;
}
public void setMovable(boolean tf)
{
//
if(!tf) topLevelFrame.addComponentListener(moveListener);
else topLevelFrame.removeComponentListener(moveListener);
}
//-----------------------------------------------------
//
//-----------------------------------------------------
/**
* add in order of preference
* most desirable first, etc.
* By indicating a display mode preference you are implicitly
* requesting fullscreen mode and a display change.
* display changes can only happen in fullscreen mode.
* If you want to fail-over into windowed mode,
* catch the Exception this will throw.
*/
public void addPreferredDisplayMode(DisplayMode mode)
{
if(!currentDevice.isFullScreenSupported())
throw new RuntimeException("Can't adjust display. Full screen mode is not supported by this display.");
forceFullScreen = true;
preferredModeList.add(mode);
}
public void init()
{
// does the application want to change modes?
// see if there are any preferences...
// (app MUST go fullscreen to change modes)
if(!preferredModeList.isEmpty())
{
// there's at least one preference on the list so
// see if we can support it
currentMode = getBestMode();
if(currentMode == null)
throw new RuntimeException("No suitable display mode found.");
// change modes
prepareFullScreenDisplay();
} else {
prepareWindowedDisplay();
}
// do any other init here
}
public void shutdown()
{
topLevelFrame.setVisible(false);
if(displayModeChanged) restoreDisplayMode();
topLevelFrame.dispose();
}
protected void prepareFullScreenDisplay()
{
try {
topLevelFrame.setResizable(false);
setMovable(false);
if(undecorated) topLevelFrame.setUndecorated(true);
currentDevice.setFullScreenWindow(topLevelFrame);
// TODO maximize frame
if(!currentDevice.isDisplayChangeSupported())
throw new RuntimeException("Graphics device doesn't support mode changing.");
currentDevice.setDisplayMode(currentMode);
displayModeChanged = true;
waitForExit();
} finally {
currentDevice.setFullScreenWindow(null);
}
}
// override for other behavior
protected void prepareWindowedDisplay()
{
topLevelFrame.pack();
topLevelFrame.setVisible(true);
topLevelFrame.setBounds(0,0,1024,768);
}
private DisplayMode getBestMode()
{
// find the best mode that is supported
// go through the preferred mode list starting at the top
Enumeration enum = preferredModeList.elements();
for( ; enum.hasMoreElements(); )
{
DisplayMode prefMode = (DisplayMode) enum.nextElement();
// see if this mode is on the list of supported modes
for(int i = 0; i < modeList.length; i++)
{
DisplayMode supportedMode = modeList[i];
if(canDisplay(prefMode, supportedMode))
{
// supported mode has the attributes we need
return supportedMode;
}
}
}
// haven't found any suitable modes so return null
return null;
}
/**
* does the supported mode have suitable display characteristics
*
* a preferred mode can specify a refresh rate of -1
* to indicate no preference.
* @return true if supported mode is acceptable
*/
private boolean canDisplay(DisplayMode prefMode, DisplayMode supMode)
{
if(prefMode.getWidth() == supMode.getWidth() &&
prefMode.getHeight() == supMode.getHeight() &&
prefMode.getBitDepth() == supMode.getBitDepth())
{
// the first 3 attributes match
if(prefMode.getRefreshRate() == -1) return true; // don't care about rate
if(prefMode.getRefreshRate() == supMode.getRefreshRate()) return true;
}
return false; // doesn't match
}
protected void waitForExit()
{
waiting = true;
topLevelFrame.repaint();
synchronized (exitLock) {
try {
exitLock.wait();
} catch (InterruptedException e) {}
}
}
protected void restoreDisplayMode()
{
if (waiting) {
synchronized(exitLock) {
exitLock.notifyAll();
}
waiting = false;
} else {
if (currentDevice.isDisplayChangeSupported() &&
!originalMode.equals(currentDevice.getDisplayMode())) {
currentDevice.setDisplayMode(originalMode);
}
}
}
} // ScreenManager
KODE FRA MIN MAIN:
.
.
.
this.mainGameFrame = new GameMainFrame();
ScreenManager mgr = new ScreenManager(this.mainGameFrame);
mgr.addPreferredDisplayMode(new DisplayMode(1024,768,32,-1));
mgr.addPreferredDisplayMode(new DisplayMode(1024,768,16,-1));
mgr.addPreferredDisplayMode(new DisplayMode(1024,768,8,-1));
mgr.init();
.
.
.
KODE FRA MIN JFRAME - CONSTRUCTOR
public class GameMainFrame extends javax.swing.JFrame {
private ConnectionDialog connectionDialog;
public GameMainFrame() {
initComponents();
this.connectionDialog = new ConnectionDialog(this, true);
}
