← (précédent) D.9 Evènements sur les boites dialogue
D.11 Exercices corrigés (1)
Accueil S O M M A I R E

D.10 Les gestionnaires de mise en forme

Un gestionnaire de mise en forme permet de place des composants graphiques d'une certaine façon dans une fenêtre.

Il existe 6 gestionnaires de mise en forme :

1. Le gestionnaire BorderLayout.
2. Le gestionnaire FlowLayout.
3. Le gestionnaire CardLayout.
4. Le gestionnaire GridLayout.
5. Le gestionnaire BoxLayout.
6. Le gestionnaire GridBagLayout.

Le gestioonaire BorderLayout est utilisé par défaut en dehors de toute précision.

D.10.1 Le gestionnaire BorderLayout

 Exemple 1 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton;
7.          public Fenetre(String titre)
8.          {
9.               setTitle(titre);
10.              setSize(500, 300);
11.              Container c = getContentPane();
12.              bouton = new JButton("BOUTON");
13.              c.add(bouton);
14.              setLocationRelativeTo(this.getParent()); 
15.              setDefaultCloseOperation(3);
16.         }
17.    }
18.       
19.    public class TesterGestionnaire
20.    {
21.         public static void main(String [] args)
22.         {
23.              JFrame f = new Fenetre("mise en forme");
24.              f.setVisible(true);
25.              
25.         }
26.    }
Compilez puis exécutez ce programme. Il sera affiché :

Une fenêtre sur la quelle on lit le mot "BOUTON".

Explications :

On a placé le bouton créé en ligne 12 dans le conteneur (ligne 13) sans indiquer le type de gestionnaire de mise en forme. Résultat : le bouton occupe la totalité de la surface de la fenêtre.

C'est le gestionnaire BorderLayout qui est utilisé par défaut. Toutes les bordure (Border) de la fenêtre sont occupées par le bouton.

Il en sera ainsi pour n'importe quel composant. Remplacez le bouton par un autre composant. Le résultat sera le même.
 Exemple 2 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton;
7.          public Fenetre(String titre)
8.          {
9.               setTitle(titre);
10.              setSize(500, 300);
11.              Container c = getContentPane();
12.              c.setLayout(new BorderLayout() );
13.              bouton = new JButton("BOUTON");
14.              c.add(bouton);
15.              setLocationRelativeTo(this.getParent()); 
16.              setDefaultCloseOperation(3);
17.         }
18.    }
19.       
20.    public class TesterGestionnaire2
21.    {     
22.         public static void main(String [] args)
23.         {    
24.              JFrame f = new Fenetre("mise en forme");
25.              f.setVisible(true);
25.         }
26.    }
Compilez puis exécutez ce programme. Il sera affiché la même chose que dans l'exemple précédent.

Explications :

Quoi de neuf ici ? Le simple fait d'indiquer le type de gestionnaire (ligne 12). C'est BorderLayout. Mais ça ne change rien. Indiquer le gestionnaire BorderLayout sans autre précision ne change rien à la donne. La position priviligiée d'un composant mis dans un conteneur grâce au gestionnaire BorderLayout est toujours le centre. C'est la position par défaut en dehors de toute précision.
 Exemple 3 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton;
7.          public Fenetre(String titre)
8.          {
9.               setTitle(titre);
10.              setSize(500, 300);
11.              Container c = getContentPane();
12.              c.setLayout(new BorderLayout() );
13.              bouton = new JButton("BOUTON");
14.              c.add(bouton, BorderLayout.NORTH);
15.              setLocationRelativeTo(this.getParent()); 
16.              setDefaultCloseOperation(3);
17.         }
18.    }
19.       
20.    public class TesterGestionnaire3
21.    {     
22.         public static void main(String [] args)
23.         {    
24.              JFrame f = new Fenetre("mise en forme");
25.              f.setVisible(true);
25.         }
26.    }
Compilez puis exécutez ce programme. Il sera affiché une fenêtre dans laquelle le bouton est affiché en haut.

Explications :

Cette fois, j'ai apporté une précision. La méthode add() est utilisée avec un argument supplémentaire. C'est la constante de type String BorderLayout.NORTH dont la valeur est "North". Ceci permet de placer le bouton au nord de la fenêtre. Autrement dit, tout en haut de la fenêtre.

5 possibilités :

