setFullscreenWindow()-->Schwarzer Bildschirm

[Aiwendil]

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

1
2
3
setUndecorated(true);
setSize( Toolkit.getDefaultToolkit().getScreenSize());
gd.setFullScreenWindow(this);

geschrieben und

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

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

hier mal die wichtigsten codeteile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
98
99
100
101
102
103
106
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]

Statt

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

benutze ich

1
2
GraphicsEnvironment.getLocalGraphicsEnvironment()
                    .getDefaultScreenDevice()

weiß nicht ob das vllt einen Unterschied macht!

[Aiwendil]

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

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

und übergeb dan dem Konstruktor der GUI

1
devices[0]

[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!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
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]

@dayaftereh:
ersma thx für die Antwort,

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

1
2
3
4
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
  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]

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:

1
2
3
4
5
6
    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:

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

der aufgerufene Konstruktor:

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

und die hinterher aufgerufene Funktion begin():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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....

Ich hoffe irgendwer hier kann mir helfen!

[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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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]

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:

1
2
3
4
5
6
7
 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:

1
2
3
4
5
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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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

[Aiwendil]

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

[dayaftereh]

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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]

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