LECON 315


Gérez vos conteneurs
Dans le dernier TP, vous avez dû remarquer que vous devez spécifier une taille spécifique de conteneur. Ceci afin que vos JPanel puissent coexister dans une même fenêtre !
Dans ce chapitre, nous allons mettre fin à ce calvaire...

Il y a plusieurs objets qui peuvent vous aider à mieux gérer le contenu de vos IHM ; les deux objets abordés ici vont, je pense, vous rendre un sacré service...
Sommaire du chapitre :
  • Rendre vos conteneurs fractionnables
  • Ajouter des scrolls
  • Avoir plusieurs contenus
  • Ce qu'il faut retenir

Rendre vos conteneurs fractionnables

Qu'est-ce que tu entends par fractionnables ?

Avant de vous faire un laïus (un petit, je vous rassure), voici à quoi ressemblent des fenêtres à contenus fractionnables :
votre contenu avec une séparation


le même contenu pendant le déplacement de la séparation


et le résultat après déplacement




Ceci correspond à l'intérieur d'un objet JFrame.
La barre au milieu est un objet déplaçable qui permet d'agrandir une zone tout en rétrécissant celle d'à côté...
Ici, dans la première image, le barre est vers la gauche. La deuxième image est prise pendant que je déplace la barre centrale, et enfin la troisième correspond au résultat lorsque j'ai relâché le bouton de ma souris !
Vous pouvez constater que le conteneur de gauche est devenu plus grand au détriment de celui de droite...
C'est comme une espèce de séparateur qui fonctionne à la façon des vases communiquants...

Vous avez tout compris !
Je vous rassure tout de suite, ce composant est très simple d'utilisation...
En fait, les composants abordés dans ce chapitre s'utilisent facilement.

Je ne vais pas vous faire mariner plus longtemps : l'objet utilisé ici est un JSplitPane.

Voici le code source que j'ai utilisé pour avoir le résultat ci-dessus :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
import java.awt.BorderLayout;
import java.awt.Color;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
 
 
public class Fenetre extends JFrame {
 
        //On déclare notre objet JSplitPane
        private JSplitPane split;
        
        //Vous êtes habitués à cette classe, maintenant... ;)
        public Fenetre(){
               this.setLocationRelativeTo(null);
               this.setTitle("Gérer vos conteneur");
               this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               this.setSize(200, 200);
                               
               //On crée deux conteneurs de couleurs différentes
               JPanel pan = new JPanel();
               pan.setBackground(Color.blue);
               
               JPanel pan2 = new JPanel();
               pan2.setBackground(Color.red);
               
               //On construit enfin notre séparateur
               split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, pan, pan2);
               
               //On le passe ensuite au contentPane de notre objet Fenetre
               //placé au centre pour qu'il utilise tout l'espace disponible
               this.getContentPane().add(split, BorderLayout.CENTER);
                this.setVisible(true);
        }
        
        public static void main(String[] args){
               Fenetre fen = new Fenetre();
        }
        
}

Nous voyons l'attribut JSplitPane.HORIZONTAL_SPLIT dans le constructeur de l'objet : cela veut-il dire que nous pouvons avoir d'autres types de séparations ?

Je vois que vous comprenez très vite !
Vous pouvez avoir une séparation verticale en utilisant l'attribut JSplitPane.VERTICAL_SPLIT :

On le savait !
Mais, dis-nous, les deux autres paramètres sont nécessairement des JPanel ?

Ici, j'ai utilisé des JPanel, mais en fait, vous pouvez utiliser n'importe quelle classe dérivant de JComponent (conteneur, bouton, case à cocher...) : elle n'est pas belle, la vie ?

