-
Notifications
You must be signed in to change notification settings - Fork 0
Les frames
L'objet JFrame
Avant de nous lancer à corps perdu dans cette partie, vous devez savoir de quoi nous allons nous servir. Dans ce cours, nous traiterons dejavax.swinget dejava.awt. Nous n'utiliserons pas de composantsawt, nous travaillerons uniquement avec des composantsswing; en revanche, des objets issus du packageawtseront utilisés afin d'interagir et de communiquer avec les composantsswing. Par exemple, un composant peut être représenté par un bouton, une zone de texte, une case à cocher, etc.
Afin de mieux comprendre comment tout cela fonctionne, vous devez savoir que lorsque le langage Java a vu le jour, dans sa version 1.0, seulawtétait utilisable ;swingn'existait pas, il est apparu dans la version 1.2 de Java (appelée aussi Java 2). Les composantsawtsont considérés comme lourds (on dit aussiHeavyWeight) car ils sont fortement liés au système d'exploitation, c'est ce dernier qui les gère. Les composantsswing, eux, sont comme dessinés dans un conteneur, ils sont dit légers (on dit aussiLightWeight) ; ils n'ont pas le même rendu à l'affichage, car ce n'est plus le système d'exploitation qui les gère. Il existe également d'autres différences, comme le nombre de composants utilisables, la gestion des bordures...
Pour toutes ces raisons, il est très fortement recommandé de ne pas mélanger les composantsswingetawtdans une même fenêtre ; cela pourrait occasionner des conflits ! Si vous associez les deux, vous aurez de très grandes difficultés à développer une IHM stable et valide. En effet,swingetawtont les mêmes fondements mais diffèrent dans leur utilisation.
Cette parenthèse fermée, nous pouvons entrer dans le vif du sujet. Je ne vous demande pas de créer un projet contenant une classemain, celui-ci doit être prêt depuis des lustres ! Pour utiliser une fenêtre de typeJFrame, vous devez l'instancier, comme ceci :
import javax.swing.JFrame;
public class Test {
public static void main(String[] args){
JFrame fenetre = new JFrame();
}
}
Lorsque vous exécutez ce code, vous n'obtenez rien, car par défaut, votreJFramen'est pas visible. Vous devez donc lui dire « sois visible » de cette manière :
import javax.swing.JFrame;
public class Test {
public static void main(String[] args){
JFrame fenetre = new JFrame();
fenetre.setVisible(true);
}
}
Ainsi, lorsque vous exécutez ce code, vous obtenez la figure suivante. Première fenêtre Première fenêtre
À toutes celles et ceux qui se disent que cette fenêtre est toute petite, je réponds : « Bienvenue dans le monde de la programmation événementielle ! » Il faut que vous vous y fassiez, vos composants ne sont pas intelligents : il va falloir leur dire tout ce qu'ils doivent faire.
Pour obtenir une fenêtre plus conséquente, il faudrait donc :
qu'elle soit plus grande ;
qu'elle comporte un titre (ce ne serait pas du luxe !) ;
qu'elle figure au centre de l'écran, ce serait parfait ;
que notre programme s'arrête réellement lorsqu'on clique sur la croix rouge, car, pour ceux qui ne l'auraient pas remarqué, le processus Eclipse tourne encore même après la fermeture de la fenêtre.
Pour chacun des éléments que je viens d'énumérer, il y a aura une méthode à appeler afin que notreJFramesache à quoi s'en tenir. Voici d'ailleurs un code répondant à toutes nos exigences :
import javax.swing.JFrame;
public class Test {
public static void main(String[] args){
JFrame fenetre = new JFrame();
//Définit un titre pour notre fenêtre
fenetre.setTitle("Ma première fenêtre Java");
//Définit sa taille : 400 pixels de large et 100 pixels de haut
fenetre.setSize(400, 100);
//Nous demandons maintenant à notre objet de se positionner au centre
fenetre.setLocationRelativeTo(null);
//Termine le processus lorsqu'on clique sur la croix rouge
fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Et enfin, la rendre visible
fenetre.setVisible(true);
}
}
Voyez le rendu de ce code en figure suivante. Une fenêtre plus adaptée Une fenêtre plus adaptée
Afin de ne pas avoir à redéfinir les attributs à chaque fois, je pense qu'il serait utile que nous possédions notre propre objet. Comme ça, nous aurons notre propre classe !
Pour commencer, effaçons tout le code que nous avons écrit dans notre méthodemain. Créons ensuite une classe que nous allons appelerFenetreet faisons-la hériter deJFrame. Nous allons maintenant créer notre constructeur, dans lequel nous placerons nos instructions. Cela nous donne :
import javax.swing.JFrame;
public class Fenetre extends JFrame {
public Fenetre(){
this.setTitle("Ma première fenêtre Java");
this.setSize(400, 500);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
Ensuite, vous avez le choix : soit vous conservez votre classe contenant la méthodemainet vous créez une instance deFenetre, soit vous effacez cette classe et vous placez votre méthodemaindans votre classeFenetre. Mais dans tous les cas, vous devez créer une instance de votreFenetre. Personnellement, je préfère placer ma méthodemaindans une classe à part… Mais je ne vous oblige pas à faire comme moi ! Quel que soit l'emplacement de votremain, la ligne de code suivante doit y figurer :
Fenetre fen = new Fenetre();
Exécutez votre nouveau code, et… vous obtenez exactement la même chose que précédemment. Vous conviendrez que c'est tout de même plus pratique de ne plus écrire les mêmes instructions à chaque fois. Ainsi, vous possédez une classe qui va se charger de l'affichage de votre futur programme. Et voici une petite liste de méthodes que vous serez susceptibles d'utiliser. Positionner la fenêtre à l'écran
Nous avons déjà centré notre fenêtre, mais vous voudriez peut-être la positionner ailleurs. Pour cela, vous pouvez utiliser la méthodesetLocation(int x, int y). Grâce à cette méthode, vous pouvez spécifier où doit se situer votre fenêtre sur l'écran. Les coordonnées, exprimées en pixels, sont basées sur un repère dont l'origine est représentée par le coin supérieur gauche (figure suivante). Coordonnées sur votre écran Coordonnées sur votre écran
La première valeur de la méthode vous positionne sur l'axe x, 0 correspondant à l'origine ; les valeurs positives déplacent la fenêtre vers la droite tandis que les négatives la font sortir de l'écran par la gauche. La même règle s'applique aux valeurs de l'axe y, si ce n'est que les valeurs positives font descendre la fenêtre depuis l'origine tandis que les négatives la font sortir par le haut de l'écran. Empêcher le redimensionnement de la fenêtre
Pour cela, il suffit d'invoquer la méthodesetResizable(boolean b):falseempêche le redimensionnement tandis quetruel'autorise. Garder la fenêtre au premier plan
Il s'agit là encore d'une méthode qui prend un booléen en paramètre. Passertruelaissera la fenêtre au premier plan quoi qu'il advienne,falseannulera cela. Cette méthode estsetAlwaysOnTop(boolean b). Retirer les contours et les boutons de contrôle
Pour ce faire, il faut utiliser la méthodesetUndecorated(boolean b).
Je ne vais pas faire le tour de toutes les méthodes maintenant, car de toute façon, nous allons nous servir de bon nombre d'entre elles très prochainement.Cependant, je suppose que vous aimeriez bien remplir un peu votre fenêtre. Je m'en doutais, mais avant il vous faut encore apprendre une bricole. En effet, votre fenêtre, telle qu'elle apparaît, vous cache quelques petites choses !
Vous pensez, et c'est légitime, que votre fenêtre est toute simple, dépourvue de tout composant (hormis les contours). Eh bien vous vous trompez ! UneJFrameest découpée en plusieurs parties superposées, comme le montre la figure suivante. Structure d'une JFrame Structure d'une JFrame
Nous avons, dans l'ordre :
la fenêtre ;
leRootPane(en vert), le conteneur principal qui contient les autres composants ;
leLayeredPane(en violet), qui forme juste un panneau composé du conteneur global et de la barre de menu (MenuBar) ;
laMenuBar(en orange), la barre de menu, quand il y en a une ;
le content pane (en rose) : c'est dans celui-ci que nous placerons nos composants ;
leGlassPane(en transparence), couche utilisée pour intercepter les actions de l'utilisateur avant qu'elles ne parviennent aux composants.
Pas de panique, nous allons nous servir uniquement du content pane. Pour le récupérer, il nous suffit d'utiliser la méthodegetContentPane()de la classeJFrame. Cependant, nous allons utiliser un composant autre que le content pane : unJPaneldans lequel nous insérerons nos composants.
Il existe d'autres types de fenêtre : laJWindow, uneJFramesans bordure et non draggable (déplaçable), et laJDialog, une fenêtre non redimensionnable. Nous n'en parlerons toutefois pas ici.