# setFullscreenWindow()-->Schwarzer Bildschirm



## Aiwendil (16. Jan 2010)

Hallo,

Ich habe volgendes  Problem bei dem ihr mir warscheinlichst helfen könnt:

Wenn ich ein Fenster (JFrame) mithilfe von setFullscreenWindow() in den "Vollildmodus" bringen will, wirrd einfach der gesamte Bilschirm schwarz. Lustigerweiße zeigt mir jedoch die Fensterpreview von Win7 alles richtig an und auch alle Buttons/andere Handler funktionieren (zb verändert sich die Maus wenn ich sie über eine (nicht zu sehende) JTextArrea bewege und auch mein Menu ist anklickbar ).

Achja ich verwende den "JavaEditor" und hab einfach hinter die Stelle an der die ganzen Frameeigenschaften definiert werden

```
setUndecorated(true);
setSize( Toolkit.getDefaultToolkit().getScreenSize());
gd.setFullScreenWindow(this);
```

geschrieben und 
	
	
	
	





```
GraphicsDevice[] devices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()[0];
```

dem Konstruktor der GUI übergeben (als "gd");

hier mal die wichtigsten codeteile:

```
public class GUI extends JFrame implements ActionListener, MouseListener, MouseMotionListener {
  // Anfang Attribute

  JMenuBar mbar = new JMenuBar();
  JMenu menu = new JMenu( "Datei" );
  JMenu spiel = new JMenu( "Spiel" );
  JMenuItem itemNext = new JMenuItem( "next()" );
  JMenuItem itemSchliesen = new JMenuItem( "Schließen" );
  JMenuItem itemSave = new JMenuItem( "SaveClkbrDaten" );
  JMenuItem itemNeustart = new JMenuItem( "Neustart" );

  
  private BrettPannel pnlSpielbrett = new BrettPannel();
  private SpAnzPannel[] pnlSpAnz = new SpAnzPannel[6];
  private pnlSpDran pnlDran;
  private JButton[] btnMission = new JButton[6];
  private JButton[] btnKarte = new JButton[6];
  private TextArea txaOut = new TextArea();
  private JScrollPane scrollingArea = new JScrollPane(txaOut);

  private Button btnNext = new Button();
  private JButton jButton1 = new JButton();


//Konstruktor
public GUI(GraphicsDevice pGd, String title) {   
    super(title);
    gd=pGd;

    init();

  }

 private void init() {

   

    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    int frameWidth = 1280;
    int frameHeight = 1024;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);

   if(isFs) {
     setUndecorated(true);
     setSize( Toolkit.getDefaultToolkit().getScreenSize());
     try {
      gd.setFullScreenWindow(this);
     } catch(Exception e) {
      System.out.println(e);      
     }

   }
    
    Container cp = getContentPane();
    cp.setLayout(null);
    
    
    // Anfang Komponenten
    
    // menü
    itemNeustart.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.ALT_MASK));
    itemNext.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_MASK));
    itemSchliesen.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Q, InputEvent.ALT_MASK ) );
    itemSchliesen.addActionListener(this);
    itemNeustart.addActionListener(this);
    itemSave.addActionListener(this);
    itemNext.addActionListener(this);
    
    spiel.add(itemNext);
    spiel.add(itemNeustart);
    menu.add(itemSchliesen);
    menu.add(itemSave);
    
    mbar.add(menu);
    mbar.add(spiel);
    setJMenuBar( mbar );
    // /menü

    pnlSpielbrett.setBounds(0, 0, 1000, 750);
    pnlSpielbrett.addMouseListener(this);
    pnlSpielbrett.addMouseMotionListener(this);
    pnlSpielbrett.setSoldaten(this.soldaten);
    pnlSpielbrett.setBgImage(this.karte);
    pnlSpielbrett.setClbBerCoords(clckBerCoords);
    pnlSpielbrett.setFarbenC(landerFarbenC);
    cp.add(pnlSpielbrett);
    
//hier kommen dan die ganzen anderen komponenten

    
    // Ende Komponenten


    setBackground(Color.lightGray);
    setResizable(false);
    validate();
    setVisible(true);
    



  }
```

