gérer la résolution de manière automatique

bonjour a tous,
j'aurais aimé savoir s'il existe un quelconque moyen pour redimensionner les fenetres autonatiquement.
En fait mon application fait 1200*1000 cependant j'aurai aimé qu'elle s'adapte aux résolutions plus basse sans perdre en qualité, existe t'il un moyen de réaliser cette transformation????

J'ai trouvé ca sur le net, jamais eu le temps de le tester

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
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
 
import java.awt.DisplayMode;
import java.awt.Frame;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Window;
 
/**
 * Cette classe est un gestionnaire d'écran et permet de changer la résolution
 * de l'écran ou de mettre le mode plein-écran.
 * 
 * @author Julien CHABLE (webmaster@neogamedev.com)
 * @version 1.0 20/06/2004
 */
public class ScreenManager {
 
    // Notre device (abstraction de la carte graphique ...) graphique sur lequel
    // nous allons effectuer les changements de résolution, le plein-écran, ...
    private GraphicsDevice gd;
 
    /**
     * Constructeur par défaut. Initialise la variable du GraphicsDevice.
     *  
     */
    public ScreenManager() {
        // On récupère l'environnement graphique du système d'exploitation,
        // celui-ci va nous permettre de récupérer un certain nombre d'éléments
        // sur la configuration graphique du système ...
        GraphicsEnvironment ge = GraphicsEnvironment
                .getLocalGraphicsEnvironment();
        // On récupère le device par défaut ... vous pouvez récupérer l'ensemble
        // des devices du système avec la méthode getScreenDevices(), le centre
        // de l'écran avec getCenterPoint(), ...
        gd = ge.getDefaultScreenDevice();
    }
 
    /**
     * Passage de la fenêtre en mode plein écran. Changement de mode graphique (résolution et profondeur). Regarder la
     * classe DisplayMode pour plus d'informations sur les résolutions d'écran.
     * 
     * @param window
     *            La fenêtre à passer en plein-écran.
     * @param displayMode
     *            Le mode graphique à appliquer.
     */
    public void setFullScreen(Frame window, DisplayMode displayMode) {
        if (window == null) return;
        // On ne veut pas des bords de la fenêtre
        window.setUndecorated(true);
        // La fenêtre n'est pas redimensionnable
        window.setResizable(false);
        // Passage en mode plein-écran
        if (gd.isFullScreenSupported()) gd.setFullScreenWindow(window);
        // Changement de résolution
        if (displayMode != null && gd.isDisplayChangeSupported()) {
            try {
                // Affectation du mode graphique au device graphique.
                gd.setDisplayMode(displayMode);
            } catch (Exception e) {
                // Do nothing
            }
        }
    }
 
    /**
     * Obtenir la fenêtre en plein-écran.
     */
    public Window getFullScreen() {
        return gd.getFullScreenWindow();
    }
 
    /**
     * Obtenir le GraphicsDevice par défaut de la fenêtre.
     */
    /*public GraphicsDevice getGraphicsDevice(){
        return gd;
    }*/
 
    /**
     * Arrête le mode plein-écran pour revenir en mode fenêtré ...
     */
    public void restoreFullScreen() {
        // On récupère notre fenêtre en mode plein-écran
        Window window = getFullScreen();
        //
        if (window != null) window.dispose();
        // On arrête le plein-écran.
        gd.setFullScreenWindow(null);
    }
}

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
import java.awt.DisplayMode;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsEnvironment;
import java.awt.Point;
 
/**
 * Classe de test pour la classe ScreenManager.
 * 
 * @author Julien CHABLE (webmaster@neogamedev.com)
 * @version 1.0 20/06/2004
 */
public class ScreenTest extends Frame {
    // Notre classe qui va nous permettre de gérer notre écran
    private ScreenManager sm = new ScreenManager();
    // Pour faire tourner notre 'aiguille'
    private double t = 0.0;
 
    // La fonction principale
    public static void main(String[] args) {
        DisplayMode dm;
 
        // Construction d'une résolution d'écran
        if (args.length == 3) {
            dm = new DisplayMode(
                    Integer.parseInt(args[0]),
                    Integer.parseInt(args[1]),
                    Integer.parseInt(args[2]),
                    DisplayMode.REFRESH_RATE_UNKNOWN);
        } else {
            // Résolution par défaut, la plus courante
            dm = new DisplayMode(
                    800,
                    600,
                    16,
                    DisplayMode.REFRESH_RATE_UNKNOWN);
        }
 
        ScreenTest screen = new ScreenTest();
        // Test le plein écran !
        screen.testFullScreen(dm);
    }
 
    public void testFullScreen(DisplayMode dm){
        sm.setFullScreen(this, dm);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e){
            // Do nothing
        } finally {
            sm.restoreFullScreen();
        }
    }
 
    public void paint(Graphics g) {
 
        Point centerScreen = GraphicsEnvironment
        	.getLocalGraphicsEnvironment().getCenterPoint();
        g.drawOval(centerScreen.x / 2, centerScreen.y / 2, getWidth() / 2, getHeight() / 2);
        g.drawLine(centerScreen.x, centerScreen.y, (int)(Math.cos(t) * getWidth() / 4) + centerScreen.x, (int)(Math.sin(t) * getHeight() / 4) + centerScreen.y);
        t += 0.5;
        try {
            Thread.sleep(230);
        } catch (InterruptedException e){
 
        }
        repaint();
    }
}

Attention, pour ce qui est de la question "sans perdre en qualité" tu dois penser au layout que tu utilises.

Je te conseille fortement le gridBag layout.

En ce qui concerne la taille automatique des fenêtres; ce que je faisais c'est que je récupérais la résolution, je créais un objet Dimension que j'envoyais en paramètre à ma JFrame.

Je ne me souviens plus du code mais une petite recherche google doit t'aider...

Salut L Ankou
Tu veux dire comme ca
Code:

1 2 Dimension screensize = Toolkit.getDefaultToolkit().getScreenSize();

Oui, il me semble que c'est comme ca !!!

je vous remercie les gars je vais testé je vous tiens au courant