Je ne vous avais donc pas menti : cet objet est vraiment très simple d'utilisation, mais je ne vais pas vous laisser tout de suite...
Vous ne l'avez peut-être pas remarqué mais ces objets ne peuvent pas faire disparaître entièrement les côtés.
Dans notre cas, la fenêtre est petite, mais vous aurez peut-être l'occasion d'avoir une grande IHM et souvent d'agrandir / de rétrécir vos contenus.
L'objet JSplitPane a une méthode qui permet de rendre la barre de séparation intelligente, enfin presque...
La dite méthode ajoute deux petits boutons sur votre barre et, lorsque vous cliquerez dessus, rétrécira le côté vers lequel pointe la flèche dans le bouton.
Hein ?!?

Voici l'illustration de mes propos :





Pour avoir ces deux boutons en plus sur votre barre, il vous suffit d'invoquer la méthode split.setOneTouchExpandable(true); (mon objet s'appelle toujours split) et le tour est joué !
Amusez-vous à cliquer sur ces boutons et vous verrez à quoi ils servent.

Avant de vous laisser fouiner un peu sur cet objet, vous devez savoir que vous pouvez définir une taille de séparateur grâce à la méthode split.setDividerSize(int size) ; voici ce que j'ai obtenu avec une taille de 35 :


Vous pouvez également définir où doit s'afficher la barre de séparation. Ceci se fait grâce à la méthode setDividerLocation(int location); ou setDividerLocation(double location); .
Avant de vous montrer un exemple de code utilisant cette méthode, vous avez dû comprendre que, vu que cet objet peut prendre des sous-classes de JComponent, il pouvait donc aussi prendre des JSplitPane !

Voici ce que j'ai pu obtenir :




Ceci, avec ce code :
import java.awt.BorderLayout;
import java.awt.Color;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;

public class Fenetre extends JFrame {

                //On déclare notre objet JTextPane
                private JTextArea textPane = new JTextArea();
                //L'objet qui va gérer le scroll
                //En lui passant un objet JComponent dans le constructeur
                private JScrollPane scroll = new JScrollPane(textPane);
               
                //Vous êtes habitués à cette classe, maintenant... ;)
                //On déclare notre objet JSplitPane
                private JSplitPane split, split2, split3;
               
                //Familiers avec celle-là également... ;)
                public Fenetre(){
                               this.setLocationRelativeTo(null);
                               this.setTitle("Gérer vos conteneur");
                               this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                               this.setSize(200, 200);
                              
                              
                               //On crée deux conteneurs de couleurs différentes
                               JPanel pan = new JPanel();
                               pan.setBackground(Color.blue);                            
                               JPanel pan2 = new JPanel();
                               pan2.setBackground(Color.red);
                               JPanel pan3 = new JPanel();
                               pan3.setBackground(Color.orange);
                               JPanel pan4 = new JPanel();
                               pan4.setBackground(Color.YELLOW);
                               //On construit enfin notre séparateur
                               split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, pan, pan4);
                               //On place le séparateur
                               split.setDividerLocation(80);
                               split2 = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, pan3, pan2);
                               //On place le séparateur
                               split2.setDividerLocation(100);
                               //On passe les deux précédents JSplitPane à celui-ci
                               split3 = new JSplitPane(JSplitPane.VERTICAL_SPLIT, split, split2);
                               //On place le séparateur
                               split3.setDividerLocation(80);
                              
                               //On le passe ensuite au contentPane de notre objet Fenetre
                               //placé au centre pour qu'il utilise tout l'espace disponible
                               this.getContentPane().add(split3, BorderLayout.CENTER);
                               this.setVisible(true);
                }
               
                public static void main(String[] args){
                               Fenetre fen = new Fenetre();
                }
               
}


Ce que je peux vous conseiller, c'est d'essayer d'adapter cet objet au dernier TP.
Je pense que vous en savez assez pour utiliser cet objet comme il convient. Nous allons à présent voir un autre objet bien pratique, lui aussi. Il permet d'avoir un scroll à côté de vos conteneurs afin de pouvoir dépasser les limites de ceux-ci !

Ajouter des scrolls