und schonmal danke fürs durchlesen 

Gruß Aiwendil


----------



## lotus (16. Jan 2010)

Statt 
	
	
	
	





```
GraphicsDevice[] devices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()[0];
```

benutze ich 
	
	
	
	





```
GraphicsEnvironment.getLocalGraphicsEnvironment()
					.getDefaultScreenDevice()
```

weiß nicht ob das vllt einen Unterschied macht!


----------



## Aiwendil (16. Jan 2010)

tut mir leid aber das macht efektiv leider keinerlei Unterschied.....
achja und ich verwende natürlich 

```
GraphicsDevice[] devices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();
```

und übergeb dan dem Konstruktor der GUI

```
devices[0]
```


----------



## dayaftereh (16. Jan 2010)

Hey,

Ich habe mal eine klienes Spiel geschrieben.Ich habe hier mal die implemitirung von mir, schau es dir mal wie ich das mit GraphicsDevice mache, vielicht hilft es dir weite, bei mir kommt aus der Config, ob es Full Screen Modus oder Fenster modus ist!
Schau dir die Methode makeGUI() mal an und die Methode show(), ist nicht sauber Programmiert, normal sollte man die Show Methode nicht überschieben, aber das macht hier nix zu sache! aber auch die Methode getDisplayMode() ist wichtig!