public static String BorderLayout.NORTH = "North";
public static String BorderLayout.SOUTH = "South";
public static String BorderLayout.EAST = "East";
public static String BorderLayout.WEST = "West";
public static String BorderLayout.CENTER = "Center";

Vous pouvez utiliser soit les noms des constantes (en gras), soit leurs valeurs.
 Exemple 4 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          public Fenetre(String titre)
8.          {
9.               setTitle(titre);
10.              setSize(500, 300);
11.              Container c = getContentPane();
12.              c.setLayout(new BorderLayout() );
13.              bouton1 = new JButton("BOUTON1");
14.              c.add(bouton1, BorderLayout.NORTH);
15.              bouton2 = new JButton("BOUTON2");
16.              c.add(bouton2, "South");
17.              bouton3 = new JButton("BOUTON3");
18.              c.add(bouton3, "East");
19.              bouton4 = new JButton("BOUTON4");
20.              c.add(bouton4, "West");
21.              bouton5 = new JButton("BOUTON5");
22.              c.add(bouton5, "Center");
23.              setLocationRelativeTo(this.getParent()); 
24.              setDefaultCloseOperation(3);
25.         }
26.    }
27.       
28.    public class TesterGestionnaire4
29.    {     
29.         public static void main(String [] args)
30.         {    
31.              JFrame f = new Fenetre("mise en forme");
32.              f.setVisible(true);
33.         }
34.    }
Compilez puis exécutez ce programme. Il sera affiché :

Une fenêtre dans laquelle on voit 5 boutons qui occupent les 5 positions : North (haut), Sud(Bas), East(droite), West(gauche) et Center(centre).

Explications :

Chaque bouton créé est ajouté au conteneur par la méthode add() avec 2 arguments : le nom du bouton et sa position.
Par défaut, les composants sont espacés de 5 pixels. Vous pouvez changer cela en précisant l'espace entre les composants. Cela se fait en créeant le nouvel objet BorderLayout. Regardez ligne 12 : c.setLayout(new BorderLayout() ); Il suffit d'ajouter 2 arguments de type int au constructeur. Le premier étant l'espace horizontal entre les composants et le deuxième étant l'espace vertical.
Par exemple : c.setLayout(new BorderLayout(10, 15) );

Remplacez cette instruction par celle de la ligne 12. Recompilez alors puis exécutez à nouveau. L'espace entre les composants a changé. 10 pixels entre BOUTON3 et BOUTON4 (espace horizontal) et 15 pixels entre BOUTON1 et BOUTON4 (espace vertical).

D.10.2 Le gestionnaire FlowLayout

 Exemple 5 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          public Fenetre(String titre)
8.          {
9.               setTitle(titre);
10.              setSize(300, 300);
11.              Container c = getContentPane();
12.              c.setLayout(new FlowLayout() );
13.              bouton1 = new JButton("BOUTON1");
14.              c.add(bouton1);
15.              bouton2 = new JButton("BOUTON2");
16.              c.add(bouton2);
17.              bouton3 = new JButton("BOUTON3");
18.              c.add(bouton3);
19.              bouton4 = new JButton("BOUTON4");
20.              c.add(bouton4);
21.              bouton5 = new JButton("BOUTON5");
22.              c.add(bouton5);
23.              setLocationRelativeTo(this.getParent()); 
24.              setDefaultCloseOperation(3);
25.         }
26.    }
27.       
28.    public class TesterGestionnaire4
29.    {     
30.         public static void main(String [] args)
31.         {    
32.              JFrame f = new Fenetre("mise en forme");
33.              f.setVisible(true);
34.         }
35.    }
Compilez puis exécutez ce programme. Il sera affiché :

Une fenêtre dans laquelle on voit 5 boutons. Les positions respectives dépendent de la taille du tableau et probablement, les dimensions de l'écran. En modifiant les dimensions du tableau, les positions changent. Mais dans tous les cas, si vous agrandissez au maximum, les boutons seront tous sur la même ligne. Puis, en diminuant la taille du tableau, une seule ligne n'est plus suffisante. Une deuxième ligne de boutons apparaît alors. Le nombre de boutons étant toujours 5. Si les dimensions du tableau continuent à dimuer, une nouvelle ligne de boutons apparaît. Ainsi de suite. Explications :