Afin que vous puissiez mieux juger de l'utilité de l'objet que nous allons utiliser ici, nous allons voir un nouvel objet de texte : un JTextArea.
Cet objet est très simple au demeurant, c'est une forme de JTextField, mais plus grand ! Voyez plutôt :


Voici le code source utilisé pour avoir ce résultat (sans le texte, hein...) :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
import java.awt.BorderLayout;
 
import javax.swing.JFrame;
import javax.swing.JTextArea;
 
public class Fenetre extends JFrame {
 
        //On déclare notre objet JTextArea
        private JTextArea textPane = new JTextArea();
        
        //Vous êtes habitués à cette classe, maintenant... ;)
        public Fenetre(){
               this.setLocationRelativeTo(null);
               this.setTitle("Gérer vos conteneur");
               this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               this.setSize(200, 200);
               
               //On ajoute l'objet au contentPane de notre fenêtre
               this.getContentPane().add(textPane, BorderLayout.CENTER);
               this.setVisible(true);
        }
        
        public static void main(String[] args){
               Fenetre fen = new Fenetre();
        }
        
}


Vous pourrez voir que nous pouvons directement écrire dans ce composant, et que celui-ci ne retourne pas directement à la ligne si vous atteignez le bord droit de la fenêtre.

Afin de voir si les lettres tapées au clavier sont bien dans notre objet, vous pouvez récupérer le texte saisi grâce à la méthode getText() .
Voici un code d'exemple ainsi que le résultat obtenu :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;
 
public class Fenetre extends JFrame {
 
        //On déclare notre objet JTextArea
        private JTextArea textPane = new JTextArea();
        
        //Vous êtes habitués à cette classe, maintenant... ;)
        public Fenetre(){
               this.setLocationRelativeTo(null);
               this.setTitle("Gérer vos conteneur");
               this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               this.setSize(200, 200);
               
               JButton bouton =  new JButton("Bouton");
               bouton.addActionListener(new ActionListener(){
                       public void actionPerformed(ActionEvent e){
                               System.out.println("Texte écrit dans le JTextArea : ");
                               System.out.println("--------------------------------");
                               System.out.println(textPane.getText());                             
                       }
               });
               //On ajoute l'objet au contentPane de notre fenêtre
               this.getContentPane().add(textPane, BorderLayout.CENTER);
               this.getContentPane().add(bouton, BorderLayout.SOUTH);
               this.setVisible(true);
        }
        
        public static void main(String[] args){
               Fenetre fen = new Fenetre();
        }
        
}



Et le résultat :





Le code est simple et clair !
Cependant, les plus curieux d'entre vous l'auront remarqué : si vous écrivez trop de lignes, vous dépassez la limite imposée par le bas de votre fenêtre... Le texte est bien écrit mais vous ne le voyez pas...
Exactement comme pour le bord droit...

Pour ce genre de problème, il existe ce qu'on appelle des scrolls.
Ce sont de petit ascenseurs positionnés sur le côté et / ou sur le bas de votre fenêtre et qui vous permettent de dépasser les limites imposées par la dite fenêtre !

Voyez plutôt :


Vous voyez le petit ascenseur à droite et en bas de la fenêtre...
Avec ceux-ci, fini les problèmes de taille de vos conteneurs !

Voici le code que j'ai utilisé afin d'avoir ce résultat :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
 
public class Fenetre extends JFrame {
 
        //On déclare notre objet JTextArea
        private JTextArea textPane = new JTextArea();
        //L'objet qui va gérer le scroll
        //En lui passant un objet JComponent dans le constructeur
        private JScrollPane scroll = new JScrollPane(textPane);
        
