JFrame en Java plein écran

Je vais bientôt faire un projet et je devrai utiliser le mode plein écran.

Il dessinera quelques graphiques dans la fenêtre. Ce serait pratique si j'utilise JFrame ou quelque chose de similaire.

Je ne sais pas quelle sera la résolution finale de l'écran. Veuillez me dire si les graphiques seront automatiquement redimensionnés?

JFrame jf = new JFrame();
jf.setSize(1650,1080);
//make it fullscreen;
//now is everything is going to be rescaled so it looks like the original?

Ajouter:

frame.setExtendedState(JFrame.MAXIMIZED_BOTH); 
frame.setUndecorated(true);
frame.setVisible(true);

Si vous souhaitez mettre votre cadre en mode plein écran (comme un film en plein écran), vérifiez ces réponses.

• Comment puis-je faire du plein écran en Java sur OSX
• Java setFullScreenWindow () reste au top

Les classes java.awt.GraphicsEnvironmentet java.awt.GraphicsDevicesont utilisées pour mettre une application en mode plein écran sur un seul écran (le dispositif).

par exemple:

static GraphicsDevice device = GraphicsEnvironment
        .getLocalGraphicsEnvironment().getScreenDevices()[0];

public static void main(String[] args) {

    final JFrame frame = new JFrame("Display Mode");
    frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    frame.setUndecorated(true);

    JButton btn1 = new JButton("Full-Screen");
    btn1.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            device.setFullScreenWindow(frame);
        }
    });
    JButton btn2 = new JButton("Normal");
    btn2.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            device.setFullScreenWindow(null);
        }
    });

    JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER));
    panel.add(btn1);
    panel.add(btn2);
    frame.add(panel);

    frame.pack();
    frame.setVisible(true);

}

Utilisez setExtendedState(int state), là où l'état serait JFrame.MAXIMIZED_BOTH.

Une façon consiste à utiliser l'état étendu. Cela demande au système d'exploitation sous-jacent de maximiser le JFrame.

setExtendedState(getExtendedState() | JFrame.MAXIMIZED_BOTH);

Une autre approche serait de maximiser manuellement l'écran selon vos besoins.

Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
setBounds(100, 100, (int) dim.getWidth(), (int) dim.getHeight());
setLocationRelativeTo(null);

Mais cela a des pièges dans Ubuntu OS. Le travail autour que j'ai trouvé était le suivant.

if (SystemHelper.isUnix()) {
    getContentPane().setPreferredSize(
    Toolkit.getDefaultToolkit().getScreenSize());
    pack();
    setResizable(false);
    show();

    SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            Point p = new Point(0, 0);
            SwingUtilities.convertPointToScreen(p, getContentPane());
            Point l = getLocation();
            l.x -= p.x;
            l.y -= p.y;
            setLocation(p);
        }
    });
}

Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
setBounds(100, 100, (int) dim.getWidth(), (int) dim.getHeight());
setLocationRelativeTo(null);

Dans Fedora, le problème ci-dessus n'est pas présent. Mais il y a des complications impliquées avec Gnome ou KDE . Alors mieux vaut être prudent. J'espère que cela t'aides.

Solution la plus simple jamais réalisée:

for ( Window w : Window.getWindows() ) {
    GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().setFullScreenWindow( w );
}

Utilisez simplement ce code:

import java.awt.event.*;
import javax.swing.*;

public class FullscreenJFrame extends JFrame {
    private JPanel contentPane = new JPanel();
    private JButton fullscreenButton = new JButton("Fullscreen Mode");
    private boolean Am_I_In_FullScreen = false;
    private int PrevX, PrevY, PrevWidth, PrevHeight;

    public static void main(String[] args) {
        FullscreenJFrame frame = new FullscreenJFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(600, 500);
        frame.setVisible(true);
    }

    public FullscreenJFrame() {
        super("My FullscreenJFrame");

        setContentPane(contentPane);

        // From Here starts the trick
        FullScreenEffect effect = new FullScreenEffect();

        fullscreenButton.addActionListener(effect);

        contentPane.add(fullscreenButton);
        fullscreenButton.setVisible(true);
    }

    private class FullScreenEffect implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent arg0) {
            if (Am_I_In_FullScreen == false) {
                PrevX = getX();
                PrevY = getY();
                PrevWidth = getWidth();
                PrevHeight = getHeight();

                // Destroys the whole JFrame but keeps organized every Component
                // Needed if you want to use Undecorated JFrame dispose() is the
                // reason that this trick doesn't work with videos.
                dispose();
                setUndecorated(true);

                setBounds(0, 0, getToolkit().getScreenSize().width,
                        getToolkit().getScreenSize().height);
                setVisible(true);
                Am_I_In_FullScreen = true;
            } else {
                setVisible(true);
                setBounds(PrevX, PrevY, PrevWidth, PrevHeight);
                dispose();
                setUndecorated(false);
                setVisible(true);
                Am_I_In_FullScreen = false;
            }
        }
    }
}

J'espère que ça aide.

cela vous aidera à utiliser votre objet instantanément du cadre

frame.setExtendedState(JFrame.MAXIMIZED_BOTH);

Tout d'abord, c'est la résolution que vous voudriez utiliser 1650,1080,.

Ajoutez maintenant:

frame.setExtendedState(JFrame.MAXIMIZED_BOTH); 

Si vous rencontrez des problèmes avec les composants du JFrame, après avoir ajouté tous les composants à l'aide de la frame.add(component)méthode, ajoutez l'instruction suivante.

frame.pack();

JFrame frame = new JFrame();
frame.setPreferredSize(new Dimension(Toolkit.getDefaultToolkit().getScreenSize()));

Cela fait juste le cadre de la taille de l'écran

Vous pouvez utiliser l'outil de propriétés.
Définissez 2 propriétés pour votre JFrame :

extendedState 6
resizeable    true

Vous n'avez besoin que de ceci:

JFrame frame = new JFrame();
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);

Lorsque vous utilisez le modificateur MAXIMIZED_BOTH, il maximisera tout le long de la fenêtre (hauteur et largeur).

Certains suggèrent d'utiliser ceci:

frame.setUndecorated(true);

Je ne le recommanderai pas, car votre fenêtre n'aura pas d'en-tête, donc pas de bouton fermer / restaurer / réduire.

Les valeurs ont souligné que je veux dire:

Définissez 2 propriétés ci-dessous:

1. ExtendedState = 6
2. redimensionnable = vrai

Ça marche pour moi.