Java-Forum.org  
Zurück   Java-Forum.org > >

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

Themen zur Programmierung von Benutzer-Oberflächen (GUI, Applet) sowie zur Grafikprogrammierung (2D / 3D)

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

und schonmal danke fürs durchlesen

Gruß Aiwendil
 
Alt 16.01.2010, 13:29   #2
lotus
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

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!
 
Alt 16.01.2010, 13:35   #3
Aiwendil
Themenstarter
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

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]
 
Alt 16.01.2010, 15:32   #4
dayaftereh
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

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. package net.shipshoot.client.gui;
  2.  
  3. import java.awt.BorderLayout;
  4. import java.awt.Color;
  5. import java.awt.Dimension;
  6. import java.awt.DisplayMode;
  7. import java.awt.FontMetrics;
  8. import java.awt.Graphics;
  9. import java.awt.GraphicsDevice;
  10. import java.awt.GraphicsEnvironment;
  11. import java.awt.GridBagConstraints;
  12. import java.awt.GridBagLayout;
  13. import java.util.ArrayList;
  14. import java.util.Collections;
  15. import java.util.List;
  16. import java.util.Map;
  17.  
  18. import javax.swing.JComponent;
  19. import javax.swing.JFrame;
  20. import javax.swing.JPanel;
  21.  
  22. import net.shipshoot.client.gui.control.GameFrameController;
  23. import net.shipshoot.client.gui.pane.JConsole;
  24. import net.shipshoot.client.gui.pane.MainMenu;
  25. import net.shipshoot.client.instance.ObjektDao;
  26. import net.shipshoot.client.runner.Client;
  27. import net.shipshoot.client.tcp.send.SendScreenSize;
  28. import net.shipshoot.client.util.ClientFactory;
  29. import net.shipshoot.lib.model.Objekt;
  30. import net.shipshoot.lib.model.PaintAble;
  31. import net.shipshoot.lib.util.Config;
  32. import net.shipshoot.lib.util.Util;
  33. import net.shipshoot.lib.util.MainConfig;
  34. import net.shipshoot.protocol.io.IOSession;
  35. import net.shipshoot.protocol.model.IPacket;
  36. import net.shipshoot.protocol.send.SendModelPacket;
  37. import net.shipshoot.protocol.util.ProtocolFactory;
  38.  
  39. import org.apache.log4j.Logger;
  40.  
  41. public class GameFrame extends JPanel {
  42.  
  43.     private static final long serialVersionUID = -688051311618433062L;
  44.  
  45.     /** Die Instance fuer die Singolton */
  46.     private static final GameFrame INSTANCE = new GameFrame();
  47.  
  48.     /** Logger um informationen mit zu Loggen */
  49.     private Logger log = Logger.getLogger(GameFrame.class);
  50.  
  51.     /** Ob das Glass JPnale Schon benutzt wird oder nicht */
  52.     private boolean glassPanelLock = false;
  53.  
  54.     /** Wenn das GameFrame im full Screen leuft */
  55.     private boolean isFullScreen = false;
  56.  
  57.     /** Um eine Durschnitt frps rate zu berechnen */
  58.     private int frpsIndex = 0;
  59.  
  60.     /** Liste mit alle frps */
  61.     private long[] frps = new long[100];
  62.  
  63.     /** Der JFrame */
  64.     private JFrame f = null;
  65.  
  66.     /** Die JConsole fuer die JTextArea zum Loggen */
  67.     private JConsole console = null;
  68.  
  69.     /** Das Glass Pnael fuer Score + Map */
  70.     private JPanel glassPanel = null;
  71.  
  72.     /** Die {@link IOSession} zum verschiechen von {@link IPacket} */
  73.     private IOSession session = null;
  74.  
  75.     /** Das GrapicsDevise fuer den FullScreen */
  76.     private GraphicsDevice gd = null;
  77.  
  78.     /** Der Controller fuer MVC */
  79.     private GameFrameController gController = null;
  80.  
  81.     /** Das Main Menu um es anzuzeigen */
  82.     private MainMenu mainMenu = null;
  83.        
  84.     /**
  85.      * Konstruktor - I <bR>
  86.      * Erzeugt das GameFrame fuer das Spiel
  87.      */
  88.     private GameFrame() {
  89.         /* Erzeugt den Controller MVC */
  90.         gController = new GameFrameController(this);
  91.  
  92.         /* Setzt due GUI up */
  93.         makeGUI();
  94.     }
  95.  
  96.     private void makeGUI() {           
  97.         gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();       
  98.         f = new JFrame(gd.getDefaultConfiguration());
  99.  
  100.         f.setTitle("ShipShoot Client " + Client.VERSION + " : " + MainConfig.getInstance().getConfig().getProperty("last.play.name"));
  101.         f.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
  102.         f.setName("GameFrame");
  103.        
  104.         f.getContentPane().setLayout(new BorderLayout());
  105.         f.setFocusTraversalKeysEnabled(false);
  106.  
  107.         addListeners();
  108.         setMainPanelUP();
  109.  
  110.         f.getContentPane().add(this, BorderLayout.CENTER);
  111.  
  112.         console = new JConsole();
  113.         f.getContentPane().add(console, BorderLayout.SOUTH);
  114.  
  115.         mainMenu = new MainMenu(this);
  116.  
  117.         Util.sleep(120);
  118.     }
  119.  
  120.     /* ------------- repaint() ----------- */
  121.  
  122.     @Override
  123.     protected void paintComponent(Graphics g) {
  124.         super.paintComponent(g);
  125.  
  126.         // ClientFactory.drawGrid(g, this.getWidth(), this.getHeight(), 25);
  127.  
  128.         drawObjekts(g);
  129.         drawReadomObjekts(g);
  130.  
  131.         drawRenderStats(g);
  132.     }
  133.  
  134.     private void drawRenderStats(Graphics g) {
  135.  
  136.         if (!MainConfig.getInstance().getConfig().getPropertyAsBoolean("render_stats")) {
  137.             return;
  138.         }
  139.  
  140.         FontMetrics m = g.getFontMetrics();
  141.  
  142.         g.setColor(Color.WHITE);
  143.         g.setFont(ClientFactory.NORMAL_FONT);
  144.  
  145.         String frpPing = "Frps: " + getFrps() + " Ping: " + MainConfig.getInstance().getLatenz();
  146.         g.drawString(frpPing, this.getWidth() / 2 - m.stringWidth(frpPing) / 2, this.getHeight() - m.getHeight() * 2);
  147.  
  148.        
  149.        
  150.         String position = "Position: " + ClientFactory.getPlayerPosition();
  151.         g.drawString(position, this.getWidth() / 2 - m.stringWidth(position) / 2, this.getHeight() - m.getHeight());
  152.     }
  153.  
  154.     /**
  155.      * Zeichnet alle Spiel Obejkte aus der objektMap auf das JPanel
  156.      *
  157.      * @param g
  158.      *            - um zu zeichnen
  159.      */
  160.     private void drawObjekts(Graphics g) {
  161.  
  162.         Map<Integer, Objekt> tmpMap = ObjektDao.getInstance().getGameObjekts();
  163.         List<Objekt> ob = null;
  164.         synchronized (tmpMap) {
  165.             ob = new ArrayList<Objekt>(tmpMap.values());
  166.         }
  167.         Collections.sort(ob);
  168.         for (Objekt objekt : ob) {
  169.             if (objekt == null) {
  170.                 continue;
  171.             }
  172.  
  173.             objekt.paintObjekt(g);
  174.         }
  175.  
  176.         tmpMap = ObjektDao.getInstance().getTempObjekts();
  177.        
  178.         synchronized (tmpMap) {
  179.             ob = new ArrayList<Objekt>(tmpMap.values());
  180.         }
  181.  
  182.         for (Objekt objekt : ob) {
  183.             if (objekt == null) {
  184.                 continue;
  185.             }
  186.  
  187.             objekt.paintObjekt(g);
  188.         }
  189.  
  190.     }
  191.  
  192.     /**
  193.      * Zeichnet alle ReadomObjekts aus der Liste auf das JPanel
  194.      *
  195.      * @param g
  196.      *            - um zu zeichnen
  197.      */
  198.     private void drawReadomObjekts(Graphics g) {
  199.         List<Objekt> readomObjekts = ObjektDao.getInstance().getReadomObjekts();
  200.  
  201.         for (int i = 0; i < readomObjekts.size(); i++) {
  202.  
  203.             PaintAble<Objekt> objekt = readomObjekts.get(i);
  204.  
  205.             if (objekt == null) {
  206.                 continue;
  207.             }
  208.             objekt.paintObjekt(g);
  209.         }
  210.  
  211.     }
  212.  
  213.     /* ------------- Handlers ---------------- */
  214.  
  215.     /**
  216.      * Wenn die greosse des JPanels veraendert wird, schickt er die neue groesse
  217.      * an den Server
  218.      */
  219.     public void resizeJPanel() {
  220.  
  221.         Dimension d = new Dimension(this.getWidth(), this.getHeight());    
  222.         Util.getMainConfig().setPropertyAsInt("display_mode_width", this.getWidth());
  223.         Util.getMainConfig().setPropertyAsInt("display_mode_height", this.getHeight());
  224.  
  225.         if (session != null) {
  226.             Util.sendData(new SendScreenSize(d.width, d.height, session));
  227.         }
  228.  
  229.         log.info("JPanel.Dimension[width=" + d.width + ",height=" + d.height + "]");
  230.     }
  231.  
  232.     /**
  233.      * Wenn Tab gedrueck wird, um die Socre zu bekommen
  234.      */
  235.     public void sendNeedScore() {
  236.         if (session != null) {
  237.             Util.sendData(new SendModelPacket(ProtocolFactory.NEED_SCORE, 0, session));
  238.         }
  239.     }
  240.  
  241.     /**
  242.      * wenn M gedrueck wierd um die MiniMap zu bekommen
  243.      */
  244.     public void sendNeedMiniMap() {
  245.         if (session != null) {
  246.             Util.sendData(new SendModelPacket(ProtocolFactory.NEED_MINI_MAP, 0, session));
  247.         }
  248.     }
  249.  
  250.     /**
  251.      * Raumt das glassePanel auf
  252.      */
  253.     public void clearGlassPanel() {
  254.         glassPanel.removeAll();
  255.         glassPanelLock = false;
  256.         glassPanel.setVisible(false);
  257.         f.requestFocus();
  258.     }
  259.  
  260.     /**
  261.      * Schliesst den JFrame
  262.      */
  263.     public void close() {          
  264.         if(f != null && f.isVisible()){                                            
  265.             f.setVisible(false);
  266.             //f.dispose();
  267.         }      
  268.     }
  269.  
  270.     /**
  271.      * Oeffnet die Map
  272.      */
  273.     public void openMap() {
  274.  
  275.         if (mainMenu.isVisible()) {
  276.             return;
  277.         }
  278.  
  279.         if (!gController.map) {
  280.             gController.map = !gController.map;
  281.             sendNeedMiniMap();
  282.         }
  283.     }
  284.  
  285.     /**
  286.      * Schliesst die Map wieder
  287.      */
  288.     public void closeMap() {
  289.  
  290.         if (mainMenu.isVisible()) {
  291.             return;
  292.         }
  293.  
  294.         if (gController.map) {
  295.             gController.map = !gController.map;
  296.             clearGlassPanel();
  297.         }
  298.     }
  299.  
  300.     /**
  301.      * Oeffnet das ScoreBoard
  302.      */
  303.     public void openScore() {
  304.         if (mainMenu.isVisible()) {
  305.             return;
  306.         }
  307.  
  308.         if (!gController.tab) {
  309.             gController.tab = !gController.tab;
  310.             sendNeedScore();
  311.         }
  312.     }
  313.  
  314.     /**
  315.      * Schliesst das ScoreBoard
  316.      */
  317.     public void closeScore() {
  318.         if (mainMenu.isVisible()) {
  319.             return;
  320.         }
  321.  
  322.         if (gController.tab) {
  323.             gController.tab = !gController.tab;
  324.             clearGlassPanel();
  325.         }
  326.     }
  327.  
  328.     /*------------- Getter / Setter -----------*/
  329.  
  330.     public void setSession(IOSession session) {
  331.         this.session = session;
  332.     }
  333.  
  334.     public boolean isLeft() {
  335.         return gController.left;
  336.     }
  337.  
  338.     public boolean isRigth() {
  339.         return gController.rigth;
  340.     }
  341.  
  342.     public boolean isUp() {
  343.         return gController.up;
  344.     }
  345.  
  346.     public boolean isDown() {
  347.         return gController.down;
  348.     }
  349.  
  350.     public boolean isFire() {
  351.         return gController.fire;
  352.     }
  353.  
  354.     public boolean isTab() {
  355.         return gController.tab;
  356.     }
  357.  
  358.     public boolean isMap() {
  359.         return gController.map;
  360.     }
  361.  
  362.     public void setFire(boolean b) {
  363.         gController.fire = b;
  364.     }
  365.  
  366.     private long getFrps() {
  367.         long d = 0;
  368.         for (int i = 0; i < frps.length; i++) {
  369.             d += frps[i];
  370.         }
  371.         return (int) (d / (frps.length - 1));
  372.     }
  373.  
  374.     /**
  375.      * Fuegt auf das GlassPanel eine {@link JComponent} hinzu
  376.      *
  377.      * @param com
  378.      *            - die {@link JComponent}
  379.      */
  380.     public void addComponent(JComponent com) {
  381.  
  382.         if (glassPanelLock) {
  383.             return;
  384.         }
  385.  
  386.         glassPanelLock = true;
  387.  
  388.         GridBagConstraints c = new GridBagConstraints();
  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. }
 
Alt 16.01.2010, 16:35   #5
Aiwendil
Themenstarter
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

@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?
 
Alt 16.01.2010, 17:52   #6
Aiwendil
Themenstarter
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

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. public static void main(String[] args) {
  2.         GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
  3.         GraphicsDevice[] devices = env.getScreenDevices();
  4.              GUI gui = new GUI(devices[0]);
  5.              gui.begin();
  6. }

der Aufruf durch die Steuerklasse:

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


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!
 
Alt 16.01.2010, 23:14   #7
dayaftereh
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

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. import java.awt.DisplayMode;
  2. import java.awt.GraphicsDevice;
  3. import java.awt.GraphicsEnvironment;
  4.  
  5. import javax.swing.JFrame;
  6.  
  7. public class Test extends JFrame {
  8.  
  9.     private static final long serialVersionUID = -5045938544478468785L;
  10.     private GraphicsDevice gd;
  11.     private DisplayMode originalDM;
  12.     private boolean isFullScreen;
  13.  
  14.     public Test(GraphicsDevice device) {
  15.         super(device.getDefaultConfiguration());
  16.         this.gd = device;
  17.         originalDM = gd.getDisplayMode();
  18.         setDefaultCloseOperation(EXIT_ON_CLOSE);
  19.  
  20.     }
  21.  
  22.     public void begin() {
  23.         isFullScreen = gd.isFullScreenSupported();
  24.         setUndecorated(isFullScreen);
  25.         setResizable(!isFullScreen);
  26.         if (isFullScreen) {
  27.             gd.setFullScreenWindow(this);
  28.             gd.setDisplayMode(new DisplayMode(1280, 1024, 32,DisplayMode.REFRESH_RATE_UNKNOWN));
  29.             validate();
  30.         } else {
  31.             pack();
  32.             setVisible(true);
  33.         }
  34.  
  35.     }
  36.  
  37.     public static void main(String[] args) {
  38.         GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
  39.         GraphicsDevice[] devices = env.getScreenDevices();
  40.         Test test = new Test(devices[0]);
  41.         test.begin();
  42.    
  43.     }
  44.  
  45. }
Und es Klappt, ich bekomme einen Grauen Bildschirmm! erkläre nochmal dein Problem? hoffe ich konnte helfen!
 
Alt 16.01.2010, 23:46   #8
Aiwendil
Themenstarter
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

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

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
 
Alt 17.01.2010, 19:54   #9
Aiwendil
Themenstarter
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

solangsam glaub ihc das Win7 schuld ist
bei nem Anderen Kumpel mit nem baugleichen rechner wie ich läuft auf Vista alles glatt
 
Alt 17.01.2010, 20:54   #10
dayaftereh
 
setFullscreenWindow()-->Schwarzer Bildschirm - Standard AW: setFullscreenWindow()-->Schwarzer Bildschirm

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

Zurück   Java-Forum.org > >

Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Ähnliche Themen: setFullscreenWindow()-->Schwarzer Bildschirm
(Android) schwarzer Bildschirm beim Rendern von Text und Dreiecken
schwarzer Bildschirm beim Rendern von Text und Dreiecken: Hallo liebes java-forum. Ich habe folgendes...
Schwarzer Flackerscreen
Schwarzer Flackerscreen: Hi ich habe gerade angefangen Java zu lernen....
JInternalFrame - schwarzer Bildschirm
JInternalFrame - schwarzer Bildschirm: Hallo, ich wollte mich gern mal in die...
Schwarzer Bildschirm JAVA
Schwarzer Bildschirm JAVA: Hallo! :wink: Ich habe seit neusten ein...


Sie betrachten gerade setFullscreenWindow()-->Schwarzer Bildschirm


Powered by vBulletin® Version 3.8.7 (Deutsch)
Copyright ©2000 - 2014, vBulletin Solutions, Inc.