```
package net.shipshoot.client.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;

import net.shipshoot.client.gui.control.GameFrameController;
import net.shipshoot.client.gui.pane.JConsole;
import net.shipshoot.client.gui.pane.MainMenu;
import net.shipshoot.client.instance.ObjektDao;
import net.shipshoot.client.runner.Client;
import net.shipshoot.client.tcp.send.SendScreenSize;
import net.shipshoot.client.util.ClientFactory;
import net.shipshoot.lib.model.Objekt;
import net.shipshoot.lib.model.PaintAble;
import net.shipshoot.lib.util.Config;
import net.shipshoot.lib.util.Util;
import net.shipshoot.lib.util.MainConfig;
import net.shipshoot.protocol.io.IOSession;
import net.shipshoot.protocol.model.IPacket;
import net.shipshoot.protocol.send.SendModelPacket;
import net.shipshoot.protocol.util.ProtocolFactory;

import org.apache.log4j.Logger;

public class GameFrame extends JPanel {

	private static final long serialVersionUID = -688051311618433062L;

	/** Die Instance fuer die Singolton */
	private static final GameFrame INSTANCE = new GameFrame();

	/** Logger um informationen mit zu Loggen */
	private Logger log = Logger.getLogger(GameFrame.class);

	/** Ob das Glass JPnale Schon benutzt wird oder nicht */
	private boolean glassPanelLock = false;

	/** Wenn das GameFrame im full Screen leuft */
	private boolean isFullScreen = false;

	/** Um eine Durschnitt frps rate zu berechnen */
	private int frpsIndex = 0;

	/** Liste mit alle frps */
	private long[] frps = new long[100];

	/** Der JFrame */
	private JFrame f = null;

	/** Die JConsole fuer die JTextArea zum Loggen */
	private JConsole console = null;

	/** Das Glass Pnael fuer Score + Map */
	private JPanel glassPanel = null;

	/** Die {@link IOSession} zum verschiechen von {@link IPacket} */
	private IOSession session = null;

	/** Das GrapicsDevise fuer den FullScreen */
	private GraphicsDevice gd = null;

	/** Der Controller fuer MVC */
	private GameFrameController gController = null;

	/** Das Main Menu um es anzuzeigen */
	private MainMenu mainMenu = null;
		
	/**
	 * Konstruktor - I <bR>
	 * Erzeugt das GameFrame fuer das Spiel
	 */
	private GameFrame() {
		/* Erzeugt den Controller MVC */
		gController = new GameFrameController(this);

		/* Setzt due GUI up */
		makeGUI();
	}

	private void makeGUI() {			
		gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();		
		f = new JFrame(gd.getDefaultConfiguration());

		f.setTitle("ShipShoot Client " + Client.VERSION + " : " + MainConfig.getInstance().getConfig().getProperty("last.play.name"));
		f.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
		f.setName("GameFrame");
		
		f.getContentPane().setLayout(new BorderLayout());
		f.setFocusTraversalKeysEnabled(false);

		addListeners();
		setMainPanelUP();

		f.getContentPane().add(this, BorderLayout.CENTER);

		console = new JConsole();
		f.getContentPane().add(console, BorderLayout.SOUTH);

		mainMenu = new MainMenu(this);

		Util.sleep(120);
	}

	/* ------------- repaint() ----------- */

	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);

		// ClientFactory.drawGrid(g, this.getWidth(), this.getHeight(), 25);

		drawObjekts(g);
		drawReadomObjekts(g);

		drawRenderStats(g);
	}

	private void drawRenderStats(Graphics g) {

		if (!MainConfig.getInstance().getConfig().getPropertyAsBoolean("render_stats")) {
			return;
		}

		FontMetrics m = g.getFontMetrics();

		g.setColor(Color.WHITE);
		g.setFont(ClientFactory.NORMAL_FONT);

		String frpPing = "Frps: " + getFrps() + " Ping: " + MainConfig.getInstance().getLatenz();
		g.drawString(frpPing, this.getWidth() / 2 - m.stringWidth(frpPing) / 2, this.getHeight() - m.getHeight() * 2);

		
		
		String position = "Position: " + ClientFactory.getPlayerPosition();
		g.drawString(position, this.getWidth() / 2 - m.stringWidth(position) / 2, this.getHeight() - m.getHeight());
	}

	/**
	 * Zeichnet alle Spiel Obejkte aus der objektMap auf das JPanel
	 * 
	 * @param g
	 *            - um zu zeichnen
	 */
	private void drawObjekts(Graphics g) {

		Map<Integer, Objekt> tmpMap = ObjektDao.getInstance().getGameObjekts();
		List<Objekt> ob = null;
		synchronized (tmpMap) {
			ob = new ArrayList<Objekt>(tmpMap.values());
		}
		Collections.sort(ob);
		for (Objekt objekt : ob) {
			if (objekt == null) {
				continue;
			}

			objekt.paintObjekt(g);
		}

		tmpMap = ObjektDao.getInstance().getTempObjekts();
		
		synchronized (tmpMap) {
			ob = new ArrayList<Objekt>(tmpMap.values());
		}

		for (Objekt objekt : ob) {
			if (objekt == null) {
				continue;
			}

			objekt.paintObjekt(g);
		}

	}

	/**
	 * Zeichnet alle ReadomObjekts aus der Liste auf das JPanel
	 * 
	 * @param g
	 *            - um zu zeichnen
	 */
	private void drawReadomObjekts(Graphics g) {
		List<Objekt> readomObjekts = ObjektDao.getInstance().getReadomObjekts();

		for (int i = 0; i < readomObjekts.size(); i++) {

			PaintAble<Objekt> objekt = readomObjekts.get(i);

			if (objekt == null) {
				continue;
			}
			objekt.paintObjekt(g);
		}

	}

	/* ------------- Handlers ---------------- */

	/**
	 * Wenn die greosse des JPanels veraendert wird, schickt er die neue groesse
	 * an den Server
	 */
	public void resizeJPanel() {

		Dimension d = new Dimension(this.getWidth(), this.getHeight());		
		Util.getMainConfig().setPropertyAsInt("display_mode_width", this.getWidth());
		Util.getMainConfig().setPropertyAsInt("display_mode_height", this.getHeight());

		if (session != null) {
			Util.sendData(new SendScreenSize(d.width, d.height, session));
		}

		log.info("JPanel.Dimension[width=" + d.width + ",height=" + d.height + "]");
	}

	/**
	 * Wenn Tab gedrueck wird, um die Socre zu bekommen
	 */
	public void sendNeedScore() {
		if (session != null) {
			Util.sendData(new SendModelPacket(ProtocolFactory.NEED_SCORE, 0, session));
		}
	}

	/**
	 * wenn M gedrueck wierd um die MiniMap zu bekommen
	 */
	public void sendNeedMiniMap() {
		if (session != null) {
			Util.sendData(new SendModelPacket(ProtocolFactory.NEED_MINI_MAP, 0, session));
		}
	}

	/**
	 * Raumt das glassePanel auf
	 */
	public void clearGlassPanel() {
		glassPanel.removeAll();
		glassPanelLock = false;
		glassPanel.setVisible(false);
		f.requestFocus();
	}

	/**
	 * Schliesst den JFrame
	 */
	public void close() {			
		if(f != null && f.isVisible()){												
			f.setVisible(false);
			//f.dispose();
		}		
	}

	/**
	 * Oeffnet die Map
	 */
	public void openMap() {

		if (mainMenu.isVisible()) {
			return;
		}

		if (!gController.map) {
			gController.map = !gController.map;
			sendNeedMiniMap();
		}
	}

	/**
	 * Schliesst die Map wieder
	 */
	public void closeMap() {

		if (mainMenu.isVisible()) {
			return;
		}

		if (gController.map) {
			gController.map = !gController.map;
			clearGlassPanel();
		}
	}

	/**
	 * Oeffnet das ScoreBoard
	 */
	public void openScore() {
		if (mainMenu.isVisible()) {
			return;
		}

		if (!gController.tab) {
			gController.tab = !gController.tab;
			sendNeedScore();
		}
	}

	/**
	 * Schliesst das ScoreBoard
	 */
	public void closeScore() {
		if (mainMenu.isVisible()) {
			return;
		}

		if (gController.tab) {
			gController.tab = !gController.tab;
			clearGlassPanel();
		}
	}

	/*------------- Getter / Setter -----------*/

	public void setSession(IOSession session) {
		this.session = session;
	}

	public boolean isLeft() {
		return gController.left;
	}

	public boolean isRigth() {
		return gController.rigth;
	}

	public boolean isUp() {
		return gController.up;
	}

	public boolean isDown() {
		return gController.down;
	}

	public boolean isFire() {
		return gController.fire;
	}

	public boolean isTab() {
		return gController.tab;
	}

	public boolean isMap() {
		return gController.map;
	}

	public void setFire(boolean b) {
		gController.fire = b;
	}

	private long getFrps() {
		long d = 0;
		for (int i = 0; i < frps.length; i++) {
			d += frps[i];
		}
		return (int) (d / (frps.length - 1));
	}

	/**
	 * Fuegt auf das GlassPanel eine {@link JComponent} hinzu
	 * 
	 * @param com
	 *            - die {@link JComponent}
	 */
	public void addComponent(JComponent com) {

		if (glassPanelLock) {
			return;
		}

		glassPanelLock = true;

		GridBagConstraints c = new GridBagConstraints();
		c.gridx = 0;
		c.gridy = 0;
		c.fill = GridBagConstraints.NONE;

		glassPanel.add(com, c);
		glassPanel.setPreferredSize(com.getPreferredSize());
		glassPanel.setVisible(true);

		validateGlassPanel();
	}

	/**
	 * Zeichnet das GlassPanel neu
	 */
	public void validateGlassPanel() {
		glassPanel.validate();
		glassPanel.repaint();
		f.requestFocus();
	}

	/* --------- Util ----------- */

	/**
	 * Addet alle Liseners
	 */
	private void addListeners() {
		f.addKeyListener(gController);
		f.addFocusListener(gController);
		f.addMouseListener(gController);
		f.addWindowListener(gController);
		this.addComponentListener(gController);
	}

	/**
	 * Setzt das Main JPanel up, unf fuegt das glassPanel hinzu
	 */
	private void setMainPanelUP() {
		this.setLayout(new BorderLayout());
		this.setBackground(Color.black);
		this.setPreferredSize(getScreenSize());

		glassPanel = new JPanel();
		glassPanel.setLayout(new GridBagLayout());
		glassPanel.setFocusable(false);
		glassPanel.setOpaque(false);
		glassPanel.setVisible(false);

		this.add(glassPanel, BorderLayout.CENTER);
	}

	/**
	 * Addet ein neue Frp in die list um besser die Frps zu berechnen
	 * 
	 * @param frp
	 *            - der Neue frps
	 */
	public void addFrp(long frp) {
		if (frpsIndex < frps.length - 1) {
			frpsIndex++;
		} else {
			frpsIndex = 0;
		}
		frps[frpsIndex] = frp;
	}

	/**
	 * Gibt die Instance von {@link GameFrame} zuruck, wegen Singolton
	 * 
	 * @return - das einzige {@link GameFrame}
	 */
	public static GameFrame getInstance() {
		return INSTANCE;
	}

	@Override
	public void show() {

		/* prueft od full screnn mode an ist */
		isFullScreen = MainConfig.getInstance().getConfig().getPropertyAsBoolean("display_full_screen");

		if (isFullScreen) {
			// pruft ob full screen Supported ist
			isFullScreen = gd.isFullScreenSupported();
		}
		
		/* Setzt das Frame auf die Einstellungen */

		f.setUndecorated(isFullScreen);
		f.setResizable(!isFullScreen);
		f.setIgnoreRepaint(isFullScreen);

		if (isFullScreen) {				
			gd.setFullScreenWindow(f);				
			gd.setDisplayMode(getDisplayMode());
		} else {
			f.pack();
			f.setLocationRelativeTo(null);
			f.setVisible(true);
		}
	}

	/**
	 * Oeffnet das MainMenu und schliesstes auch wieder
	 */
	public void doMainMenu() {
		if (mainMenu.isVisible()) {
			mainMenu.setVisible(false);
			mainMenu.clearMenu();
			clearGlassPanel();
		} else {
			if (glassPanelLock == false) {
				mainMenu.setVisible(true);
				addComponent(mainMenu);
			}
		}
	}

	/**
	 * Liest aus der config die Screen groesse und gibt sie zurueck.
	 * 
	 * @return die Screen groesse als {@link Dimension}
	 */
	private Dimension getScreenSize() {
		Config config = MainConfig.getInstance().getConfig();

		int width = 800;
		int height = 600;

		try {
			width = config.getPropertyAsInt("display_mode_width");
			height = config.getPropertyAsInt("display_mode_height");
		} catch (Exception e) {
			log.error(e);
		}

		return new Dimension(width, height);
	}

	/**
	 * Hold sie aus der Config das {@link DisplayMode} unf gibt es zurueck
	 * 
	 * @return das {@link DisplayMode}
	 */
	private DisplayMode getDisplayMode() {
		Config config = MainConfig.getInstance().getConfig();
		Dimension d = getScreenSize();
		int depth = 16;

		try {

			depth = config.getPropertyAsInt("display_color_depth");
		} catch (Exception e) {
			log.error(e);
		}

		return new DisplayMode(d.width, d.height, depth, DisplayMode.REFRESH_RATE_UNKNOWN);
	}
}
```


