setFullscreenWindow()-->Schwarzer Bildschirm

AWT, Swing, JavaFX & SWT: setFullscreenWindow()-->Schwarzer Bildschirm



Erstellt von Aiwendil  |  Antworten: 10

  1. #1
    Aiwendil


    setFullscreenWindow()-->Schwarzer Bildschirm
    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
    Java Code:
    1.  
    2. setUndecorated(true);
    3. setSize( Toolkit.getDefaultToolkit().getScreenSize());
    4. gd.setFullScreenWindow(this);


    geschrieben und
    Java Code:
    1. GraphicsDevice[] devices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()[0];


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

    hier mal die wichtigsten codeteile:
    Java Code:
    1.  
    2. public class GUI extends JFrame implements ActionListener, MouseListener, MouseMotionListener {
    3. // Anfang Attribute
    4.  
    5. JMenuBar mbar = new JMenuBar();
    6. JMenu menu = new JMenu( "Datei" );
    7. JMenu spiel = new JMenu( "Spiel" );
    8. JMenuItem itemNext = new JMenuItem( "next()" );
    9. JMenuItem itemSchliesen = new JMenuItem( "Schließen" );
    10. JMenuItem itemSave = new JMenuItem( "SaveClkbrDaten" );
    11. JMenuItem itemNeustart = new JMenuItem( "Neustart" );
    12.  
    13.  
    14. private BrettPannel pnlSpielbrett = new BrettPannel();
    15. private SpAnzPannel[] pnlSpAnz = new SpAnzPannel[6];
    16. private pnlSpDran pnlDran;
    17. private JButton[] btnMission = new JButton[6];
    18. private JButton[] btnKarte = new JButton[6];
    19. private TextArea txaOut = new TextArea();
    20. private JScrollPane scrollingArea = new JScrollPane(txaOut);
    21.  
    22. private Button btnNext = new Button();
    23. private JButton jButton1 = new JButton();
    24.  
    25.  
    26. //Konstruktor
    27. public GUI(GraphicsDevice pGd, String title) {
    28. super(title);
    29. gd=pGd;
    30.  
    31. init();
    32.  
    33. }
    34.  
    35. private void init() {
    36.  
    37.  
    38.  
    39. setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    40. int frameWidth = 1280;
    41. int frameHeight = 1024;
    42. setSize(frameWidth, frameHeight);
    43. Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    44. int x = (d.width - getSize().width) / 2;
    45. int y = (d.height - getSize().height) / 2;
    46. setLocation(x, y);
    47.  
    48. if(isFs) {
    49. setUndecorated(true);
    50. setSize( Toolkit.getDefaultToolkit().getScreenSize());
    51. try {
    52. gd.setFullScreenWindow(this);
    53. } catch(Exception e) {
    54. System.out.println(e);
    55. }
    56.  
    57. }
    58.  
    59. Container cp = getContentPane();
    60. cp.setLayout(null);
    61.  
    62.  
    63. // Anfang Komponenten
    64.  
    65. // menü
    66. itemNeustart.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.ALT_MASK));
    67. itemNext.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_MASK));
    68. itemSchliesen.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Q, InputEvent.ALT_MASK ) );
    69. itemSchliesen.addActionListener(this);
    70. itemNeustart.addActionListener(this);
    71. itemSave.addActionListener(this);
    72. itemNext.addActionListener(this);
    73.  
    74. spiel.add(itemNext);
    75. spiel.add(itemNeustart);
    76. menu.add(itemSchliesen);
    77. menu.add(itemSave);
    78.  
    79. mbar.add(menu);
    80. mbar.add(spiel);
    81. setJMenuBar( mbar );
    82. // /menü
    83.  
    84. pnlSpielbrett.setBounds(0, 0, 1000, 750);
    85. pnlSpielbrett.addMouseListener(this);
    86. pnlSpielbrett.addMouseMotionListener(this);
    87. pnlSpielbrett.setSoldaten(this.soldaten);
    88. pnlSpielbrett.setBgImage(this.karte);
    89. pnlSpielbrett.setClbBerCoords(clckBerCoords);
    90. pnlSpielbrett.setFarbenC(landerFarbenC);
    91. cp.add(pnlSpielbrett);
    92.  
    93. //hier kommen dan die ganzen anderen komponenten
    94.  
    95.  
    96. // Ende Komponenten
    97.  
    98.  
    99. setBackground(Color.lightGray);
    100. setResizable(false);
    101. validate();
    102. setVisible(true);
    103.  
    104.  
    105.  
    106.  
    107. }


    und schonmal danke fürs durchlesen

    Gruß Aiwendil

  2. #2
    lotus


    Statt
    Java Code:
    1. GraphicsDevice[] devices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()[0];


    benutze ich
    Java Code:
    1. GraphicsEnvironment.getLocalGraphicsEnvironment()
    2. .getDefaultScreenDevice()


    weiß nicht ob das vllt einen Unterschied macht!

  3. #3
    Aiwendil


    tut mir leid aber das macht efektiv leider keinerlei Unterschied.....
    achja und ich verwende natürlich
    Java Code:
    1. GraphicsDevice[] devices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();


    und übergeb dan dem Konstruktor der GUI
    Java Code:
    1. devices[0]

  4. #4
    dayaftereh


    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!
    Java Code:
    1.  
    2. package net.shipshoot.client.gui;
    3.  
    4. import java.awt.BorderLayout;
    5. import java.awt.Color;
    6. import java.awt.Dimension;
    7. import java.awt.DisplayMode;
    8. import java.awt.FontMetrics;
    9. import java.awt.Graphics;
    10. import java.awt.GraphicsDevice;
    11. import java.awt.GraphicsEnvironment;
    12. import java.awt.GridBagConstraints;
    13. import java.awt.GridBagLayout;
    14. import java.util.ArrayList;
    15. import java.util.Collections;
    16. import java.util.List;
    17. import java.util.Map;
    18.  
    19. import javax.swing.JComponent;
    20. import javax.swing.JFrame;
    21. import javax.swing.JPanel;
    22.  
    23. import net.shipshoot.client.gui.control.GameFrameController;
    24. import net.shipshoot.client.gui.pane.JConsole;
    25. import net.shipshoot.client.gui.pane.MainMenu;
    26. import net.shipshoot.client.instance.ObjektDao;
    27. import net.shipshoot.client.runner.Client;
    28. import net.shipshoot.client.tcp.send.SendScreenSize;
    29. import net.shipshoot.client.util.ClientFactory;
    30. import net.shipshoot.lib.model.Objekt;
    31. import net.shipshoot.lib.model.PaintAble;
    32. import net.shipshoot.lib.util.Config;
    33. import net.shipshoot.lib.util.Util;
    34. import net.shipshoot.lib.util.MainConfig;
    35. import net.shipshoot.protocol.io.IOSession;
    36. import net.shipshoot.protocol.model.IPacket;
    37. import net.shipshoot.protocol.send.SendModelPacket;
    38. import net.shipshoot.protocol.util.ProtocolFactory;
    39.  
    40. import org.apache.log4j.Logger;
    41.  
    42. public class GameFrame extends JPanel {
    43.  
    44. private static final long serialVersionUID = -688051311618433062L;
    45.  
    46. /** Die Instance fuer die Singolton */
    47. private static final GameFrame INSTANCE = new GameFrame();
    48.  
    49. /** Logger um informationen mit zu Loggen */
    50. private Logger log = Logger.getLogger(GameFrame.class);
    51.  
    52. /** Ob das Glass JPnale Schon benutzt wird oder nicht */
    53. private boolean glassPanelLock = false;
    54.  
    55. /** Wenn das GameFrame im full Screen leuft */
    56. private boolean isFullScreen = false;
    57.  
    58. /** Um eine Durschnitt frps rate zu berechnen */
    59. private int frpsIndex = 0;
    60.  
    61. /** Liste mit alle frps */
    62. private long[] frps = new long[100];
    63.  
    64. /** Der JFrame */
    65. private JFrame f = null;
    66.  
    67. /** Die JConsole fuer die JTextArea zum Loggen */
    68. private JConsole console = null;
    69.  
    70. /** Das Glass Pnael fuer Score + Map */
    71. private JPanel glassPanel = null;
    72.  
    73. /** Die {@link IOSession} zum verschiechen von {@link IPacket} */
    74. private IOSession session = null;
    75.  
    76. /** Das GrapicsDevise fuer den FullScreen */
    77. private GraphicsDevice gd = null;
    78.  
    79. /** Der Controller fuer MVC */
    80. private GameFrameController gController = null;
    81.  
    82. /** Das Main Menu um es anzuzeigen */
    83. private MainMenu mainMenu = null;
    84.  
    85. /**
    86. * Konstruktor - I <bR>
    87. * Erzeugt das GameFrame fuer das Spiel
    88. */
    89. private GameFrame() {
    90. /* Erzeugt den Controller MVC */
    91. gController = new GameFrameController(this);
    92.  
    93. /* Setzt due GUI up */
    94. makeGUI();
    95. }
    96.  
    97. private void makeGUI() {
    98. gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
    99. f = new JFrame(gd.getDefaultConfiguration());
    100.  
    101. f.setTitle("ShipShoot Client " + Client.VERSION + " : " + MainConfig.getInstance().getConfig().getProperty("last.play.name"));
    102. f.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
    103. f.setName("GameFrame");
    104.  
    105. f.getContentPane().setLayout(new BorderLayout());
    106. f.setFocusTraversalKeysEnabled(false);
    107.  
    108. addListeners();
    109. setMainPanelUP();
    110.  
    111. f.getContentPane().add(this, BorderLayout.CENTER);
    112.  
    113. console = new JConsole();
    114. f.getContentPane().add(console, BorderLayout.SOUTH);
    115.  
    116. mainMenu = new MainMenu(this);
    117.  
    118. Util.sleep(120);
    119. }
    120.  
    121. /* ------------- repaint() ----------- */
    122.  
    123. @Override
    124. protected void paintComponent(Graphics g) {
    125. super.paintComponent(g);
    126.  
    127. // ClientFactory.drawGrid(g, this.getWidth(), this.getHeight(), 25);
    128.  
    129. drawObjekts(g);
    130. drawReadomObjekts(g);
    131.  
    132. drawRenderStats(g);
    133. }
    134.  
    135. private void drawRenderStats(Graphics g) {
    136.  
    137. if (!MainConfig.getInstance().getConfig().getPropertyAsBoolean("render_stats")) {
    138. return;
    139. }
    140.  
    141. FontMetrics m = g.getFontMetrics();
    142.  
    143. g.setColor(Color.WHITE);
    144. g.setFont(ClientFactory.NORMAL_FONT);
    145.  
    146. String frpPing = "Frps: " + getFrps() + " Ping: " + MainConfig.getInstance().getLatenz();
    147. g.drawString(frpPing, this.getWidth() / 2 - m.stringWidth(frpPing) / 2, this.getHeight() - m.getHeight() * 2);
    148.  
    149.  
    150.  
    151. String position = "Position: " + ClientFactory.getPlayerPosition();
    152. g.drawString(position, this.getWidth() / 2 - m.stringWidth(position) / 2, this.getHeight() - m.getHeight());
    153. }
    154.  
    155. /**
    156. * Zeichnet alle Spiel Obejkte aus der objektMap auf das JPanel
    157. *
    158. * @param g
    159. * - um zu zeichnen
    160. */
    161. private void drawObjekts(Graphics g) {
    162.  
    163. Map<Integer, Objekt> tmpMap = ObjektDao.getInstance().getGameObjekts();
    164. List<Objekt> ob = null;
    165. synchronized (tmpMap) {
    166. ob = new ArrayList<Objekt>(tmpMap.values());
    167. }
    168. Collections.sort(ob);
    169. for (Objekt objekt : ob) {
    170. if (objekt == null) {
    171. continue;
    172. }
    173.  
    174. objekt.paintObjekt(g);
    175. }
    176.  
    177. tmpMap = ObjektDao.getInstance().getTempObjekts();
    178.  
    179. synchronized (tmpMap) {
    180. ob = new ArrayList<Objekt>(tmpMap.values());
    181. }
    182.  
    183. for (Objekt objekt : ob) {
    184. if (objekt == null) {
    185. continue;
    186. }
    187.  
    188. objekt.paintObjekt(g);
    189. }
    190.  
    191. }
    192.  
    193. /**
    194. * Zeichnet alle ReadomObjekts aus der Liste auf das JPanel
    195. *
    196. * @param g
    197. * - um zu zeichnen
    198. */
    199. private void drawReadomObjekts(Graphics g) {
    200. List<Objekt> readomObjekts = ObjektDao.getInstance().getReadomObjekts();
    201.  
    202. for (int i = 0; i < readomObjekts.size(); i++) {
    203.  
    204. PaintAble<Objekt> objekt = readomObjekts.get(i);
    205.  
    206. if (objekt == null) {
    207. continue;
    208. }
    209. objekt.paintObjekt(g);
    210. }
    211.  
    212. }
    213.  
    214. /* ------------- Handlers ---------------- */
    215.  
    216. /**
    217. * Wenn die greosse des JPanels veraendert wird, schickt er die neue groesse
    218. * an den Server
    219. */
    220. public void resizeJPanel() {
    221.  
    222. Dimension d = new Dimension(this.getWidth(), this.getHeight());
    223. Util.getMainConfig().setPropertyAsInt("display_mode_width", this.getWidth());
    224. Util.getMainConfig().setPropertyAsInt("display_mode_height", this.getHeight());
    225.  
    226. if (session != null) {
    227. Util.sendData(new SendScreenSize(d.width, d.height, session));
    228. }
    229.  
    230. log.info("JPanel.Dimension[width=" + d.width + ",height=" + d.height + "]");
    231. }
    232.  
    233. /**
    234. * Wenn Tab gedrueck wird, um die Socre zu bekommen
    235. */
    236. public void sendNeedScore() {
    237. if (session != null) {
    238. Util.sendData(new SendModelPacket(ProtocolFactory.NEED_SCORE, 0, session));
    239. }
    240. }
    241.  
    242. /**
    243. * wenn M gedrueck wierd um die MiniMap zu bekommen
    244. */
    245. public void sendNeedMiniMap() {
    246. if (session != null) {
    247. Util.sendData(new SendModelPacket(ProtocolFactory.NEED_MINI_MAP, 0, session));
    248. }
    249. }
    250.  
    251. /**
    252. * Raumt das glassePanel auf
    253. */
    254. public void clearGlassPanel() {
    255. glassPanel.removeAll();
    256. glassPanelLock = false;
    257. glassPanel.setVisible(false);
    258. f.requestFocus();
    259. }
    260.  
    261. /**
    262. * Schliesst den JFrame
    263. */
    264. public void close() {
    265. if(f != null && f.isVisible()){
    266. f.setVisible(false);
    267. //f.dispose();
    268. }
    269. }
    270.  
    271. /**
    272. * Oeffnet die Map
    273. */
    274. public void openMap() {
    275.  
    276. if (mainMenu.isVisible()) {
    277. return;
    278. }
    279.  
    280. if (!gController.map) {
    281. gController.map = !gController.map;
    282. sendNeedMiniMap();
    283. }
    284. }
    285.  
    286. /**
    287. * Schliesst die Map wieder
    288. */
    289. public void closeMap() {
    290.  
    291. if (mainMenu.isVisible()) {
    292. return;
    293. }
    294.  
    295. if (gController.map) {
    296. gController.map = !gController.map;
    297. clearGlassPanel();
    298. }
    299. }
    300.  
    301. /**
    302. * Oeffnet das ScoreBoard
    303. */
    304. public void openScore() {
    305. if (mainMenu.isVisible()) {
    306. return;
    307. }
    308.  
    309. if (!gController.tab) {
    310. gController.tab = !gController.tab;
    311. sendNeedScore();
    312. }
    313. }
    314.  
    315. /**
    316. * Schliesst das ScoreBoard
    317. */
    318. public void closeScore() {
    319. if (mainMenu.isVisible()) {
    320. return;
    321. }
    322.  
    323. if (gController.tab) {
    324. gController.tab = !gController.tab;
    325. clearGlassPanel();
    326. }
    327. }
    328.  
    329. /*------------- Getter / Setter -----------*/
    330.  
    331. public void setSession(IOSession session) {
    332. this.session = session;
    333. }
    334.  
    335. public boolean isLeft() {
    336. return gController.left;
    337. }
    338.  
    339. public boolean isRigth() {
    340. return gController.rigth;
    341. }
    342.  
    343. public boolean isUp() {
    344. return gController.up;
    345. }
    346.  
    347. public boolean isDown() {
    348. return gController.down;
    349. }
    350.  
    351. public boolean isFire() {
    352. return gController.fire;
    353. }
    354.  
    355. public boolean isTab() {
    356. return gController.tab;
    357. }
    358.  
    359. public boolean isMap() {
    360. return gController.map;
    361. }
    362.  
    363. public void setFire(boolean b) {
    364. gController.fire = b;
    365. }
    366.  
    367. private long getFrps() {
    368. long d = 0;
    369. for (int i = 0; i < frps.length; i++) {
    370. d += frps[i];
    371. }
    372. return (int) (d / (frps.length - 1));
    373. }
    374.  
    375. /**
    376. * Fuegt auf das GlassPanel eine {@link JComponent} hinzu
    377. *
    378. * @param com
    379. * - die {@link JComponent}
    380. */
    381. public void addComponent(JComponent com) {
    382.  
    383. if (glassPanelLock) {
    384. return;
    385. }
    386.  
    387. glassPanelLock = true;
    388.  
    389. c.gridx = 0;
    390. c.gridy = 0;
    391. c.fill = GridBagConstraints.NONE;
    392.  
    393. glassPanel.add(com, c);
    394. glassPanel.setPreferredSize(com.getPreferredSize());
    395. glassPanel.setVisible(true);
    396.  
    397. validateGlassPanel();
    398. }
    399.  
    400. /**
    401. * Zeichnet das GlassPanel neu
    402. */
    403. public void validateGlassPanel() {
    404. glassPanel.validate();
    405. glassPanel.repaint();
    406. f.requestFocus();
    407. }
    408.  
    409. /* --------- Util ----------- */
    410.  
    411. /**
    412. * Addet alle Liseners
    413. */
    414. private void addListeners() {
    415. f.addKeyListener(gController);
    416. f.addFocusListener(gController);
    417. f.addMouseListener(gController);
    418. f.addWindowListener(gController);
    419. this.addComponentListener(gController);
    420. }
    421.  
    422. /**
    423. * Setzt das Main JPanel up, unf fuegt das glassPanel hinzu
    424. */
    425. private void setMainPanelUP() {
    426. this.setLayout(new BorderLayout());
    427. this.setBackground(Color.black);
    428. this.setPreferredSize(getScreenSize());
    429.  
    430. glassPanel = new JPanel();
    431. glassPanel.setLayout(new GridBagLayout());
    432. glassPanel.setFocusable(false);
    433. glassPanel.setOpaque(false);
    434. glassPanel.setVisible(false);
    435.  
    436. this.add(glassPanel, BorderLayout.CENTER);
    437. }
    438.  
    439. /**
    440. * Addet ein neue Frp in die list um besser die Frps zu berechnen
    441. *
    442. * @param frp
    443. * - der Neue frps
    444. */
    445. public void addFrp(long frp) {
    446. if (frpsIndex < frps.length - 1) {
    447. frpsIndex++;
    448. } else {
    449. frpsIndex = 0;
    450. }
    451. frps[frpsIndex] = frp;
    452. }
    453.  
    454. /**
    455. * Gibt die Instance von {@link GameFrame} zuruck, wegen Singolton
    456. *
    457. * @return - das einzige {@link GameFrame}
    458. */
    459. public static GameFrame getInstance() {
    460. return INSTANCE;
    461. }
    462.  
    463. @Override
    464. public void show() {
    465.  
    466. /* prueft od full screnn mode an ist */
    467. isFullScreen = MainConfig.getInstance().getConfig().getPropertyAsBoolean("display_full_screen");
    468.  
    469. if (isFullScreen) {
    470. // pruft ob full screen Supported ist
    471. isFullScreen = gd.isFullScreenSupported();
    472. }
    473.  
    474. /* Setzt das Frame auf die Einstellungen */
    475.  
    476. f.setUndecorated(isFullScreen);
    477. f.setResizable(!isFullScreen);
    478. f.setIgnoreRepaint(isFullScreen);
    479.  
    480. if (isFullScreen) {
    481. gd.setFullScreenWindow(f);
    482. gd.setDisplayMode(getDisplayMode());
    483. } else {
    484. f.pack();
    485. f.setLocationRelativeTo(null);
    486. f.setVisible(true);
    487. }
    488. }
    489.  
    490. /**
    491. * Oeffnet das MainMenu und schliesstes auch wieder
    492. */
    493. public void doMainMenu() {
    494. if (mainMenu.isVisible()) {
    495. mainMenu.setVisible(false);
    496. mainMenu.clearMenu();
    497. clearGlassPanel();
    498. } else {
    499. if (glassPanelLock == false) {
    500. mainMenu.setVisible(true);
    501. addComponent(mainMenu);
    502. }
    503. }
    504. }
    505.  
    506. /**
    507. * Liest aus der config die Screen groesse und gibt sie zurueck.
    508. *
    509. * @return die Screen groesse als {@link Dimension}
    510. */
    511. private Dimension getScreenSize() {
    512. Config config = MainConfig.getInstance().getConfig();
    513.  
    514. int width = 800;
    515. int height = 600;
    516.  
    517. try {
    518. width = config.getPropertyAsInt("display_mode_width");
    519. height = config.getPropertyAsInt("display_mode_height");
    520. } catch (Exception e) {
    521. log.error(e);
    522. }
    523.  
    524. return new Dimension(width, height);
    525. }
    526.  
    527. /**
    528. * Hold sie aus der Config das {@link DisplayMode} unf gibt es zurueck
    529. *
    530. * @return das {@link DisplayMode}
    531. */
    532. private DisplayMode getDisplayMode() {
    533. Config config = MainConfig.getInstance().getConfig();
    534. Dimension d = getScreenSize();
    535. int depth = 16;
    536.  
    537. try {
    538.  
    539. depth = config.getPropertyAsInt("display_color_depth");
    540. } catch (Exception e) {
    541. log.error(e);
    542. }
    543.  
    544. return new DisplayMode(d.width, d.height, depth, DisplayMode.REFRESH_RATE_UNKNOWN);
    545. }
    546. }

  5. #5
    Aiwendil


    @dayaftereh:
    ersma thx für die Antwort,

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

    Java Code:
    1. public void show() {
    2.  
    3. /* prueft ob full screnn mode an ist */
    4.  
    5.  
    6. if (isFullScreen) {
    7. // pruft ob full screen Supported ist
    8. isFullScreen = gd.isFullScreenSupported();
    9. }
    10.  
    11. /* Setzt das Frame auf die Einstellungen */
    12.  
    13. setUndecorated(isFullScreen);
    14. setResizable(!isFullScreen);
    15. setIgnoreRepaint(isFullScreen);
    16. System.out.println(isFullScreen);
    17. if (isFullScreen) {
    18. gd.setFullScreenWindow(this);
    19. gd.setDisplayMode(new DisplayMode(1280,1024,32,DisplayMode.REFRESH_RATE_UNKNOWN));
    20. } else {
    21. pack();
    22. setLocationRelativeTo(null);
    23. setVisible(true);
    24. }
    25. }


    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?

  6. #6
    Aiwendil


    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:

    Java Code:
    1.  
    2. public static void main(String[] args) {
    3. GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
    4. GraphicsDevice[] devices = env.getScreenDevices();
    5. GUI gui = new GUI(devices[0]);
    6. gui.begin();
    7. }


    der Aufruf durch die Steuerklasse:

    Java Code:
    1.  
    2. private void guiMaker() {
    3. GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
    4. GraphicsDevice[] devices = env.getScreenDevices();
    5. gui = new GUI(devices[0]);
    6. gui.begin();
    7. }



    der aufgerufene Konstruktor:

    Java Code:
    1. public GUI(GraphicsDevice pGd) {
    2. super(pGd.getDefaultConfiguration());
    3. this.gd = pGd;
    4. originalDM = gd.getDisplayMode();
    5. setDefaultCloseOperation(EXIT_ON_CLOSE);
    6. }


    und die hinterher aufgerufene Funktion begin():

    Java Code:
    1. public void begin() {
    2. isFullScreen = gd.isFullScreenSupported();
    3. setUndecorated(isFullScreen);
    4. setResizable(!isFullScreen);
    5. if (isFullScreen) {
    6. gd.setFullScreenWindow(this);
    7. gd.setDisplayMode(new DisplayMode(1280,1024,32,DisplayMode.REFRESH_RATE_UNKNOWN));
    8. validate();
    9. } else {
    10. pack();
    11. setVisible(true);
    12. }
    13. init();
    14. }


    irgendwie verwirrt mich das....

    Ich hoffe irgendwer hier kann mir helfen!

  7. #7
    dayaftereh


    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:
    Java Code:
    1.  
    2. import java.awt.DisplayMode;
    3. import java.awt.GraphicsDevice;
    4. import java.awt.GraphicsEnvironment;
    5.  
    6. import javax.swing.JFrame;
    7.  
    8. public class Test extends JFrame {
    9.  
    10. private static final long serialVersionUID = -5045938544478468785L;
    11. private GraphicsDevice gd;
    12. private DisplayMode originalDM;
    13. private boolean isFullScreen;
    14.  
    15. public Test(GraphicsDevice device) {
    16. super(device.getDefaultConfiguration());
    17. this.gd = device;
    18. originalDM = gd.getDisplayMode();
    19. setDefaultCloseOperation(EXIT_ON_CLOSE);
    20.  
    21. }
    22.  
    23. public void begin() {
    24. isFullScreen = gd.isFullScreenSupported();
    25. setUndecorated(isFullScreen);
    26. setResizable(!isFullScreen);
    27. if (isFullScreen) {
    28. gd.setFullScreenWindow(this);
    29. gd.setDisplayMode(new DisplayMode(1280, 1024, 32,DisplayMode.REFRESH_RATE_UNKNOWN));
    30. validate();
    31. } else {
    32. pack();
    33. setVisible(true);
    34. }
    35.  
    36. }
    37.  
    38. public static void main(String[] args) {
    39. GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
    40. GraphicsDevice[] devices = env.getScreenDevices();
    41. Test test = new Test(devices[0]);
    42. test.begin();
    43.  
    44. }
    45.  
    46. }

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

  8. #8
    Aiwendil


    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:

    Java Code:
    1. public GUI(GraphicsDevice pGd) {
    2. super(pGd.getDefaultConfiguration());
    3. this.gd = pGd;
    4. originalDM = gd.getDisplayMode();
    5. setDefaultCloseOperation(EXIT_ON_CLOSE);
    6. mRisiko = new Mrisiko(this);
    7. }


    2. Die Steuerklasse MRisiko:

    Java Code:
    1. public MRisiko(GUI pGui) {
    2. System.out.println("MRisiko Konstruktor mit pGUI");
    3. this.gui=pGui;
    4. init();
    5. }

    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:

    Java Code:
    1.  
    2. public void actionPerformed( ActionEvent e ) {
    3. if(e.getSource()==itemFS){
    4. this.isFullScreen=(!this.isFullScreen);
    5. begin();
    6. repaint();
    7. }
    8. }
    9.  
    10. public void begin() {
    11. this.dispose();
    12. setUndecorated(isFullScreen);
    13. setResizable(!isFullScreen);
    14. if (this.isFullScreen) {
    15. System.out.println("fullscreen mode");
    16. gd.setFullScreenWindow(this);
    17. gd.setDisplayMode(new DisplayMode(1280,1024,32,DisplayMode.REFRESH_RATE_UNKNOWN));
    18. validate();
    19. } else {
    20. System.out.println("windowed mode");
    21. int frameWidth = 1280;
    22. int frameHeight = 1024;
    23. setSize(frameWidth, frameHeight);
    24. Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    25. int x = (d.width - getSize().width) / 2;
    26. int y = (d.height - getSize().height) / 2;
    27. setLocation(x, y);
    28. setVisible(true);
    29. }
    30.  
    31. this.show();
    32.  
    33. }


    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

  9. #9
    Aiwendil


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

  10. #10
    dayaftereh


    Hey, versuche das mal: obd das bei dir Klappt! also bei meine Win Vista 64 gehts:
    Java Code:
    1.  
    2. import java.awt.EventQueue;
    3. import java.awt.GraphicsDevice;
    4. import java.awt.GraphicsEnvironment;
    5.  
    6. import javax.swing.JFrame;
    7.  
    8. public class FullScreenTest {
    9.  
    10. private GraphicsDevice gd;
    11.  
    12. private boolean isFullScreen;
    13.  
    14. private JFrame f = null;
    15.  
    16. public FullScreenTest() {
    17. buildGUI();
    18. }
    19.  
    20. private void buildGUI() {
    21. gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
    22. f = new JFrame(gd.getDefaultConfiguration());
    23. }
    24.  
    25. public void show() {
    26. if (EventQueue.isDispatchThread()) {
    27. isFullScreen = gd.isFullScreenSupported();
    28. f.setUndecorated(isFullScreen);
    29. f.setResizable(!isFullScreen);
    30. if (isFullScreen) {
    31. gd.setFullScreenWindow(f);
    32. gd.setDisplayMode(gd.getDisplayMode());
    33. f.validate();
    34. } else {
    35. f.pack();
    36. f.setVisible(true);
    37. }
    38. } else {
    39. EventQueue.invokeLater(new Runnable() {
    40. public void run() {
    41. show();
    42. }
    43. });
    44. }
    45. }
    46.  
    47. public static void main(String[] args) {
    48. FullScreenTest test = new FullScreenTest();
    49. test.show();
    50. }
    51. }

  11. #11
    Aiwendil


    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....


Keine Antwort auf Deine Suche gefunden? Registriere Dich kostenlos und stelle Deine eigene Frage zu Java!

Jetzt kostenlos registrieren