Chaque bouton créé est ajouté au conteneur. Le gestionnaire FlowLaytou permet d'ajouter des composants sur une ligne. Dès qu'il n'ya plus d'espace suffisant sur la ligne, les autres s'ajoutent sur la deuxième ligne. Et ainsi de suite.
L'un des constructeurs de l'objet FlowLayout peut réquérir un argument de type String. Cet argument permet d'aligner les composants soit au centre, soit à gauche, soit à droite.

Vous pouvez modifier la ligne 12 de cette façon : c.setLayout(new FlowLayout(FlowLayout.CENTER) ); Puis aggrandissez la fenêtre. Recompilez puis exécutez à nouveau. Les 5 composants seront affichés sur une même ligne (parce que vous aurez agrandi la fenêtre). Et vous verrez de l'espace à gauche du premier composant et un espace à droite du dernier composant. Parce que l'argument FlowLayout.CENTER indique que les composants seront centrés

Vous pouvez modifier la ligne 12 de cette façon : c.setLayout(new FlowLayout(FlowLayout.RIGHT) ); Puis aggrandissez la fenêtre. Recompilez puis exécutez à nouveau. Les 5 composants seront affichés sur une même ligne (parce que vous aurez agrandi la fenêtre). Et vous verrez de l'espace à gauche du premier composant et aucun espace à droite du dernier composant. Parce que l'argument FlowLayout.RIGHT indique que les composants seront alignés à droite.

Vous pouvez modifier la ligne 12 de cette façon : c.setLayout(new FlowLayout(FlowLayout.LEFT) ); Puis aggrandissez la fenêtre. Recompilez puis exécutez à nouveau. Les 5 composants seront affichés sur une même ligne (parce que vous aurez agrandi la fenêtre). Et vous verrez de aucun espace à gauche du premier composant et un espace à droite du dernier composant. Parce que l'argument FlowLayout.LEFT indique que les composants seront alignés à gauche. Du reste, c'est le comportement par défaut du gestionnaire FlowLayout.

D.10.3 Le gestionnaire CardLayout

Ce gestionnaire permet de placer des composants sur la fenêtre sous forme de pile. Comme un jeu de cartes (Card = Carte). Le composant visible est toujours le premier placé dans la fenêtre.

La question immédiate et tout à fait légitime que vous vous posez est donc de savoir à quoi ça sert de placer plusieurs composants pour finalement ne voir qu'un seul ?...

Cela permet par exemple de choisir un composant, plutôt qu'un autre selon une ou des actions préalablement effectuées par l'utilisateur du logiciel. Vous verrez ainsi un champ de saisie différent selon l'action effectuée.

Des méthodes permettent de parcourir les divers composants ou alors de rendre visible tel plutôt qu'autre composant.
 Exemple 6 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          public Fenetre(String titre)
8.          {
9.               setTitle(titre);
10.              setSize(500, 300);
11.              Container c = getContentPane();
12.              c.setLayout(new CardLayout() );
13.              bouton1 = new JButton("BOUTON1");
14.              c.add(bouton1,"1");
15.              bouton2 = new JButton("BOUTON2");
16.              c.add(bouton2, "2");
17.              bouton3 = new JButton("BOUTON3");
18.              c.add(bouton3, "3");
19.              bouton4 = new JButton("BOUTON4");
20.              c.add(bouton4, "4");
21.              bouton5 = new JButton("BOUTON5");
22.              c.add(bouton5, "5");
23.              setLocationRelativeTo(this.getParent()); 
24.              setDefaultCloseOperation(3);
25.         }
26.    }
27.       
28.    public class TesterGestionnaire6
29.    {     
30.         public static void main(String [] args)
31.         {    
32.              JFrame f = new Fenetre("mise en forme");
33.              f.setVisible(true);
34.         }
35.    }
Compilez puis exécutez ce programme. Il sera affiché :

Une fenêtre avec un seul bouton visible. Le premier ajouté au conteneur. Donc, le bouton appelé : BOUTON1.

Explications :

L'explication est déjà dite juste avant l'exemple. Le gestionnaire CardLayout permet de placer des composants sur la fenêtre sous forme de pile. Comme un jeu de cartes (Card = Carte). Le composant visible est toujours le premier placé dans la fenêtre.

Dans le cas du gestionnaire CardLayout, on conservera la référence. C'est à dire qu'au lieu d'écrire (ligne 12) c.setLayout(new CardLayout());, on fera d'abord : CardLayout carte = new CardLayout(); Puis on fera : c.setLayout(carte);. carte est la référence à l'objet de type CardLayout.