----------



## Aiwendil (16. Jan 2010)

@dayaftereh:
ersma thx für die Antwort,

ich hab mir mal deine show() gelkaut und minimals verändert:


```
public void show() {

        /* prueft ob full screnn mode an ist */


        if (isFullScreen) {
            // pruft ob full screen Supported ist
            isFullScreen = gd.isFullScreenSupported();
        }

        /* Setzt das Frame auf die Einstellungen */

        setUndecorated(isFullScreen);
        setResizable(!isFullScreen);
        setIgnoreRepaint(isFullScreen);
        System.out.println(isFullScreen);
        if (isFullScreen) {
            gd.setFullScreenWindow(this);
            gd.setDisplayMode(new DisplayMode(1280,1024,32,DisplayMode.REFRESH_RATE_UNKNOWN));
        } else {
            pack();
            setLocationRelativeTo(null);
            setVisible(true);
        }
  }
```

und jetzt wird auch endlich der Displaymode richtig gesetzt. Nur wird mein JFrame ienfach nicht angezeigt.... d.h. jetzt wird einfach der Desktop mit dem neuen DM angezeigt.

Kannst du mir vlt erklären was den die "show()" genau macht?


----------



## Aiwendil (16. Jan 2010)

Ich hab mir jetzt mal aus verzweiflung ne Beispielbrog gezogen und das entsprechend umgebaut; wodurch ich das Problem teilweiße einschränlen konnte (das teilweiße kommt daher das ich jetzt noch mer verwirrt bin als ihc davor schon war).