        //Vous êtes habitués à cette classe, maintenant... ;)
        public Fenetre(){
               this.setLocationRelativeTo(null);
               this.setTitle("Gérer vos conteneur");
               this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               this.setSize(200, 200);
               
               JButton bouton =  new JButton("Bouton");
               bouton.addActionListener(new ActionListener(){
                       public void actionPerformed(ActionEvent e){
                               System.out.println("Texte écrit dans le JTextArea : ");
                               System.out.println("--------------------------------");
                               System.out.println(textPane.getText());                             
                       }
               });
               
               //On ajoute l'objet au contentPane de notre fenêtre
               this.getContentPane().add(scroll, BorderLayout.CENTER);
               this.getContentPane().add(bouton, BorderLayout.SOUTH);
               this.setVisible(true);
        }
        
        public static void main(String[] args){
               Fenetre fen = new Fenetre();
        }
        
}


Vous avez vu que l'objet utilisé afin d'avoir un ascenseur s'appelle un : JScrollPane.
Maintenant, vous pouvez écrire aussi loin que vous le voulez, vers le bas et vers la droite !
Les ascenseurs apparaissent automatiquement lorsque vous dépassez les limites autorisées. Cependant, vous pouvez redéfinir un comportement grâce aux méthodes :
  • scroll.setHorizontalScrollBarPolicy(int policy) : permet de définir le comportement du scroll en bas de votre fenêtre ;
  • scroll.setVerticalScrollBarPolicy(int policy) : permet de définir le comportement du scroll à droite de votre fenêtre.


Le paramètre de ces méthodes est un entier défini dans la classe JScrollPane, il peut prendre les valeurs suivantes :
  • JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED : le scroll vertical n'est visible que s'il est nécessaire, donc s'il y a dépassement de la taille en hauteur ;
  • JScrollPane.VERTICAL_SCROLLBAR_NEVER : le scroll vertical n'est jamais visible, même si vous dépassez, mais par contre, le conteneur s'allonge tout de même !
  • JScrollPane.VERTICAL_SCROLLBAR_ALWAYS : le scroll vertical est toujours visible même si vous ne dépassez pas !

Les mêmes entiers existent pour le scroll horizontal, mais vous devrez remplacer VERTICAL par HORIZONTAL !


Vous devez tout de même savoir que cet objet en utilise un autre : un JScrollBar. Les deux barres de défilement sont deux instances de cet objet...

Je pense vous avoir montré le B.A.BA, mais si vous voulez en savoir plus, vous pouvez aller faire un tour ici.

Nous avons vu comment séparer un conteneur, nous avons vu comment agrandir un conteneur, nous allons maintenant voir comment ajouter dynamiquement des conteneurs !

Avoir plusieurs contenus

Dans ce chapitre, vous allez apprendre à avoir plusieurs "pages" dans votre IHM...
Jusqu'à maintenant, vous ne pouviez pas avoir plusieurs contenus dans votre fenêtre, à moins de leur faire partager l'espace disponible.

Il existe une solution toute simple qui consiste à créer des onglets, et, croyez-moi, c'est aussi très simple à faire.
L'objet à utiliser est un JTabbedPane.
Afin d'avoir un exemple plus ludique, j'ai constitué une classe héritée de JPanel afin de créer des onglets ayant une couleur de fond différente... Cette classe ne devrait plus vous poser de problèmes :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
 
import javax.swing.JPanel;
 
 
public class Panneau extends JPanel{
        
        private Color color = Color.white;
        private static int COUNT = 0;
        private String message = "";
        
        public Panneau(){}
        public Panneau(Color color){
               this.color = color;
               this.message = "Contenu du panneau N°" + (++COUNT);
        }
        public void paintComponent(Graphics g){
               g.setColor(this.color);
               g.fillRect(0, 0, this.getWidth(), this.getHeight());
               g.setColor(Color.white);
               g.setFont(new Font("Arial", Font.BOLD, 15));
               g.drawString(this.message, 10, 20);
        }
}


J'ai utilisé cet objet afin de créer un tableau de Panneau. Chaque instance est ensuite ajoutée à mon objet gérant les onglets via sa méthode add(String title, JComponent comp) .
Vous voudriez peut-être avoir le code tout de suite...
Le voici :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
import java.awt.Color;
 