Lorsqu'il s'agit d'ajouter un composant à un contenu qui dispose les objets façon CardLayout, on associera toujours l'objet à une variable de type String. C'est pourquoi, en ligne 14 par exemple, au lieu d'écrire c.add(bouton1); on a plutôt écrit : c.add(bouton1, "1");.
Cette chaine de caractères (ce deuxième argument) sert à identifier le composant. Même si dans le programme, cet identifiant ne sert à rien, il faut quand même le mentionner. En pratique, on peut l'appeler comme le bouton. Au lieu d'écrire "1", j'aurais pu écrire "BOUTON1".

L'exemple suivant permet de voir comment parcourir les divers composants entassés sous forme de pile. Et cette fois, la référence de l'objet CardLayout sera conservée.
 Exemple 7 : 

1.    import javax.swing.*; import java.awt.*;
2.    import javax.swing.event.*; import java.awt.event.*;
3.  
4.     class Fenetre extends JFrame implements ActionListener
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          private JButton pre, suiv, prem, der;
8.          private JPanel panneau1, panneau2;
9.          private CardLayout pile;
10.         
11.         public Fenetre(String titre)
12.         {
13.              setTitle(titre);
14.              setSize(300, 400);
15.              Container c = getContentPane();
16.              
17.              panneau1 = new JPanel();
18.              c.add(panneau1);
19.    
20.              panneau2 = new JPanel();
21.              c.add(panneau2, "North");
22.               
23.              pile = new CardLayout(15, 15);
24.              panneau1.setLayout(pile);
25.              
26.              bouton1 = new JButton("BOUTON1");
27.              panneau1.add(bouton1,"1");
28.              bouton2 = new JButton("BOUTON2");
29.              panneau1.add(bouton2, "2");
30.              bouton3 = new JButton("BOUTON3");
31.              panneau1.add(bouton3, "3");
32.              bouton4 = new JButton("BOUTON4");
33.              panneau1.add(bouton4, "4");
34.              bouton5 = new JButton("BOUTON5");
35.              panneau1.add(bouton5, "5");
36.                            
37.              pre = new JButton("precedent");
38.              panneau2.add(pre);
39.              pre.addActionListener(this);
40.              
41.              suiv = new JButton("suivant");
42.              panneau2.add(suiv);
43.              suiv.addActionListener(this);
44.               
45.              prem = new JButton("premier");
46.              panneau2.add(prem);
47.              prem.addActionListener(this);
48.                
49.              der = new JButton("dernier");
50.              panneau2.add(der);
51.              der.addActionListener(this);
52.              setDefaultCloseOperation(3);  
53.        }    
54.                         
55.         public void actionPerformed(ActionEvent a)
56.         {
57.              JButton source = (JButton) a.getSource();
58.              
59.              if(source == pre) pile.previous(panneau1);
60.              if(source == suiv) pile.next(panneau1);
61.              if(source == prem) pile.first(panneau1);
62.              if(source == der) pile.last(panneau1);
63.         }
64.    }     
65.         public class TesterGestionnaire7
66.         {
67.             public static void main (String [] args)
68.             {
69.                 JFrame f = new Fenetre("Mise en forme");
70.                 f.setVisible(true);
71.             }
72.         }

Compilez puis exécutez ce programme. Il sera affiché :

Une fenêtre avec 4 boutons en haut (Au nord) nommés : precedent, suivant, premier et dernier. Puis un autre bouton nommé BOUTON1 et qui se trouve au centre de la fenêtre.
Cliquez sur le bouton suivant, et le bouton BOUTON2 remplace BOUTON1. Encore sur le même bouton et c'est le bouton BOUTON3 qu'on voit.
Cliquez sur le bouton précédent et c'est le bouton BOUTON2 qui remplace le bouton BOUTON3. Encore un clic sur precedent et c'est le bouton BOUTON1 qu'on voit.
Cliquez sur premier et c'est le bouton BOUTON1 qu'on voit. Un autre clic sur premier et c'est le même bouton qu'on voit.
Cliquez sur dernier et ce sera le bouton BOUTON5 qu'on voit. Un autre clic sur dernuier et c'est le même bouton qu'on voit.


Explications :

Ligne 17 : on crée un panneau appelé panneau1. Puis en ligne 18 : on ajoute ce panneau au conteneur. On n'a pas défini le gestionnaire de mise en forme avant d'ajouter ce panneau. Donc, ce panneau se met au centre du conteneur. C'est le gestionnaire BorderLayout qui est choisi par défaut.