ich hab das GUI so eingerichtet, dass es eine eigene "main()" hat (ist zum ARbeiten mit dem "JavaEditor" einfacher). Wenn ich jetzt nur die GUI-klasse ausführen lasse (also die "main()" aus der GUI-Klasse verwende) dan funktioniert die Darstellung. Wen ich jetzt aber aus dem Steuerprogramm herraus ein neues GUI erstelle bekomme ich wieder den bereits erwänten Blackscreen.
Hier mal der Code:

die main() der GUI-KLasse:


```
public static void main(String[] args) {
        GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
        GraphicsDevice[] devices = env.getScreenDevices();
             GUI gui = new GUI(devices[0]);
             gui.begin();
}
```

der Aufruf durch die Steuerklasse:


```
private void guiMaker() {      
     GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
     GraphicsDevice[] devices = env.getScreenDevices();        
     gui = new GUI(devices[0]);
     gui.begin();
}
```


der aufgerufene Konstruktor:


```
public GUI(GraphicsDevice pGd) {
   super(pGd.getDefaultConfiguration());
      this.gd = pGd;
      originalDM = gd.getDisplayMode();
      setDefaultCloseOperation(EXIT_ON_CLOSE);
 }
```

und die hinterher aufgerufene Funktion begin():


```
public void begin() {
        isFullScreen = gd.isFullScreenSupported();
        setUndecorated(isFullScreen);
        setResizable(!isFullScreen);
        if (isFullScreen) {
            gd.setFullScreenWindow(this);
            gd.setDisplayMode(new DisplayMode(1280,1024,32,DisplayMode.REFRESH_RATE_UNKNOWN));
            validate();
        } else {
            pack();
            setVisible(true);
        }
        init();
  }
```