import javax.swing.JFrame;
import javax.swing.JTabbedPane;
 
public class Fenetre extends JFrame {
 
        private JTabbedPane onglet;
        //Vous êtes habitués à cette classe, maintenant... ;)
        public Fenetre(){
               this.setLocationRelativeTo(null);
               this.setTitle("Gérer vos conteneurs");
               this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               this.setSize(400, 200);
               
               //Création de plusieurs Panneau
               Panneau[] tPan = {     new Panneau(Color.RED),
                                                     new Panneau(Color.GREEN),
                                                     new Panneau(Color.BLUE)};
               
               //Création de notre conteneur d'onglets
               onglet = new JTabbedPane();
               int i = 0;
               for(Panneau pan : tPan){
                       //Méthode d'ajout d'onglet
                       onglet.add("Onglet N°"+(++i), pan);
                       //Vous pouvez aussi utiliser la méthode addTab
                       //onglet.addTab("Onglet N°"+(++i), pan);
 
               }
               //on passe ensuite les onglets au contentPane
               this.getContentPane().add(onglet);
               this.setVisible(true);
        }
        
        public static void main(String[] args){
               Fenetre fen = new Fenetre();
        }
        
}


Ce qui m'a donné :


Vous constatez que l'utilisation de cet objet est très simple, là aussi...
Je vais tout de même vous montrer quelques méthodes bien utiles. Par exemple, vous pouvez ajouter une image en guise d'icône à côté du titre de l'onglet.
Ce qui pourrait nous donner :


Le code est identique au précédent, à l'exception de ce qu'il y a dans la boucle :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
 
for(Panneau pan : tPan){
        //Méthode d'ajout d'onglets                   
        onglet.add("Onglet N°"+(++i), pan);
        //On ajoute l'image à l'onglet en cours
        //Les index d'onglets fonctionnent comme les tableaux : ils commencent à 0
        onglet.setIconAt((i - 1), new ImageIcon("java.jpg"));
        
        //Vous pouvez aussi utiliser la méthode addTab
        //onglet.addTab("Onglet N°"+(++i), new ImageIcon("java.jpg"), pan);
}


Vous avez également la possibilité de changer l'emplacement des entêtes d'onglets en spécifiant le dit emplacement dans le constructeur, comme ceci :
Code : Java - 
1
2
3
4
5
6
7
8
 
//affiche les onglets en bas de la fenêtre
JTabbedPane onglet = new JTabbedPane(JTabbedPane.BOTTOM);
 
//affiche les onglets à gauche de la fenêtre
JTabbedPane onglet = new JTabbedPane(JTabbedPane.LEFT);
 
//affiche les onglets à droite de la fenêtre
JTabbedPane onglet = new JTabbedPane(JTabbedPane.RIGHT);


Voici ce que vous pouvez obtenir :

Vous pouvez aussi utiliser la méthode setTabPlacement(JTabbedPane.BOTTOM); qui a le même effet : ici, la barre d'exploration des onglets sera située en bas du conteneur.


Vous avez aussi la possibilité d'ajouter ou de retirer des onglets. Pour ajouter, vous avez deviné comment procéder !
Pour retirer un onglet, nous allons utiliser la méthode remove(int index) . Cette méthode parle d'elle-même, elle va retirer l'onglet ayant pour index le paramètre passé !

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
 
 
public class Fenetre extends JFrame {
 
        //On déclare notre objet JSplitPane
        private JTabbedPane onglet;
        //Compteur pour le nombre d'onglets
        private int nbreTab = 0;
        
