Création interface graphique avec Swing : les bases


précédentsommairesuivant

4. Afficher du texte dans la fenêtre

Maintenant que l'on sait comment créer des fenêtres, il va bien falloir mettre quelque chose dedans, on va donc commencer par apprendre à afficher du texte dans une fenêtre.

Il y a deux sortes de composants textes dans une interface graphique :

  • Les composants de saisie : Ce sont les composants qui permettent à l'utilisateur de saisir du texte. On va les décrire plus loin.
  • Les composants d'affichage : Ce sont les composants qui permettent d'afficher du texte. Ce sont sur ceux-là qu'on va se concentrer. Je dis ceux-là, mais en fait, on ne va en utiliser qu'un.

Le composant pour afficher du texte en Java s'appelle un JLabel. C'est juste un composant sans réelle apparence qui affiche un texte.

Mais avant d'utiliser un JLabel, on va commencer par apprendre comment ajouter des composants dans une fenêtre. En fait, on ne va pas ajouter directement des composants dans la fenêtre. Je m'explique : Une Jframe est découpée en plusieurs parties : la fenêtre, le RootPane, le LayeredPane, la MenuBar, le ContentPane et le GlassPane. Pas besoin de s'affoller, on n'aura pas besoin de tout manipuler. Le RootPane est le container principal, c'est lui qui contient les autres, le LayeredPane forme juste un panneau composé du ContentPane et de la barre de menu (MenuBar) et le GlassPane est une couche par dessus le tout qui est utilisée pour intercepter les actions de l'utilisateur avant qu'elles ne parviennent aux composants. Et finalement, il nous reste le ContentPane qui est le composant qui contient la partie utile de la fenêtre, c'est-à-dire, celle dans laquelle on va afficher nos composants.

En Swing, on peut dire qu'il y deux types de composants, les containers et les composants. Les containers sont destinés à contenir d'autres containers et composants et les composants sont destinés à quelque chose de précis, par exemple afficher du texte ou permettre à l'utilisateur de saisir du texte. Le ContentPane est donc un container et le JLabel un composant.

Pour ajouter des composants dans la fenêtre, on va donc créer notre propre JPanel, ajouter notre JLabel à l'intérieur et ensuite indiquer à la fenêtre que notre JPanel sera le contentPane.

On va maintenant passer un chapitre suivant qui va traiter du positionnement des composants.

4.1. Le positionnement des composants

Avant d'apprendre à ajouter des composants dans notre JPanel, on va voir comment Java permet de positionner les composants à l'intérieur d'un container.

Il y a deux manières de faire ceci :

  • Le positionnement absolu : On va placer nos composant nous-même en utilisant un système de coordonnées en x et en y. Ce placement qui semble à première vue très simple, n'est en fait pas pratique du tout. Tout d'abord, si on veut ajouter des composants, il faut souvent changer une grande partie des coordonnées des autres composants et ensuite, il est quasi-impossible de faire du contenu redimensionnable avec cette méthode à moins de recalculer les coordonnées de tous les composants à chaque redimensionnement. Cette méthode n'est pas à utiliser.
  • L'utilisation d'un gestionnaire de placement : On peut aussi utiliser les gestionnaires de placements (layout) qui vont s'occuper de placer correctement nos composants dans la fenêtre en fonction des paramètres qu'on leur a donné pour certains et bien évidemment en fonction des composants eux-mêmes. C'est cette solution que nous développer maintenant. Elle se révèle bien plus souple et bien plus pratique que le positionnement absolu.

Il existe de nombreux gestionnaires de layout dans Swing, en voici quelques uns :

  • FlowLayout : C'est le layout par défaut des panels dans Swing. Il place les composants sur une ligne et recommence une nouvelle ligne à chaque fois qu'il atteint la fin de la ligne.
  • BorderLayout : Ce layout place les composants dans 5 zones du container : La zone du haut, la zone du bas, la zone de gauche, celle de droite et la zone du centre. Il est très utile pour gérer le positionement du contentpane.
  • CardLayout : Ce layout place les composants sur des couches disposées les unes sur les autres. On ne peut voir qu'une couche à la fois. On utilise surtout ce layout quand on a une série de composants qui s'affichent en fonction de quelques choses (liste déroulante, boutons, ...).
  • GridLayout : Ce composant place les composants dans une grille. Il va redimensionner les composants pour les rendre tous de la même taille. C'est surtout utile quand on a plusieurs boutons ou champs texte en colonne et ligne qui doivent avoir la même taille, par exemple, les boutons d'une calculatrice.
  • GridBagLayout : C'est le layout le plus avancé et le plus puissant. Néanmoins, c'est également le plus complexe à utiliser. Il permet de positionner les composants dans une grille et il permet d'indiquer beaucoup de données pour indiquer comment placer tel composant dans la grille. Ainsi on pourra dire à un composant de se redimensionner en hauteur mais pas en largeur et lui mettre des marges à gauche et à droite.

Il y a encore d'autres layouts dans Java et on peut également en trouver d'autres sur Internet.

Je ne vais pas détailler tous les gestionnaires de placements dans cet article. Ce n'est pas le but de cet article, je le ferai peut-être dans un prochain article. Pour le moment, on va rester avec le FlowLayout qui est très simple à utiliser.