irgendwie verwirrt mich das....:shock:

Ich hoffe irgendwer hier kann mir helfen!


----------



## dayaftereh (17. Jan 2010)

Hey, also was versuchst du? einen JFrame zu erstellen der als Full Screen angezeigt wird und daraus mit einem Button wieder einen JFrame erzugen, oder wie?

Also ich habe deine Sache mal probiert! hier meine code:

```
import java.awt.DisplayMode;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;

import javax.swing.JFrame;

public class Test extends JFrame {

	private static final long serialVersionUID = -5045938544478468785L;
	private GraphicsDevice gd;
	private DisplayMode originalDM;
	private boolean isFullScreen;

	public Test(GraphicsDevice device) {
		super(device.getDefaultConfiguration());
		this.gd = device;
		originalDM = gd.getDisplayMode();
		setDefaultCloseOperation(EXIT_ON_CLOSE);

	}

	public void begin() {
		isFullScreen = gd.isFullScreenSupported();
		setUndecorated(isFullScreen);
		setResizable(!isFullScreen);
		if (isFullScreen) {
			gd.setFullScreenWindow(this);
			gd.setDisplayMode(new DisplayMode(1280, 1024, 32,DisplayMode.REFRESH_RATE_UNKNOWN));
			validate();
		} else {
			pack();
			setVisible(true);
		}

	}

	public static void main(String[] args) {
		GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
		GraphicsDevice[] devices = env.getScreenDevices();
		Test test = new Test(devices[0]);
		test.begin();
	
	}

}
```
Und es Klappt, ich bekomme einen Grauen Bildschirmm! erkläre nochmal dein Problem? hoffe ich konnte helfen!


----------



## Aiwendil (17. Jan 2010)

mein Problem ist folgendes:
ich erstelle gerade Risiko (das Brettspiel) für die Schule. Dabei verwend ich etliche Datenklassen eine Steuerklasse und eine Guiklasse (mit einigen Abgeleiteten Komponenten), dach dem vereinfachten 5-schicht Model bei uns in der Schule heißt das 3Schicht Architektur. So und jetzt versuch ich das Gui im Follbildmodus anzuzeigen, was mir auf meinem Rechner(win7 64) nicht gelingt. Auf 2 anderen Systemen scheint es zu funktionieren (ein Linux und XP). 
zum Code:

