A partir du JDK 1.4 :Le JDK 1.4 offre une méthode de centrage automatique des fenêtres, plus besoin de faire cela à la main... La méthode setLocationRelativeTo(java.awt.Component) de la classe java.awt.Window permets de faire un centrage par rapport à un composant ou à l'écran.
Le centrage doit être effectué par rapport à un composant affiché au moment où l'on veut centrer notre fenêtre... Généralement juste avant de la rendre visible. (si le paramètre est null ou que le composant n'est pas affiché, le centrage est fait par rapport à l'écran.)
JDK 1.3 et antérieurs :Aucune méthode ne fait cela automatiquement, mais il est très facile de positionner soit-même la fenêtre lors de l'initialisation.
Centré autour de ses quatres composants voisins Réponse toute simple : en utilisant le LayoutManager approprié à ce cas de figure, à savoir java.awt.BorderLayout.
N'oubliez pas que la caractéristique principale du BorderLayout est d'ajuster la dimension du composant à la place disponible.
Centré sur son conteneur (JPanel )Là aussi c'est le choix du LayoutManager qui résout le problème, mais il est nécessaire d'en prendre un quelque peu plus compliqué : java.awt.GridBagLayout.
JPanel p =new JPanel (new GridBagLayout ());
p.add (composant,
new GridBagConstraints (0, 0, 1, 1, 0, 0,
GridBagConstraints.CENTER,
GridBagConstraints.CENTER,
new Insets (0,0,0,0), 0, 0));
Java propose un certain nombre gestionnaires de mise en forme, ou layout managers, qui permettent de placer les composants sans en indiquer la position précise (les coordonnées), mais la disposition souhaitée.
Si l'on a besoin d'une mise en forme particulière, il est possible de créer des gestionnaires de mise en forme personnalisés.
En spécifiant les coordonnées
Il est possible de se passer des gestionnaires de mise en forme pour le placement des composants. Pour cela, on définit le gestionnaire de mise en forme du contenant à null, on ajoute le composant au contenant et on spécifie la position absolue et la taille voulue du composant :
setLayout(null);
JButton ok =newJButton("OK");
ok.setBounds(x,y,width,height); //paramint
Ce gestionnaire aligne horizontalement les composants, en préservant la taille de ceux-ci, jusqu'à ce qu'il n'y ait plus de place. Lorsque la ligne est remplie, les composants suivant sont placés à la ligne suivante et ainsi de suite.
Par défaut les composants sont centrés horizontalement. Lorsque la taille du conteneur est modifiée, les composants sont réorganisés automatiquement.
FlowLayout est le gestionnaire de mise en forme par défaut des JPanel.
Ce gestionnaire décompose le conteneur en 5 zones : Centre, Nord, Sud, Est, Ouest.
Si on ne précise pas la zone dans laquelle on veut placer le composant, celui-ci est placé au centre. Les composants en bordure sont placés en premier, puis l'espace restant est occupé par le composant central.
Ce gestionnaire modifie la taille des composants afin qu'ils prennent tout l'espace disponible. En cas de redimensionnement, seul le centre est redimensionné en hauteur ET en largeur.
BorderLayout est le gestionnaire de mise en forme par défaut des JFrame.
Ce gestionnaire arrange les composants sur une grille dont on spécifie le nombre de cases horizontales et verticales.
Un composant est redimensionné afin de prendre tout l'espace de la cellule, et chaque cellule est de taille identique. Lorsque la fenêtre est redimensionnée, les cellules se partagent équitablement l'espace disponible. Les composants sont ajoutés ligne par ligne à partir de la cellule du coin supérieur gauche.
Ce gestionnaire permet de placer les composants sur une même ligne ou une même colonne.
Comme pour les autres gestionnaires, on peut l'assigner comme gestionnaire du conteneur (JFrame, JPanel...). Cependant, il existe un conteneur "dédié", le Box, dont le gestionnaire par défaut est un BoxLayout.
Utiliser des Box nous permet d'avoir plusieurs BoxLayout dans un même conteneur (dans le JFrame par exemple).
Les composants sont insérés :
de gauche à droite pour le BoxLayout horizontal
de haut en bas pour le BoxLayout vertical
Par défaut, les composants sont collés les uns aux autres. Pour les espacer, il faut insérer des réserves entre les composants. Il en existe 3 types :
le Strut, qui ajoute un espace mesuré en nombre de pixels. Le Strut est unidimensionnel : il existe un Strut horizontal et un Strut vertical
le RigidArea, qui est équivalent à un couple de Strut horizontal/vertical
le Glue, qui repousse les 2 composants voisins aussi loin que possible l'un de l'autre.
Stratégie de mise en forme :
- Le BoxLayout horizontal calcul la taille maximale du plus haut composant et tente d'agrandir tous les autres composants à la même hauteur. Les composants qui n'ont pu atteindre cette hauteur sont alignés (appel à getAlignementY()). Les largeurs préférées des composants sont additionnées. Si la largeur du BoxLayout ne correspond pas à cette somme, la taille des composants est ajustée dans les limites des tailles min et max. Si le Box est trop petit, des composants ne seront pas affichés.
- stratégie analogue pour le BoxLayout vertical.
La terreur du débutant ! Comme le GridLayout, ce gestionnaire permet de placer les composants sur une grille, mais avec plus de flexibilité.
Le GridBagLayout fonctionne comme un tableau dont les cellules peuvent être fusionnées.
Pour placer les composants, il faut :
instancier un GridBagLayout et le passer comme gestionnaire du conteneur
définir un GridBagConstraints pourr chaque composant
ajouter chaque paire composant/GridBagConstraints au conteneur
Ce sont les contraintes qui détermineront la position des composants et le comportement en cas de redimenssionnement de la fenêtre.
Les paramètres d'un GridBagConstraints sont :
gridx, gridy (int) : numéros de ligne et de colonne du coin supérieur gauche de la zone d'affichage du composant.
gridwidth, gridheight (int) : largeur et hauteur du composant en nombre de cellule.
fill (int) : comportement du composant lors du redimensionnement si sa taille et celle de la zone d'affichage ne correspondent pas.
anchor (int) : alignement du composant dans la zone d'affichage.
weigthx, weigthy (double) : comportement de la zone d'affichage en cas de redimenssionnement du tableau.
ipadx, ipady (int) : valeurs ajoutées à la taille minimale du composant (par 2 fois : ipadx à gauche et à droite, ipady en haut et en bas)
insets (Insets) : définit les marges autour du composant.
La documentation AWT recommande de remplacer la définition des paramètres gridx et gridy en valeurs absolues, par la constante GridBagConstraints.RELATIVE. Pour indiquer qu'un composant est le dernier d'une ligne, on donne alors à la largeur de sa zone d'affichage (gridwidth) la valeur GridBagConstraints.REMAINDER. On donne cette même valeur à la hauteur de la zone d'affichage des composants de la dernière ligne.
Etapes pour utiliser un GridBagLayout:
[1] Mettre en forme le composant sur papier.
[2] Etablir la grille avec une cellule pour les petits composants, plusieurs pour les plus gros.
[3] Libeller les lignes et les colonnes. Ces libellés donneront les valeurs de gridx, gridy, gridwidth, gridheight.
[4] Définir le dimensionnement (fill) et l'alignement (anchor) des composants.
[5] Mettre tous les poids (weightx et weigthy) à 100, on ajoustera les poids ensuite. Mettre 0 pour les composants qui restent toujours à leur taille par défaut.
[6] Ecrire le code.
[7] Compiler, exécuter et éventuellement ajuster les poids.
NOTE: Le didactiel de Sun suggère d'utiliser le même objet GriBagConstraints pour tous les composants. Cependant, le code devient difficile à lire et est sujet aux erreurs (oublie de modification d'un paramètre qui avait été modifié pour un précédent composant). Aussi est-il préférable d'utiliser un nouveau GriBagConstraints pour chaque composant.
Le plus complexe avec le GridBagLayout, c'est l'écriture des contraintes. Les auteurs du livre "Au coeur de Java2 : Notions fondamentales" proposent une classe qui simplifie énormément l'écriture des contraintes et la lecture du code : la classe GBC.
En voici les avantages :
Dans 'Au coeur de Java2 : Notions fondamentales', il y a écrit :
L'exemple de la question Comment utiliser le GridBagLayout ?,réarrangé en employant la classe GBC, devient :
Le passage en plein écran est très utile pour la programmation de jeu, mais aussi dans les applications à titre ponctuel pour faire une prévisualisation d'impression, d'image, pour faire un diaporama ou autres ...
Passage en plein écran :Le passage de l'affichage en plein écran est une nouvelle fonctionnalité de j2se 1.4. La classe java.awt.GraphicsEnvironment permet de connaître la liste des écrans. Il est fortement recommandée de vérifier que le plein écran est supporté ; si ce n'est pas le cas la fenêtre est redimensionnée pour prendre tout l'écran mais elle n'a pas l'exclusivité de l'affichage.
Changement de résolution :La diminution de la résolution est particulièrement conseillée pour augmenter la performance d'affichage ( moins il y a de pixels, mieux c'est ). Une configuration est définie par une instance de java.awt.DisplayMode. Exemple de code :
Avant de commencer :Avant de vous embarquer dans la réalisation d'un super jeu en plein écran, je vous conseille de vous renseigner un minimum sur les techniques d'optimisation et d'accélération de l'affichage (vois lien ci-dessous).
Et les applets ?Les applets sont autorisées à passer en affichage plein écran seulement si l'utilisateur a la permission fullScreenExclusive.
L'icone d'une application apparaît à divers endroits en fonction du système d'exploitation. Sous windows, on la retrouve en haut à gauche de la fenêtre, et dans la barre des taches. Par défaut, il s'agit de la tasse de café de Java. Il est très facile de la personnaliser en utilisant la méthode setIconImage(java.awt.Image) des classes javax.swing.JFrame.
Cette méthode n'est pas disponible pour la classe JDialog, les dialogues utilisent automatiquement l'icone de la frame parente.
Si l'image n'apparaît pas, c'est certainement que le paramètre image a une valeur 'null'.
Une autre raison pour laquelle cette image n'apparaitrait serait un problème au niveau de la transparence avec les images PNG qui ne sont pas gérés par tous les OS, certains OS vont l'afficher mais supprimmer la transparence et d'autres ne pas l'afficher.
De plus, certains OS ne supportent simplement pas les images de type PNG, transparence ou non.
Lorsque l'on affiche une fenêtre à l'écran, la machine virtuelle alloue la mémoire et les ressources systèmes nécessaires à la création de l'image de cette fenêtre à l'écran. Les méthodes hide() et dispose() font tous les deux disparaître la fenêtre de l'écran ; en revanche, elles diffèrent par leur action sur la mémoire.
Cacher une fenêtre avec hide() :La méthode hide() se contente de masquer la fenêtre, les ressources nécessaires à son affichage sont conservées. La fenêtre est donc prête à être réaffichée. C'est une bonne idée de cacher les fenêtres qui sont utilisées régulièrement par l'application, leur réaffichage est plus rapide.
Détruire une fenêtre avec dispose() :La méthode dispose() restitue les ressources au système. Les ressources libérées ne concernent que les objets utilisés pour la construction de l'image, les différents composants que vous avez placés dans la fenêtre restent en mémoire comme n'importe quel autre objet. Même après avoir été détruit, on peut toujours utiliser la méthode show() pour réafficher la fenêtre (de nouvelles ressources seront alors allouées). C'est donc une très bonne idée de détruire les fenêtres lorsque vous n'en avez plus besoin.
Note :Tant qu'une fenêtre n'est pas détruite, elle ne peut pas être collectée par le ramasse miettes.
AWT :Lorsque l'on créer une fenêtre avec AWT, aucune action n'est associée à la commande de fermeture de cette fenêtre. Nous allons donc en associer une.
SWING :Par défaut, les fenêtres Swing sont cachées lorsque l'utilisateur clic sur la croix. Cette action par défaut peut facilement être remplacée avec setDefaultCloseOperation(int).
DO_NOTHING_ON_CLOSE - Ne fait aucune action par défaut.
HIDE_ON_CLOSE - Cache la fenêtre.
DISPOSE_ON_CLOSE - Détruit la fenêtre.
EXIT_ON_CLOSE - Quitte l'application.
Note : La solution utilisée avec AWT reste valable avec Swing, elle permet d'effectuer des traitements plus complexes en parallèle du traitement par défaut.
Frame & JFrame (JDK1.3 et précédants)Les classes java.awt.Frame et javax.swing.JFrame correspondent aux fenêtres du système d'exploitation, il n'est pas possible de changer l'apparence de la barre des titres ni des boutons de fermeture et d'agrandissement.
Window & JWindowContrairement aux 2 classes précédentes, java.awt.Window et javax.swing.JWindow définissent une fenêtre sans aucun cadre ni barre de titre. Elles sont donc idéales pour faire des écrans de démarrage ou des interfaces personnalisées.
A partir du JDK1.4Le jdk1.4 définit une nouvelle méthode setUndecorated(boolean) pour les classes java.awt.Frame et java.awt.Dialog. Attention : cette méthode doit être appelée avant le premier affichage de la fenêtre à l'écran.
Depuis J2SE 1.4
Pour maximiser ou iconifier votre fenêtre, vous pouvez utiliser la méthode setExtendedState de la classe Frame. Par exemple, pour maximiser de tous les côtés votre fenêtre, vous pouvez faire comme ceci :
MAXIMIZED_HORIZ : la fenêtre occupe le maximum de place horizontalement
MAXIMIZED_VERT : la fenêtre occupe le maximum de place verticalement
MAXIMIZED_BOTH : la fenêtre est maximisée de tous côtés
Avant J2SE 1.4
Vous pouvez utiliser la méthode setState de la classe Frame. Son utilisation est la même que pour setExtendedState, à la différence qu'il n'existe pas de paramètre permettant de maximiser. Si vous voulez tout de même avoir l'impression que votre fenêtre est maximisée, c'est à dire qu'elle prenne toute la place disponible à l'écran, tout en gardant visible la barre d'outils, vous pouvez faire comme ceci :
publicvoidmaximiser(Frame frame){
Toolkit kit = Toolkit.getDefaultToolkit();
//récupérationdelatailledel'écranetdesrebords
Insets insets = kit.getScreenInsets(frame.getGraphicsConfiguration());
Dimension screen = kit.getScreenSize();
//calculdeslongueursnécessairesetdelapositionint w = (int)(screen.getWidth()-insets.left-insets.right);
int h = (int)(screen.getHeight()-insets.top-insets.bottom);
int x = (int)(insets.left);
int y = (int)(insets.top);
Dimension dimension =newDimension(w,h);
//placementetredimension
frame.setSize(dimension);
frame.setLocation(x,y);
}
Si il existe plusieurs fenêtres ayant cette propriété à true, le comportement sera défini par le système. De plus, cette méthode est susceptible de lever une SecurityException.
Attention : Cette fonctionnalité n'est disponible dans l'API standard que depuis la version 1.5 de J2SE. Pour les versions précédentes, la seule possibilité est de passer par JNI et des API natives.
Afin d'ouvrir une fenêtre (ou une boite de dialogue) sur un écran particulier,
il faut utiliser un des constructeurs comportant un paramètre du type
java.awt.GraphicsConfiguration (présent dans les classes Frame
et Dialog d'AWT ainsi que JFrame et JDialog
pour Swing).
L'instance de GraphicsConfiguration s'obtient depuis le GraphicsDevice
associé à l'écran. Ainsi, pour afficher une JFrame sur le second écran
(si il est présent), on utilisera le code suivant :
Les informations sur les écrans sont disponibles grâce à la classe
java.awt.GraphicsEnvironment. Il suffit dès lors d'utiliser
la méthode getScreenDevices() pour obtenir un tableau de
java.awt.GraphicsDevice représentant les différents écrans du système :
La classe GraphicsDevice permet également d'obtenir d'autres
informations sur l'écran, tel que la résolution actuelle et la liste
des résolutions supportées...
Le "bureau" des systèmes d'exploitations peut posséder une ou plusieurs barres qui diminue l'espace d'affichage des fenêtres, mais lorsque l'on souhaite positionner précisément une fenêtre il est intéressant de déterminer cet espace afin de ne pas cacher (ou être cacher) par une de ces barres, et ainsi respecter l'interface de l'utilisateur.
Pour obtenir cette espace, il faut dans un premier temps récupérer la taille de l'écran. Il suffit ensuite de récupérer les marges de l'écran, de la manière suivante :
Ces marges correspondent à l'espace occupé par les différentes barres d'outils du système. Il est ainsi possible de déterminer l'espace utile du bureau graphique de l'utilisateur.