        //Vous êtes habitués à cette classe, maintenant... ;)
        public Fenetre(){
               this.setLocationRelativeTo(null);
               this.setTitle("Gérer vos conteneurs");
               this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               this.setSize(400, 200);
               
               //Création de plusieurs Panneau
               Panneau[] tPan = {     new Panneau(Color.RED),
                                                     new Panneau(Color.GREEN),
                                                     new Panneau(Color.BLUE)};
               
               //Création de notre conteneur d'onglets
               onglet = new JTabbedPane();
               for(Panneau pan : tPan){
                       //Méthode d'ajout d'onglets
                       onglet.addTab("Onglet N°"+(++nbreTab), pan);
               }
               //on passe ensuite les onglets au contentPane
               this.getContentPane().add(onglet, BorderLayout.CENTER);
               
               //Ajout du bouton pour ajouter des onglets
               JButton nouveau = new JButton("Ajouter un onglet");
               nouveau.addActionListener(new ActionListener(){
                       public void actionPerformed(ActionEvent e){
                               onglet.add("Onglet N°"+(++nbreTab), new Panneau(Color.DARK_GRAY));
                       }
               });
               
               //Ajout du bouton pour retirer l'onglet sélectionné
               JButton delete = new JButton("Effacer l'onglet");
               delete.addActionListener(new ActionListener(){
                       public void actionPerformed(ActionEvent e){
                               //On récupère l'index de l'onglet sélectionné
                               int selected = onglet.getSelectedIndex();
                               //S'il n'y a plus d'onglet, la méthode ci-dessus retourne -1
                               if(selected > -1)onglet.remove(selected);
                       }
               });
               
               JPanel pan = new JPanel();
               pan.add(nouveau);
               pan.add(delete);
               
               this.getContentPane().add(pan, BorderLayout.SOUTH);
               this.setVisible(true);
        }
 
        
        public static void main(String[] args){
               Fenetre fen = new Fenetre();
        }       
}


Ce qui peut vous donner :





Voilà : vous venez de voir pas mal de choses, simples et utiles !
Il est temps de se diriger vers le topo...

Ce qu'il faut retenir

  • Vous pouvez scinder le contenu de votre IHM en utilisant un JSplitPane.
  • Celui-ci vous permet de couper votre IHM dans le sens vertical ou horizontal.
  • Vous pouvez spécifier la taille du séparateur grâce à la méthode split.setDividerSize(int size) et sa position avec split.setDividerLocation(int size) .
  • Vous avez la possibilité d'ajouter des ascenseurs à vos conteneurs grâce à l'objet JScrollPane.
  • Les ascenseurs de cet objet peuvent être affichés ou non selon le mode d'affichage que vous avez choisi avec la méthode setHorizontalScrollBarPolicy(int policy) ou / et setVerticalScrollBarPolicy(int policy) .
  • Vous pouvez utiliser des onglets grâce à l'objet JTabbedPane.
  • Vous avez la possibilité d'ajouter des onglets grâce à la méthode addtab() ou la méthode add() .
  • Une icône peut être spécifiée à un emplacement donné grâce à la méthode setIconAt(int index, ImageIcon img) .
  • Vous avez aussi la possibilité de spécifier où doit se mettre la barre de navigation des onglets en le spécifiant dans le constructeur new JTabbedPane(JTabbedPane.BOTTOM) ou encore grâce à la méthode .setTabPlacement(JTabbedPane.BOTTOM); .
  • Des onglets peuvent être retirés en invoquant la méthode removeAt(int index) .



Je ne vais pas vous faire l'affront de vous faire un QCM tellement ce chapitre était simple...
Nos venons de voir comment gérer le contenu de vos fenêtres avec différents objets.
Vous pouvez, bien sûr, les cumuler et mettre des panneaux avec séparateurs dans un onglet...

Vous avez dû remarquer que tous les objets vus dans ce chapitre ont un nom qui se termine avec Pane.
Ils appartiennent donc à la famille des conteneurs !

Dans le prochain chapitre, nous allons voir un conteneur bien spécial, lui aussi : Les arbres.

// // 0 comments //

0 comments to "LECON 315"

Post a Comment

Powered by Blogger.

About This Blog

Aller au debut de la page