4.2. Afficher du texte avec un JLabel

Maintenant que l'on sait tout ce qu'il faut, on va afficher du texte dans notre fenêtre. Pour faire simple, on va afficher un message de bienvenue dans notre fenêtre.

Pour commencer, on va donc créer un JPanel et lui indiquer quel layout utiliser :

 
Sélectionnez
JPanel panel = new JPane();
panel.setLayout(new FlowLayout());

Rien de compliqué pour le moment, donc.

On va ensuite ajouter dans ce panel notre JLabel de bienvenue :

 
Sélectionnez
JLabel label = new JLabel("Bienvenue dans ma modeste application");
 
panel.add(label);

On a donc passé la chaîne à afficher au constructeur de JLabel. On aurait aussi pu utiliser la méthode setText pour indiquer au JLabel le texte à afficher.

On peut afficher du texte multiligne dans un JLabel avec de l'HTML. Il suffit pour cela de mettre un texte comme celui-ci : "<html><body>Ligne 1<br />Ligne 2</body></html>"

On a ensuite utilisé la méthode add pour ajouter le label dans le panel. Ensuite le gestionnaire de placement se chargera du reste. Comme vous pouvez le voir, c'est un jeu d'enfant.

On va maintenant reprendre le code la première fenêtre qu'on faîte, qu'on va renommer en FenetreTexte. On pourrait modifier le contentpane directement dans le constructeur, dans le build() ou dans une méthode à part. Personnellement, je fais une méthode à part qui créée et qui me renvoie le panel et je l'appelle depuis la méthode build. Voilà donc ce que ça nous donnerait :

 
Sélectionnez
import javax.swing.JFrame;
 
public class FenetreTexte extends JFrame{
 
	public FenetreTexte(){
		super();
 
		build();//On initialise notre fenêtre
	}
 
	private void build(){
		setTitle("Fenêtre qui affiche du texte"); //On donne un titre à l'application
		setSize(320,240); //On donne une taille à notre fenêtre
		setLocationRelativeTo(null); //On centre la fenêtre sur l'écran
		setResizable(true); //On permet le redimensionnement
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //On dit à l'application de se fermer lors du clic sur la croix
		setContentPane(buildContentPane());
	}
}

La seule chose qui ait vraiment changé est le fait qu'on appelle la méthode buildContentPane pour modifier le ContentPane. J'ai également modifié le titre et permis le redimensionnement pour que vous voyiez comment se comporte le FlowLayout.

On va maintenant coder notre méthode buildContentPane() avec ce qu'on a appris avant :

 
Sélectionnez
private JPanel buildContentPane(){
	JPanel panel = new JPanel();
	panel.setLayout(new FlowLayout());
 
	JLabel label = new JLabel("Bienvenue dans ma modeste application");
 
	panel.add(label);
 
	return panel;
}	

Cette fois-ci, on va directement ajouter la méthode main dans la classe Fenetre pour avoir moins de classes :

Si on met cette méthode dans FenetreTexte et qu'on la lance, voici ce que ça devrait vous donner :

Affichage de texte
Affichage de texte

Le texte s'ajoute donc automatiquement sur la première ligne de notre fenêtre.

Code complet : FenetreTexte

4.3. Application au projet

Comme vous l'avez vu, c'est vraiment très simple d'afficher du texte dans une JFrame. On va maintenant afficher du texte dans notre Calculatrice. Pour le moment, comme rien d'autre n'est fait, on va juste afficher "Résultat : Pas encore calculé". De plus, on va mettre un fond blanc à notre fenêtre plutôt que ce gris triste qui apparaît par défaut. Pour cela, on va utiliser la méthode setBackground(Color) sur notre JPanel.

Voici donc ce que donnerait notre classe modifiée :

 
Sélectionnez
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;
 
public class CalculatriceFenetre extends JFrame{
 
	public CalculatriceFenetre(){
		super();
 
		build();//On initialise notre fenêtre
	}
 
	private void build(){
		setTitle("Calculatrice"); //On donne un titre à l'application
		setSize(400,200); //On donne une taille à notre fenêtre
		setLocationRelativeTo(null); //On centre la fenêtre sur l'écran
		setResizable(false); //On interdit la redimensionnement de la fenêtre
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //On dit à l'application de se fermer lors du clic sur la croix
		setContentPane(buildContentPane());
	}
 
	private JPanel buildContentPane(){
		JPanel panel = new JPanel();
		panel.setLayout(new FlowLayout());
		panel.setBackground(Color.white);
 
		JLabel label = new JLabel("Résultat : Pas encore calculé");
 
		panel.add(label);
 
		return panel;
	}
}

On a également changé la couleur de fond de notre JPanel pour que le résultat soit plus joli.

La classe Calculatrice ne change pas. Voici donc notre calculatrice en l'état :

Notre calculatrice
Notre calculatrice

Vous pouvez maintenant essayer de modifier les différents paramètres que nous avons définis pour ce label et essayer d'ajouter d'autres JLabel à votre fenêtre pour vous familiariser avec ce composant, qui reste très simple et basique.


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2009 Baptiste Wicht. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.