Ligne 20 : on crée un deuxième panneau. Pas de gestionnaire de mise en forme précisée. Donc le gestionnaire BorderLayout est utilisé. Puis en ligne 21, on l'ajoute en précisant la position. Le deuxième argument est l'endroit où sera placé le deuxième panneau. Au nord, c'est en haut.
Remarquez : les panneaux sont aussi des conteneurs. On peut donc y placer des composants.

En ligne 23 : on crée un gestionnaire de mise en forme type CardLayout en gardant sa référence appelée pile. En ligne 24 : On applique au panneau1, ce gestionnaire.
De la ligne 26 à la ligne 35, on ajoute alors au panneau1, 5 boutons. C'est donc le premier bouton qui sera visible.

Ligne 37 : on crée un bouton appelé pre. Ligne 38 : on l'ajoute au panneau2. Ligne 39 : on associe au bouton, un objet écouteur qui est la fenêtre elle-même. Ce qui veut dire que le clic sur le bouton entrainera une réaction.

Lignes 41 à 43 : même traitement que le bouton pre pour le bouton suiv

Lignes 45 à 47 : même traitement que le bouton pre pour le bouton prem

Lignes 49 à 51 : même traitement que le bouton pre pour le bouton der

Les boutons pre, suiv, prem et der sont ajoutés au panneau2 façon FlowLayout.
En effet, Contrairement au conteneur obtenu par la méthode getContentPane, dont le gestionnaire par défaut est BorderLayout, le conteneur de type JPanel a pour gestionnaire par défaut : FlowLayout. Pensez-y !


Dans la méthode actionPerformed() (lignes 57 à 62), on traite les évènement constitués par les clics sur les boutons.

La méthode getSource() appliquée à l'objet a de type ActionEvent renvoie l'objet sur lequel a eu lieu le clic. Cet objet est de type Object. Ligne 57 : On converti explicitement cet objet en type JButton qu'on met dans l'objet source de type JButton.

Ligne 59 : si la source est le bouton pre, alors on applique à la pile (l'objet de type CardLayout instancié ligne 23) la méthode previous(). Cette méthode requiert comme argument, le conteneur dans lequel se trouvent tous les objets appartenant à la pile. Et ce conteneur est le panneau panneau1 De la ligne 26 à la ligne 35, on a ajouté à ce conteneur les 5 boutons : BOUTON1, BOUTON2, BOUTON3, BOUTON4,et BOUTON5.
Cette méthode permet de rendre visible le bouton précédent celui qui est visible.

Ligne 60 : Si la source est le bouton suiv, on applique à la pile, la méthode next() qui permet de rendre visible le bouton suivant celui qui est visible. Cette méthode requiert ausi comme argument, le conteneur dans lequel se trouvent tous les objets appartenant à la pile : panneau1.

Ligne 61 : Si la source est le bouton prem, on applique à la pile, la méthode first() qui permet de rendre visible le premier bouton de la pile. Cette méthode requiert ausi comme argument, le conteneur dans lequel se trouvent tous les objets appartenant à la pile : panneau1

Ligne 62 : Si la source est le bouton prem, on applique à la pile, la méthode lest() qui permet de rendre visible le dernier bouton de la pile. Cette méthode requiert ausi comme argument, le conteneur dans lequel se trouvent tous les objets appartenant à la pile : panneau1

D.10.4 Le gestionnaire GridLayout

Ce gestionnaire permet de placer des composants sur la fenêtre sous forme de grille. Un nombre de lignes et un nombre de colonnes sont à préciser en créant le gestionnaire..

 Exemple 8 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          public Fenetre(String titre)
8.          {
9.               setTitle(titre);
10.              setSize(500, 300);
11.              Container c = getContentPane();
12.              c.setLayout(new GridLayout(2, 3) );
13.              bouton1 = new JButton("BOUTON1");
14.              c.add(bouton1,"1");
15.              bouton2 = new JButton("BOUTON2");
16.              c.add(bouton2, "2");
17.              bouton3 = new JButton("BOUTON3");
18.              c.add(bouton3, "3");
19.              bouton4 = new JButton("BOUTON4");
20.              c.add(bouton4, "4");
21.              bouton5 = new JButton("BOUTON5");
22.              c.add(bouton5, "5");
23.              setLocationRelativeTo(this.getParent()); 
24.              setDefaultCloseOperation(3);
25.         }
26.    }
27.       
28.    public class TesterGestionnaire8
29.    {     
30.         public static void main(String [] args)
31.         {    
32.              JFrame f = new Fenetre("mise en forme");
33.              f.setVisible(true);
34.         }
35.    }
Compilez puis exécutez ce programme. Il sera affiché :

