Création de nouvelles fenêtres avec ou sans cadre

Fenêtre et cadre de fenêtre
Chapitres traités
Fenêtres et cadres
Dans cette étude, nous nous concentrons uniquement sur la mise en oeuvre de nouvelles fenêtres avec ou sans cadres. Nous en
profiterons pour connaître leurs différentes constitutions, mais aussi comment interragir avec le bureau et la barre de tâche.
Fenêtres et cadres
Les fenêtres et les cadres sont les conteneurs de plus niveau des composants Java. JWindow n'est rien d'autre qu'un plein écran graphique d'affichage dans le système de
fenêtrage. Les fenêtres ne comportent pas fioritures : elles conviennent surtout pour faire surgir des écrans et des fenêtres popup. De son côté, JFrame est une classe fille
de JWindow, pourvue d'une bordure et pouvant contenir une barre de menu. Il est également possible de déplacer un cadre sur l'écran et de le redimensionner, à l'aide des
contrôles habituels de l'environnement de fenêtrage.
L'exemple ci-dessous présente un cadre JFrame à gauche et une fenêtre JWindow à droite :
package fenêtres;
import javax.swing.*;
public class Fenêtres {
public static void main(String[] args) {
JFrame cadre = new JFrame("Cadre de fenêtre");
cadre.setSize(300, 250);
cadre.setLocation(150, 100);
JWindow fenêtre = new JWindow();
fenêtre.setSize(300, 250);

fenêtre.setLocation(500, 100);
cadre.setVisible(true);
fenêtre.setVisible(true);
}
}
Décrivons le fonctionnement de ce petit programme :
1. Le constructeur de JFrame peut prendre un argument String indiquant le titre affiché dans la barre de titre. Il est également possible de créer un JFrame sans titre,
puis d'appeler ensuite la méthode setTitle() pour en fournir un ultérieurement.
2. La taille et la position de JFrame et de JWindow sur votre bureau sont déterminées par les méthodes que nous connaissons déjà, c'est-à-dire setSize() et
setLocation().
3. JWindow ne possédant pas de barre de titre, le constructeur de JWindow ne comporte donc pas d'arguments.
4. Une fois que vous avez définis votre JFrame et votre JWindow, nous appelons setVisible(true)pour les afficher à l'écran. La méthode setVisible() revient
immédiatement, sans blocage. Par bonheur, notre application ne se termine pas, même après avoir atteint la fin de la méthode main(), puique les fenêtres sont
encore visibles. Vous pouvez fermer le JFrame en cliquant sur l'icône de fermeture de la barre de titre. Attention, par défaut, JFrame se cache lorsque nous
cliquons dessus, en appelant la méthode setVisible(false), mais ne quitte toujours pas l'application. Heureusement, nous verrons que nous pouvons modifier ce
comportement en appelant la méthode adéquate setDefaultCloseOperation().
5. Il est toutefois impossible de fermer un JWindow dans l'application. Pour mettre fin à votre à l'exécution de l'application Fenêtres, vous devez saisir Crtl-C ou la
touche destinée à tuer un processus sur votre machine. Du coup, JWindow sera plutôt utilisé par un autre JFrame et sera très rarement la fenêtre principale d'une
application.
En Java, une fenêtre de haut niveau, c'est-à-dire une fenêtre qui n'est pas contenue dans une autre fenêtre, est appelée frame (cadre ou fenêtre d'encadrement). Pour
représenter ce niveau supérieur la bibliothèque AWT possède une classe nommée Frame. La version Swing de cette classe est baptisée JFrame, qui étend la classe
Frame et désigne l'un des rares composants Swing qui ne soient pas dessiné sur un canevas (grille). Du coup, les éléments de décoration de la fenêtre (boutons,
barre de titre, icônes, etc.) ne sont pas dessinés par Swing, mais par le système de fenêtrage du système d'exploitation de l'utilisateur.
Les cadres sont des exemples de conteneurs. Cela signifie qu'ils peuvent contenir d'autres composants d'interface tels que les boutons et des champs de texte. De
toute façon, tous les autres composants et conteneurs doivent, à un certain niveau, se trouver dans un JWindow ou un JFrame. Les applets JApplet sont une sorte
de Container. Même les applets doivent être hébergées dans un dans cadre ou une fenêtre, bien qu'en général, nous ne voyons pas son cadre parent car il fait partie
du navigateur qui affiche l'applet.
Mise en place d'un cadre
Je reviendrais plutard sur la fenêtre JWindow. Nous allons maintenant étudier les méthodes employées le plus fréquemment lorsque nous travaillons avec un composant
JFrame. Nous allons procéder par étapes, de l'ossature d'un cadre de fenêtre minimal jusqu'à que ayons une fenêtre relativement sophistiquée.
Création d'un cadre visible où nous pouvons quitter directement l'application
Dans l'exemple précédent, nous avons simplement créé un objet de type JFrame et nous avons utilisé les fonctionnalités présentes dans cette classe. Mais pour que notre
programme présente un intérêt, il va de soi qu'il faut lui associer des fonctionnalités ou des attributs supplémentaires ; de fait, la fenêtre devra pouvoir réagir à certains
événements. Pour cela, il nous faudra généralement définir notre propre classe dérivée de JFrame et créer un objet de ce nouveau type. Par ailleurs, il ne sera plus
nécessaire de préciser à chaque fois le nom de l'objet de type JFrame pour faire appel à la méthode requise.
Voici donc un exemple de codage minimum requis, qui permet de constituer une fenêtre principale d'application placée à l'endroit voulu, avec la possibilité de
quitter l'application quand l'utilisateur le désire.
package cadre;
import javax.swing.JFrame;
public class Fenêtre extends JFrame {
public Fenêtre(String titre) {
super(titre);
setSize(300, 200);

setLocation(100, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Fenêtre("Première fenêtre") ;
}
}
ou -----------------------------------------------------
public class Fenêtre extends JFrame {
public Fenêtre() {
setTitle("Première fenêtre");
setBounds(100, 100, 300, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Fenêtre();
}
}
Bien que nous n'ayons rien prévu de particulier, l'utilisateur peut manipuler cette fenêtre comme n'importe qu'elle fenêtre graphique d'un logiciel du commerce, et en
particulier : la retailler, la redimmensionner, la réduire à une icône dans la barre de tâche. Ces fonctionnalités, communes à toutes les fenêtres, sont prises en charge
par la classe JFrame elle-même. Vous n'avez donc pas à vous soucier de la gestion des événements correspondants tels que le clic sur l'une des cases systèmes, le
glissé (drag) d'une bordure ...
Après ce commentaire, analysons notre code source et voyons la liste des méthodes utiles cette classe JFrame :
1. super() : Nous faisons ici explicitement appel au constructeur de la classe JFrame qui accepte un paramètre de type String qui précise tout simplement le titre de
la fenêtre.
2. setTitle() : Au lieu, de faire un appel explicite au constructeur de la classe de base, il est tout à fait possible d'utiliser cette méthode après coup.
3. setSize() : Par défaut, un cadre a une taille assez peu utile de 0 x 0 pixels. Il faut donc utiliser cette méthode pour spécifier la taille requise.
4. setLocation() : cette méthode de la classe Component peut être utilisée pour un JFrame ou un JWindow afin de définir sa position à l'écran. Les coordonnées x et
ysont relatives à l'origine de l'écran (le coin supérieur gauche). Attention, l'axe des abscisses est orientée vers la droite, celui des ordonnées vers le bas (nous
n'avons à pas affaire à un système orthonormé usuel).
5. setBounds() : nous pouvons aussi utiliser une méthode qui positionne et propose les dimensions voulues en une seule fois.
6. setDefaultCloseOperation() : Nous indiquons ensuite ce qui doit se passer lorsque l'utilisateur ferme ce cadre. Dans ce cas précis, le programme doit sortir. Dans
d'autres programmes comprenant éventuellement plusieurs cadres, vous ne souhaiterez pas la sortie du programme si l'utilisateur ferme seulement l'un des
cadres. Par défaut, un cadre est masqué - setVisible(false)- lorsque l'utilisateur le ferme, mais le programme ne se termine pas pour autant. Nous pouvons imposer
un autre comportement lors de la fermeture de la fenêtre, en appelant cette méthode avec l'un des arguments suivants :
DO_NOTHING_ON_CLOSE :ne rien faire. (Intéressant si vous désirez mettre en place une boîte de confirmation de sortie).
DISPOSE_ON_CLOSE :détruire l'objet fenêtre.
EXIT_ON_CLOSE :terminer l'application.
HIDE_ON_CLOSE :cacher la fenêtre (comportement par défaut).
7. setVisible() : Le simple fait de construire un cadre ne l'affiche pas automatiquement. Les cadres sont au départ invisibles. Cela permet au programmeur d'y ajouter
des composants avant l'affichage. Pour afficher le cadre, vous devez impérativement appeler cette méthode.
Positionnement et réglages du cadre de la fenêtre
La classe JFrame ne fournit que peu de méthodes capables de modifier l'aspect d'un cadre. Cependant, grâce à l'héritage, les diverses superclasses de JFrame proposent la
plupart des méthodes permettant d'agir sur la taille et la position d'un cadre ainsi que quelques petits ajouts intéressants.
C'est généralement dans la classe Component (ancêtre de tous les objets d'interface utilisateur graphique) ou dans la classe Window (superclasse du parent de la
classe Frame) que l'on recherche les méthodes permettant de modifier la taille et la position des cadres.
Les plus importantes sont les suivantes :
java.awt.Component
boolean isVisible()
Renvoie true si le composant est visible. Les composants sont initialement visibles par défaut, à l'exception des composants de haut niveau tels que JFrame.
void setVisible(boolean visible)
Affiche ou cache le composant, selon la valeur booléenne proposée (respectivement true ou false).
boolean isShowing()
Vérifie que le composant s'affiche à l'écran. Pour cela, le composant doit être visible et son éventuel conteneur doit être également affiché.
boolean isEnabled()
void setEnabled(boolean activation)
Obtient ou définit l'activité du composant. Un composant activé peut recevoir le focus du clavier. Les composants sont initialement activés.
boolean isOpaque()
void setOpaque(boolean visibilité)
Obtient ou définit une opacité, ou inversement une transparence du composant.
Point getLocation()
Point getLocationOnScreen()
void setLocation(Point p)
void setLocation(int x,int y)
Obtient ou définit la position actuelle du composant par rapport au composant parent. La méthode getLocationOnScreen() précise les coordonnées par
rapport à l'écran.

Dimension getSize()
void setSize(int largeur,int hauteur)
Obtient ou définit la taille actuelle du composant. Un gestionnaire de placement peut modifier la taille d'un composant même après que vous l'avez définie.
Pour changer la taille qu'un composant veut avoir, utilisez alors la méthode setPreferedSize(). D'autres méthodes de Component permettent de définir son
emplacement, mais cette tâche est normalement dévolue à un gestionnaire de placement.
Rectangle getBounds()
void setBounds(Rectangle zonePréférée)
void setBounds(int x,int y, int largeur,int hauteur)
Obtient ou définit à la fois la position et la taille actuelle du composant. Lorsque le composant doit être automatiquement redimensionnné, cette dernière
méthode est systématiquement appelée.
java.awt.Window
void toFront()
Affiche cette fenêtre par-dessus toutes les autres.
void toBack()
Place cette fenêtre au-dessous de la pile des fenêtres du bureau et réorganise les autres fenêtres visibles.
boolean isLocationByPlatform()
void setLocationByPlatform(boolean valider)
Récupère ou défini la propriété locationByPlatform. Lorsque la propriété est définie avant que la fenêtre ne soit affichée, la plate-forme choisit un
emplacement adéquat, légèrement décallée de la dernière qui s'est affichée.
void setLocationRelativeTo(Component référence)
Cette méthode permet de positionner la fenêtre par rapport à un autre composant. Si ce composant n'existe pas ou si vous placez la valeur null, la fenêtre
est alors automatiquement centrée.
java.awt.Frame
void setResizable(boolean visible)
Détermine si l'utilisateur peut modifier la taille du cadre.
void setTitle(String titre)
Affiche le texte de la chaîne passée en argument à la barre de titre du cadre.
void setIconImage(Image icône)
Spécifie l'icône de l'application qui est alors visible sur bord supérieur gauche de la fenêtre ou dans la barre de tâche lorsque la fenêtre est réduite sous
forme d'icône.
boolean isUndecorated()
void setUndecorated(boolean décoration)
Indique si les décorations du cadre sont présentes ou les supprime si le paramètre passé en argument est true.
int getExtendedState()
void setExtendedState(int état)
Récupère ou définit l'état de la fenêtre. Voici les différents états possibles :
-- normal :Frame.NORMAL
-- icônifié :Frame.ICONIFIED
-- maximum en horizontal :Frame.MAXIMIZED_HORIZ
-- maximum en vertical :Frame.MAXIMIZED_VERT
-- plein écran :Frame.MAXIMIZED_BOTH
java.awt.Toolkit
static Toolkit getDefaultToolkit()
Renvoie la boîte à outils par défaut.
Dimension getScreenSize()
Renvoie la taille de l'écran.
Image getImage(String fichierImage)
Image getImage(URL url)
Charge une image à partir du nom du fichier spécifié en argument ou à partir de son URL.
Au vue de ces différentes méthodes, nous pouvons rajouter quelques commentaires supplémentaires :
1. Pour spécifier un placement de fenêtre classique, nous connaissons déjà toutes les méthodes issues de Component comme setSize(),setLocation() et setBounds
().
2. Il est possible de démarrer votre application pour que cette dernière prennent systématiquement tout l'écran. Il est alors judicieux d'utiliser la méthode
setExtendedState(Frame.MAXIMIZED_BOTH).
3. Nous pouvons préférer imposer une taille de fenêtre qui ne bouge plus durant toute sa durée de vie, prenez alors la méthode setResizable(false).
4. Une méthode particulière est certainement setUndecorated(true)qui enlève tout le pourtour du cadre de la fenêtre. Nous nous retrouvons alors exactement comme
dans le cas d'un JWindow.
5. Nous pouvons aussi donner le contrôle du placement au système de fenêtres. Si nous appelons la setLocationByPlatform(true)avant d'afficher le cadre, le
système de fenêtres choisit l'emplacement (mais non la taille), généralement avec un léger décalage par rapport à la dernière fenêtre. Dans la plupart des cas, cette
méthode est plus intéressante que la simple setLocation().
6. Toujours dans le positionnement d'une fenêtre, il est également possible d'utiliser la méthode setLocationRelativeTo() qui par nature positionne le cadre par
rapport à un autre composant. L'intérêt ici est de faire en sorte que la fenêtre s'affiche automatiquement au centre de l'écran en proposant tout simplement la
valeur null à cette méthode.
Pour vous donner une idée de ce que nous pouvons faire avec une fenêtre, nous terminerons ce chapitre en proposant un programme qui positionne le cadre au
centre de l'écran.
Pour connaître la taille de l'écran, nous devons utiliser la classe Toolkit. La classe Toolkit est un dépotoir pour diverses méthodes qui interfacent le système de
fenêtrage natif. La méthode qui nous intéresse ici est la méthode getScreenSize(), qui renvoie la taille de l'écran sous forme d'un objet Dimension (un objet de ce
type stocke simultanément une largeur et une hauteur dans des attributs publics appelés respectivement width et height.

Nous fournissons également une icône à notre cadre. Comme la récupération des images dépend aussi du système, nous employons également la boîte à outils pour
charger une image, à l'aide de la méthode getImage(). Ensuite, nous affectons l'image à l'icône du cadre au travers de la méthode setIconImage().
Les méthodes getScreenSize() et getImage() de la classe Toolkit sont des méthodes non statiques. Vous devez donc créer au préalable un objet représentant la boîte
à outil en utilisant la méthode statique getDefaultToolkit().
package cadre;
import java.awt.*;
import javax.swing.JFrame;
public class Fenêtre extends JFrame {
public Fenêtre() {
setTitle("Cadre centré à l'écran");
Toolkit kit = Toolkit.getDefaultToolkit();
Dimension dimensionEcran = kit.getScreenSize();
int largeur = dimensionEcran.width;
int hauteur = dimensionEcran.height;
setBounds((largeur-300)/2, (hauteur-200)/2, 300, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setIconImage(kit.getImage("icone.gif"));
setResizable(false);
setVisible(true);
}
public static void main(String[] args) {
new Fenêtre() ;
}
}
Comme nous l'avons vu plus haut, de façon plus simple, pour positionner votre cadre au centre de l'écran, il est préférable d'utiliser la méthode
setLocationRelativeTo(null).
Codage correspondant
package cadre;
import java.awt.*;
import javax.swing.JFrame;
public class Fenêtre extends JFrame {
public Fenêtre() {
setTitle("Cadre centré à l'écran");
setLocationRelativeTo(null);
setSize(300, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setIconImage(new ImageIcon("icone.gif").getImage("icone.gif"));
setResizable(false);
setVisible(true);
}
public static void main(String[] args) {
new Fenêtre() ;
}
}
Utilisation de ressources
Restons quelques instants sur ce programme. Nous remarquons que nous avons un problème de déploiement pour l'icône. En effet, cette dernière doit être utilisée à côté
du fichier d'archive, ce qui est assez gênant. L'idéal serait qu'elle soit directement intégrée dans l'archive elle-même. Pour cela, vous devez alors mettre en oeuvre le
mécanisme des ressources. Ainsi, pour obtenir un seul fichier d'archive afin que le déploiement en soit facilité, il est nécessaire que l'icône soit plutôt considérée comme
une ressource.