1. Die GUI-Klasse die von JFrame abgeleitet ist. Ihr Konstruktor:


```
public GUI(GraphicsDevice pGd) {
   super(pGd.getDefaultConfiguration());
      this.gd = pGd;
      originalDM = gd.getDisplayMode();
      setDefaultCloseOperation(EXIT_ON_CLOSE);   
 mRisiko = new Mrisiko(this);
 }
```

2. Die Steuerklasse MRisiko:


```
public MRisiko(GUI pGui) {
   System.out.println("MRisiko Konstruktor mit pGUI");
   this.gui=pGui;
   init();
 }
```
in init() werden jetzt über ein eigenes Frame nochmal n paar Daten abgefragt und dann werden meine ganzen Datenklassen initialisiert. 

Am Ende wird dan init() vom GUI aufgerufen das sämtliche Componenten auf das Frame knallt und die mir das Frame ersma normal im "windowed-mode" anzeigt.

Jetzt kann ich (über einen Menüeintrag) die Methode begin() aufrufen die mir eben dieses Frame in den Follbildmodus bringen soll:


```
public void actionPerformed( ActionEvent e )  {  
   if(e.getSource()==itemFS){
     this.isFullScreen=(!this.isFullScreen);
     begin();
     repaint();
   }
}

public void begin() {  
     this.dispose();
        setUndecorated(isFullScreen);
        setResizable(!isFullScreen);
        if (this.isFullScreen) {
         System.out.println("fullscreen mode");
            gd.setFullScreenWindow(this);
            gd.setDisplayMode(new DisplayMode(1280,1024,32,DisplayMode.REFRESH_RATE_UNKNOWN));
            validate();
        } else {
         System.out.println("windowed mode");
          int frameWidth = 1280;
          int frameHeight = 1024;
          setSize(frameWidth, frameHeight);
          Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
          int x = (d.width - getSize().width) / 2;
          int y = (d.height - getSize().height) / 2;
          setLocation(x, y);
          setVisible(true);
        }

    this.show();

  }
```

wenn ich das jetzt ausführe geht das Frame auch irgendwie in den Follbildmodus und auch der DisplayMode richtig gesetzt (sehe ich daran das der Mauscourser großer wird) allerdings seh ihc halt einfach nur Schwarz.


[edit]ich hab das grade alles umgebaut deshalb sind einige bezeihcner etwas irreführend und ja ich weis das das was ich hier fabrizier schlechter Stil ist[/edit]


----------



## Aiwendil (17. Jan 2010)

solangsam glaub ihc das Win7 schuld ist
bei nem Anderen Kumpel mit nem baugleichen rechner wie ich läuft auf Vista alles glatt


----------



## dayaftereh (17. Jan 2010)

Hey, versuche das mal: obd das bei dir Klappt! also bei meine Win Vista 64 gehts:

```
import java.awt.EventQueue;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;

import javax.swing.JFrame;

public class FullScreenTest {

	private GraphicsDevice gd;

	private boolean isFullScreen;

	private JFrame f = null;

	public FullScreenTest() {
		buildGUI();
	}

	private void buildGUI() {
		gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
		f = new JFrame(gd.getDefaultConfiguration());
	}

	public void show() {
		if (EventQueue.isDispatchThread()) {
			isFullScreen = gd.isFullScreenSupported();
			f.setUndecorated(isFullScreen);
			f.setResizable(!isFullScreen);
			if (isFullScreen) {
				gd.setFullScreenWindow(f);
				gd.setDisplayMode(gd.getDisplayMode());
				f.validate();
			} else {
				f.pack();
				f.setVisible(true);
			}
		} else {
			EventQueue.invokeLater(new Runnable() {
				public void run() {
					show();
				}
			});
		}
	}
	
	public static void main(String[] args) {
		FullScreenTest test = new FullScreenTest();
		test.show();
	}
}
```


----------



## Aiwendil (18. Jan 2010)

Jap das geht. Ich hab ja auch sonst kaum Probleme mit dem FSEM nur halt in genau diesem Programm und einigen Beispielprogrammen. Generell gesehen krieg ihc den aber shcon zum laufen das is ja das sonderbare....


----------