Une fenêtre avec 5 boutons. Ils sont disposés en 2 lignes et 3 colonnes.

Explications :

En ligne 12 : on applique au contenuer c, la méthode setLayout avec pour argument l'objet GridLayout qui permet de disposer les composants sous forme de grille. 2 lignes et 3 colonnes. EN ajoutant donc les 5 boutons dans le conteneur c, on obtient alors la disposition en 2 lignes et 3 colonnes.

Les boutons occupent toute la surface de la fenêtre. SI vous voulez que ces boutons occupent seulement une partie de la fenêtre, vous devez créer un panneau (JPanel) que vous ajoutez au conteneur c. Et c'est dans ce conteneur que vous mettrez les boutons.
On peut modifier l'espace entre les boutons en utilisant un autre constructeur de la classe GridLayout.
 Exemple 9 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          private JPanel panneau;
8.          public Fenetre(String titre)
9.          {
9.               setTitle(titre);
10.              setSize(500, 300);
11.              Container c = getContentPane();
12.      
13.              panneau = new JPanel();        
14.              c.add(panneau, "North");
15.              panneau.setLayout(new GridLayout(2, 3, 10, 15) );
16.              
17.              bouton1 = new JButton("BOUTON1");
18.              panneau.add(bouton1,"1");
19.              bouton2 = new JButton("BOUTON2");
20.              panneau.add(bouton2, "2");
21.              bouton3 = new JButton("BOUTON3");
22.              panneau.add(bouton3, "3");
23.              bouton4 = new JButton("BOUTON4");
24.              panneau.add(bouton4, "4");
25.              bouton5 = new JButton("BOUTON5");
26.              panneau.add(bouton5, "5");
27.                 
28.              setLocationRelativeTo(this.getParent()); 
29.              setDefaultCloseOperation(3);
30.         }
31.    }
32.       
33.    public class TesterGestionnaire9
34.    {     
35.         public static void main(String [] args)
36.         {    
37.              JFrame f = new Fenetre("mise en forme");
38.              f.setVisible(true);
39.         }
40.    }
Compilez puis exécutez ce programme. Il sera affiché :

Même chose que ci-dessus. Deux différences tout de même : les bouton sont tous situés au nord de la fenêtre. Et l'espace entre les boutons est plus grand.

Explications :

Les boutons sont tous en haut de la fenêtre parce que ces boutons sont mis dans un panneau (ligne 13) qui lui a été ajouté au conteneur c avec le gestionnaire par défaut BorderLayout avec un argument "North" (ligne 14) qui permet de placer le panneau en haut de la fenêtre.
Le gestion GridLayout a été utilisé ici avec un constructeur de 4 arguments (ligne 15)
Les 2 premiers arguments sont respectivement le nombre de lignes et le nombre de colonnes. Les 2 derniers argeuments sont respectivement l'espace horizontal (10 pixels) et l'espace vertical (15 pixels).
Si vous créez un gridLayout tel que au moins une ligne reste vide, alors, la disposition des composants graphique que vous y mettrez se réorganisera autrement. Exemple : changez les premiers arguments du contructeur GridLayout. Au lieu de 2 et 3, mettez 3 et 4. Recompilez puis exécutez à nouveau. Vous verrez les boutons organisés en 3 lignes et 2 colonnes. C'est d'abord le nombre de lignes qui est respecté. Puisqu'il n'ya que 5 boutons, alors 2 colonnes suffisent.

D.10.5 Le gestionnaire BoxLayout

Ce gestionnaire permet de placer des composants sur la fenêtre sur une seule ligne (box horizontal) ou sur une seule colonne (box vertical).

 Exemple 10 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          private Box boxHorizontal;
