Aller au menu - Aller au contenu

Icône Gérez vos conteneurs

Par Avatar cysboy
Mise à jour : 12/02/2010
Difficulté : Intermédiaire Intermédiaire Creative Commons BY-NC-SA
96 702 visites depuis 7 jours, dont 498 sur ce chapitre classé 4/786
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... :)

Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

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

Image utilisateur

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

Image utilisateur

et le résultat après déplacement

Image utilisateur



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... :ange:
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 :

Image utilisateur

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 ? :soleil:

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 :

Image utilisateur


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 :

Image utilisateur


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 ! :waw:

Voici ce que j'ai pu obtenir :
Secret (cliquez pour afficher)

Image utilisateur


Ceci, avec ce code :
Secret (cliquez pour afficher)

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
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 ! :waw:
Retour en haut

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 :

Image utilisateur


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 :

Image utilisateur


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 :

Image utilisateur


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 ! :magicien:

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 ! :D
Retour en haut

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é :

Image utilisateur Image utilisateur Image utilisateur


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 :

Image utilisateur


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 :

Image utilisateur Image utilisateur Image utilisateur


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 :

Image utilisateur


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

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...
Retour en haut
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.
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
3 commentaires pour "Gérez vos conteneurs"
Note moyenne : 3.57 / 4 (1025 votes)
Pseudo Commentaire
Hors ligne djamil.b # Posté le 11/11/2008 à 19:05:20
''De la pure Folie.'' dit-elle
Avatar

 Super ! Jframe c'est hyper cool pour l'interface graphique simple beau et rapide
We can't be stopped. :)
 
Hors ligne artistou # Posté le 01/02/2011 à 13:00:07

Bonjour a tous j ai realise une application selon le model MVC
dans la partie vue j ai mis un Menubar contenant des jmenu ensuite j ai lie chaque jmenu a sa propre classe(contenant une methode getpanel() ) pour l afficher ensuite dans la Fenetre a travers cette methode mon probleme c ke lors de l affichage de la classe CalculPanel j ai eu des problemes d affichage puisque j ai utilise des Jsplit est ce que kelkun peut m aider Svp
c presque comme l application PenduZ
voici la partie de code la plus mechante

Class CalculPanel
{

//On construit enfin notre séparateur
split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, pan, pan4);
//On place le séparateur
split.setDividerLocation(400);
split2 = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, pan3, pan2);
//On place le séparateur
split2.setDividerLocation(400);
//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(270);

//On le passe ensuite au contentPane de notre objet Fenetre
//placé au centre pour qu'il utilise tout l'espace disponible
this.panel.add(split3,BorderLayout.CENTER);
}
public class Fenetre extends JFrame implements Observer {
JMenuItem New = new JMenuItem( "New" );
New.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
conteneur.removeAll();
CalculPanel gp = new CalculPanel(size, model);
model.addObserver(gp);
conteneur.add(gp.getPanel(), BorderLayout.CENTER);
conteneur.revalidate();
initModel();
}
});
}

Pouvez vous Svp m aider merci
Hors ligne alicedog # Posté le 26/07/2011 à 09:40:02
au revoir

Avis : Très bon

Super! :lol:
Les onglets m'ont rendu très utile! Je fais maintenant des logiciels de plus en plus complexes. Maintenant je pratique beaucoup et je me souvient de tout sans presque apprendre. Le tuto est très bien expliqué depuis le début. Félicitation à Cysboy! :p
Au revoir
 

Voir tous les commentaires