imposer une résolution d'écran

Version imprimable

Bonjour à tous

J'ai une application javaFX que j'affiche en plein écran mais je voudrais pouvoir imposer la résolution de l'écran. Par exemple 1280x864

J'ai essayé ça:
Code:

1 2 3 4 5 6 7 8 9 primaryScene = new Scene(vueRoot, 1280, 864); primaryStage.setScene(primaryScene); primaryStage.setX(0); primaryStage.setY(0); primaryStage.setWidth(1280); primaryStage.setHeight(864); primaryStage.setOnCloseRequest(e -> handleWin(e)); primaryStage.setFullScreen(true);
Mais ça ne fonctionne pas comme je le voudrais. A savoir que l'application est bien plein écran mais à la résolution de mon écran et non à celle que je voudrais imposer.

29/08/2018, 01h18
bouye
Je ne pense pas que ce soit faisable de base dans FX (dans Swing il me semble que le passage en mode exclusif permettait de le faire), il va sans doute te falloir passer par Java2D/AWT/Swing ou aller taper dans JNI ou JNA pour changer la résolution d'affichage de l’hôte avant d'activer le passage en mode plein écran de l'application FX.

Le soucis c'est que le mode plein ecran de AWT requiert une Window AWT et que on est pas sense pouvoir manipuler le peer d'un Stage (pis ca devient inaccessible a partir du JDK9 de toutes manières)

J'ai aussi essaye de faire un truc qui permettait de basculer vers en hors du mode plein écran a autre résolution avec 2 JFrame (une affichée normalement et une autre non-décorée pour le plein écran) mais le résultat n'était pas probant (exception ou partie FX qui n'apparaissait pas). Donc la je suis parti vers une JFrame qui bascule directement en mode plein écran au lancement.

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
46
47
48
49
50
51
52
53
package screenres;
 
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import javafx.application.Platform;
import javafx.embed.swing.JFXPanel;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
 
public final class Main2 extends JFrame {
 
    public static void main(String... args) {
        SwingUtilities.invokeLater(Main2::new);
    }
 
    private final JFXPanel fxContainer;
 
    private Main2() {
        setTitle("Test");
        setPreferredSize(new Dimension(500, 500));
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setUndecorated(true);
        setResizable(false);
        final GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        final GraphicsDevice[] devices = ge.getScreenDevices();
        final GraphicsDevice gd = devices[0];
        if (gd.isFullScreenSupported()) {
            final DisplayMode old = gd.getDisplayMode();
            final DisplayMode dm = new DisplayMode(640, 480, old.getBitDepth(), old.getRefreshRate());
            gd.setFullScreenWindow(this);
            gd.setDisplayMode(dm);            
        }
        fxContainer = new JFXPanel();
        setContentPane(fxContainer);
        setVisible(true);
        pack();
        Platform.runLater(this::buildFXContent);
 
    }
 
    private void buildFXContent() {
        final Button button = new Button("Click me");
        final StackPane root = new StackPane();
        root.getChildren().add(button);
        final Scene scene = new Scene(root);
        fxContainer.setScene(scene);
    }
}

A voir si c'est plus simple avec JNI/JNA.

Après pas mal de depatouillage dans la doc de JNA et de Windows, j'ai fait ca qui est sense donner des infos sur les ecrans de la machine via EnumDisplayDevicesA et _DISPLAY_DEVICEA

Infos: j'y vais a tatons (pas mon rayon) et ça retourne que dalle pour le moment mais au moins ça me donne 2 devices. Ça peut peut-être être une piste pour la suite.

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
public interface User32 extends StdCallLibrary {
 
    final User32 INSTANCE = (User32) Native.loadLibrary("user32", User32.class);
 
//    interface _DISPLAY_DEVICEA extends StdCallCallback {
//
//        boolean callback(int cb, String DeviceName, String DeviceString, int StateFlags, String DeviceID, String DeviceKey);
//    }
    class _DISPLAY_DEVICEA extends Structure {
 
        public int cb;
        public String DeviceName;
        public String DeviceString;
        public int StateFlags;
        public String DeviceID;
        public String DeviceKey;
 
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("cb", "DeviceName", "DeviceString", "StateFlags", "DeviceID", "DeviceKey");
        }
    }
 
    final int EDD_GET_DEVICE_INTERFACE_NAME = 0x00000001;
 
    boolean EnumDisplayDevicesA(Pointer lpDevice, int iDevNum, _DISPLAY_DEVICEA lpDisplayDevice, int dwFlags);
}

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
public final class Main3 extends Application {
 
    public static void main(String... args) {
        final User32 user32 = User32.INSTANCE;
        final User32._DISPLAY_DEVICEA dp = new User32._DISPLAY_DEVICEA();
        for (int iDevNum = 0;
                user32.EnumDisplayDevicesA(Pointer.NULL, iDevNum, dp, User32.EDD_GET_DEVICE_INTERFACE_NAME); iDevNum++) {
            System.out.println(iDevNum);
            System.out.println(dp.cb);
            System.out.println(dp.DeviceName);
            System.out.println(dp.DeviceString);
            System.out.println(dp.StateFlags);
            System.out.println(dp.DeviceID);
            System.out.println(dp.DeviceKey);
            System.out.println();
        }
        System.out.println("Fini !");
//        Application.launch(args);
    }
 
    @Override
    public void start(Stage primaryStage) throws Exception {
        final ToggleButton button = new ToggleButton("Click me");
        button.setOnAction(event -> toggleFullScreen(primaryStage, button.isSelected()));
        final StackPane root = new StackPane();
        root.getChildren().add(button);
        final Scene scene = new Scene(root);
        primaryStage.setTitle("Test");
        primaryStage.setWidth(500);
        primaryStage.setHeight(500);
        primaryStage.setScene(scene);
        primaryStage.show();
    }
 
    private void toggleFullScreen(final Stage stage, final boolean toggle) {
        // Call JNA here to change or restore resolution.
        if (toggle) {
        } else {
        }
        Platform.runLater(() -> stage.setFullScreen(toggle));
    }
}

29/08/2018, 09h05
Gouyon

Merci pour les informations je vais regarder la doc JNA.
21/09/2018, 02h16
bouye

Pour rebondir sur ce sujet et apporter de l'eau au moulin :

Citation:

Envoyé par http://mail.openjdk.java.net/pipermail/openjfx-dev/2018-September/022507.html

JavaFX does not use exclusive full-screen mode. It simulates full screen by using an undecorated window that is exactly the size of the screen.
This means that pop-ups, such as those used by ComboBox and content menus, will continue to work (they use separate windows).

-- Kevin

pas de mode exclusif plein écran comme AWT/Swing donc. Fouiller du cote de JNA pour imposer puis restaurer la résolution appropriée semble être la meilleure solution donc.