8.            
9.          public Fenetre(String titre)
10.         {
11.              setTitle(titre);
12.              setSize(500, 300);
13.              Container c = getContentPane();
14.                  
15.              boxHorizontal = Box.createHorizontalBox();
16.              c.add(boxHorizontal);
17.              
18.              bouton1 = new JButton("BOUTON1");
19.              boxHorizontal.add(bouton1);
20.              bouton2 = new JButton("BOUTON2");
16.              boxHorizontal.add(bouton2);
22.              bouton3 = new JButton("BOUTON3");
23.              boxHorizontal.add(bouton3);
24.              bouton4 = new JButton("BOUTON4");
25.              boxHorizontal.add(bouton4);
26.              bouton5 = new JButton("BOUTON5");
27.              boxHorizontal.add(bouton5);
28.              
29.              setLocationRelativeTo(this.getParent()); 
30.              setDefaultCloseOperation(3);
31.         }
32.    }
33.       
34.    public class TesterGestionnaire10
35.    {     
36.         public static void main(String [] args)
37.         {    
38.              JFrame f = new Fenetre("mise en forme");
38.              f.setVisible(true);
39.         }
40.    }
Compilez puis exécutez ce programme. Il sera affiché :

5 boutons affichés sur une seule ligne. Si vous réduisez la taille de la fenêtre, vous ne verrez pas certains boutons. Vous vous attendrez peut-être à voir certains boutons sur une deuxième ligne. Echec et mat.

Explications :

On crée un box horizontal grâce à la classe Box. Ce box horizontal est appelé ici : boxHorizontal.

On le crée ligne 15 à l'aide de la méthode static createHorizontalBox() de la classe Box. Puis on ajoute ce box au conteneur c en ligne 16.

Puis on ajoute les boutons à ce box et non pas au conteneur c.
 Exemple 11 : 

1.    import javax.swing.*;
2.    import java.awt.*;
3.  
4.     class Fenetre extends JFrame
5.     {
6.          private JButton bouton1, bouton2, bouton3, bouton4, bouton5;
7.          private Box boxVertical;
8.            
9.          public Fenetre(String titre)
10.         {
11.              setTitle(titre);
12.              setSize(500, 300);
13.              Container c = getContentPane();
14.                  
15.              boxVertical = Box.createVerticalBox();
16.              c.add(boxVertical);
17.              
18.              bouton1 = new JButton("BOUTON1");
19.              boxHorizontal.add(bouton1);
20.              bouton2 = new JButton("BOUTON2");
16.              boxHorizontal.add(bouton2);
22.              bouton3 = new JButton("BOUTON3");
23.              boxHorizontal.add(bouton3);
24.              bouton4 = new JButton("BOUTON4");
25.              boxHorizontal.add(bouton4);
26.              bouton5 = new JButton("BOUTON5");
27.              boxHorizontal.add(bouton5);
28.              
29.              setLocationRelativeTo(this.getParent()); 
30.              setDefaultCloseOperation(3);
31.         }
32.    }
33.       
34.    public class TesterGestionnaire11
35.    {     
36.         public static void main(String [] args)
37.         {    
38.              JFrame f = new Fenetre("mise en forme");
38.              f.setVisible(true);
39.         }
40.    }
Compilez puis exécutez ce programme. Il sera affiché :

5 boutons affichés sur une seule colonne. Si vous réduisez la taille de la fenêtre, vous ne verrez pas certains boutons.

Explications :

On crée un box vertical grâce à la classe Box. Ce box horizontal est appelé ici : boxVertical.

On le crée ligne 15 à l'aide de la méthode static createVerticalBox() de la classe Box. Puis on ajoute ce box au conteneur c en ligne 16.

Puis on ajoute les boutons à ce box et non pas au conteneur c.

D.10.6 Le gestionnaire GridBagLayout

C'est le gestionnaire le plus souple. Moins de contraintes sur la position des composants.. Mais en même temps, c'est le plus difficile à mettre en oeuvre.
D'autres gestionnaires existent et vous pouvez les étudier en regardant la plateforme web de java :

GroupLayout
SpringLayout
PageLayout
TableLayout
FormLayout
MigLayout
ZoneLayout

Faire des recherches personnelles fait partir du travail d'un programmeur.
La connaissance, c'est bien. La partager, c'est mieux
Conseiller ce site à un(e) ami(e):

Son e-mail est :       
Une suggestion à faire pour ce site ? ... Contact : webmaster@debutantprog.com
← (précédent) D.9 Evènements boites dialogue
D.11 Exercices corrigés (1)
Accueil S O M M A I R E

D.10 Les gestionnaires de mise en frome