Interfaces graphiques en JAVA

Les environnements graphiques

Menu Icône
Fenêtre cadre
système système

Menu Barre
application d'outils

Zone
client Vue
fractionnée

Barre Vue avec Composants

d'état ascenseur conteneur
graphiques
Conteneurs et composants (1) : généralités

Object
 Une interface graphique en Java est un assemblage de (from lang)
 conteneurs (Container) et de composants (Component).

 Un composant est une partie "visible" de l'interface utilisateur Java.

●
Exemple : les boutons, les zones de textes ou de dessin, etc.

Component

 Un conteneur est un espace dans lequel on peut positionner plusieurs

composants et donc des conteneurs

Container

3/35
 Les conteneurs
Conteneurs disponibles

Parmi les conteneurs

applicatifs, on peut citer :
•Les boites de dialogues
•Les fenêtres cadres
•Les applets

4/35
 Les fenêtres d'application : JFrame

 C'est une fenêtre avec un cadre,

utilisé de façon autonome,

C'est donc un conteneur général,
qui dispose
– d'un menu système,
– de boutons d'agrandissement,
– mise en icône
– et de fermeture de l'application
Un JFrame peut contenir des
composants ou d'autres
conteneurs

5/35
 Les boîtes de dialogue JDialog
 Un JDialog ressemble à un JFrame mais
– Il n'a pas de bouton du gestionnaire des fenêtres
permettant de l'iconiser.
– On y associe habituellement un bouton de
validation.
 Un JDialog dépend d'un frame parent(qui est passé
comme premier argument au constructeur).
 Un JDialog n'est pas visible lors de sa création.
Utiliser setVisible(true);

6/35
Les panneaux

●
Ce sont des conteneurs non autonomes (JPanel).
●
Ils se positionne dans une zone client d'une fenêtre.
●
Ils peuvent fournir des barres de défilement pour
manipuler une zone large (JscrollPane).
●
Un JPanel peut recevoir plusieurs composants. Ils se
placent selon le gestionnaire de placement choisi.
●
Le conteneur JscrollPane ne peut recevoir qu'un
composant.

7/35
Conteneurs et composants (2) : Frame et Panel

 Les deux conteneurs les plus courants sont JFrame et JPanel.

 Un JFrame présente une fenêtre de haut niveau avec un titre,
une bordure et des angles de redimensionnement.
– Un JFrame est doté d'un BorderLayout par défaut.

 Un JPanel n'a pas une apparence propre et ne peut pas être

utilisé comme fenêtre autonome.
– Un JPanel est doté d'un FlowLayout par défaut.
– Les JPanel sont créés et ajoutés aux autres conteneurs de la
même façon que les composants tels que les boutons.
• Les JPanel peuvent ensuite redéfinir une présentation qui
leur soit propre pour contenir eux-mêmes d'autres
composants.

8/35
 Composants graphiques principaux
Classe Description

Jframe Fenêtre graphique.

Jpanel Zone graphique, container

Jbutton Objet bouton

JtextField Zone de texte à saisir

Jlabel Texte non modifiable

JcomboBox Choix d'éléments dans une liste avec sélecteur

JscrollBar Barre de défilement

Jtable Tableau

Jlist Choix d'éléments dans une liste sans sélecteur

JcheckBox Objet pouvant être coché ou décoché

JradioButton Choix exclusifs pour les options

9/35
La bibliothèque Swing

10/35
Conventions de nommage

 Les composants Swing sont situés dans le paquetage javax.swing

et ses sous paquetages.

 Ils portent des noms similaires à leurs correspondants de awt

précédés d'un J.

 JFrame, JPanel, JTextField, JButton, JCheckBox, JLabel, etc.

11/35
Aperçu des classes Swing (1)

•Conteneurs de haut niveau •Conteneurs à usage général

JDialog JFrame JApplet JPanel

JScrollPane
•Conteneurs particulier
JTabbedPane

JtoolPane JSplitlPane

JLayeredPane
JInternalPane

RootPane 12/35
Aperçu des classes Swing (2)
•Composants à usage général

JButton
JCheckBox JComboBox
JList

JSlider
JRadioButton
JMenu

JSpinner JPasswordField
JTextField

13/35
Aperçu des classes Swing (3)
•Composants interactifs

JColorChooser JFileChooser
JEditorPane ou JTextPane

JTable JTree

14/35
Aperçu des classes Swing (3)

•Composants non éditable

JProgressBar
JSeparator JLabel

JToolTip

15/35
Organisation d’un écran
• Composition d’objets graphique dans des containers
• 1-déclaration du container
• 2-insertion des composants dans le container
• 1) Déclaration du composant
• 2) Insertion du composant dans son container

1) JFrame maFen = new JFrame("Fenetre"); UneClasse

21) JButton b=new JButton("Bonjour");
22) maFen.getContentPane.add(b); JFrame
maFenetre

... b 1 JButton
2
2 2
1

• Remarque : Un container peut être inséré dans un autre container

16/35
Exemple composants swing

17/35
Exemple de composants swing

JMenuBar
JLabel JTextField
JComboBox

JList

JCheckBox

18/35
Conteneurs et composants (4) : utilisation

 On ajoute un composant dans un conteneur, avec la méthode add()

:
JPanel p = new JPanel();
JButton b = new JButton();
p.add(b);
 De manière similaire, un composant est retiré de son conteneur par
la méthode remove() :
p.remove(b);
 Un composant a (notamment) :
 une taille préférée que l’on obtient avec getPreferredSize()
 une taille minimum que l’on obtient avec getMinimunSize()
 une taille maximum que l’on obtient avec getMaximunSize()

19/35
Gestionnaire de placement (1)

 Les conteneurs définissent la position des

composants
Soit en position absolue (x, y, largeur, hauteur)
Soit selon le gestionnaire de placement associé
au conteneur (LayoutManager)
– Le gestionnaire calcule la position des
composants
– Qui peuvent ainsi être invisibles

20/35
Gestionnaire de placement (2)

●
La méthode setLayout(layoutManager) définie dans les
conteneurs permet de changer le gestionnaire par
défaut
●
Un gestionnaire par défaut est défini pour chaque
conteneur
●
Il est possible de choisir un autre gestionnaire de
présentation pour un conteneur donnée
●
La méthode pack() déclenche le calcul du placement
●
La méthode invalidate() rend le placement courant
invalide et donc le redimentionnement des composants
à l'intérieur de celui-ci
21/35
Gestionnaire de placement (3)
●
FlowLayout
 Place les composants de
gauche à droite
●
CardLayout
 Superpose les composants

●
GridLayout
 Découpe en une grille
régulière sur laquelle les
composants sont placés

GridBagLayout
Découpe en une grille et place les
composants sur une ou plusieurs cases

22/35
Gestionnaire de placement (4)
●
BorderLayout
Découpe l'espace en 5 régions :
centre, est, ouest, sud et nord

• SpringLayout
Pemet de définir de manière
souple les distances entre les
composants
23/35
Gestionnaire de placement (5)

 Positionnement absolu
 Null
 On place les composants sur le conteneurs en indiquant la
position absolue avec la méthode setBounds(x, y, h, l)

24/35
Gestionnaire de placement (6)
 Tout conteneur possède un gestionnaire de présentation
par défaut.
 Tout instance de Container référence une instance de
LayoutManager.
 Il est possible d'en changer grâce à setLayout().
 Les éditeurs visuels (GuiBuilder) utilise un gestionnaire de
placement additionnel :
 GroupLayout

25/35
Premier exemple : ExempleIHM
import java.awt.*;
import javax.swing.*;
public class ExempleIHM extends JFrame {
private JButton b1;
private JButton b2;
public static void main(String args[]) {
ExempleIHM that = new ExempleIHM();
that.pack(); //change taille du Frame pour englober boutons
that.setVisible(true);
}
public ExempleIHM() {
super("Notre exemple d'IHM"); // lance le constructeur de la super
classe, ici Frame
setLayout(new FlowLayout()); // nouveau gestionnaire pres.
b1 = new JButton("Appuyer");
b2 = new JButton("Ne pas appuyer");
Container content = getContentPane();
content.add(b1);
content.add(b2);
}
}

Utiliser le gestionnaire par défaut(null).

Modifiez le code pour obtenir un résultat
similaire au précédent.
La fenêtre doit avoir une taille de 200 X 200 26/35
Layout Manager : la hierarchie

C o n t a in e r
L a y o u tM a n a g e r

L a y o u tM a n a g e r 2
B o rd e rL a yo u t

C a rd L a yo u t
G r id B a g L a y o u t

F lo w L a y o u t

G r id L a y o u t

27/35
Principaux paquetages Swing
 javax.swing
 javax.swing.border
 javax.swing.colorchooser
 javax.swing.event
 javax.swing.filechooser
 javax.swing.plaf
 javax.swing.table
 javax.swing.text
 javax.swing.text.html
 javax.swing.text.rtf
 javax.swing.tree
 javax.swing.undo

28/35
Le dessin sur transparents

 JLayeredPane est un conteneur qui permet de ranger ses

composants en couches (ou transparents).

 Cette notion permet de dessiner les composants, selon un

certain ordre: premier plan, plan médian, arrière plan, etc.

 Pour ajouter un composant, il faut spécifier la couche sur

laquelle il doit être dessiné :
monJlayeredPane.add (monComposant, new Integer(5));

29/35
Les étiquettes d'aide en ligne

 La classe ToolTipText permet de créer des aides en lignes qui

apparaissent lorsque la souris passe sur un composant.

JButton monBouton = new JButton ("Un bouton");

monBouton.setToolTipText ("Aide de mon bouton");

 Ces quelques éléments ne sont qu'un aperçu de ce que

propose Swing.

 Il y a beaucoup de composants, de nouveaux

gestionnaires de présentation, de nouveaux événements
graphiques que l ’on ne peut présenter dans le cadre de
ce cours...
30/35
Les événements générés

●
Chaque fois qu’un utilisateur frappe un caractère du clavier,
appuie sur un bouton de la souris ou la déplace, un événement
est généré.
●
Ces événements sont envoyés à un composant appelé écouteur,
mais c'est à lui d'enregistrer une routine de traitement
d'événement pour recevoir l'événement.
 Le traitement de l'événement est ainsi délégué à une classe
séparée.

31/35
Les événements générés (2)
●
La gestion des événements passe par l'utilisation d'objets
"écouteur d'événements" (les Listener) et d'objets
sources d'événements.

 Un objet écouteur est l'instance d'une classe

implémentant l'interface XXXXListener.

 Une source d'événements est un objet pouvant recenser

des objets écouteurs et leur envoyer des objets
événements.

32/35
Les événements générés (3)

 Les classes adapteurs permettent une mise en œuvre

simple de l'écoute d'événements graphiques.

 Ce sont des classes qui implémentent les écouteurs

d'événements possédant le plus de méthodes, en
définissant un corps vide pour chacune d'entre elles.

 Plutôt que d'implémenter l'intégralité d'une interface dont

une seule méthode est pertinente pour résoudre un
problème donné, une alternative est de sous-classer
l'adapteur approprié.
33/35
Les événements générés (4)
import java.awt.*;
import java.awt.event.*;
import ButtonHandler;
class TestButton
{
JFrame f; JButton b;
public TestButton()
{
super(); f = new JFrame ("TestButton");
Container panneauContenu;
panneauContenu = f.getContentPane(); import java.awt.event.*;
b = new JButton ("Pressez Moi"); public class ButtonHandler
panneauContenu.add ("Center", b) ; implements ActionListener {
f.pack (); f.setVisible (true) ; public void actionPerformed (ActionEvent e)
b.addActionListener (new ButtonHandler ()); {
} System.out.println ("Action occured") ;
public static void main(String args[]) }
{ }
TestButton that = new TestButton();
}}

34/35
Conteneurs et composants : hiérarchie
Object
(from la ng)
Button

Hiérarchie d’héritage
Canvas Component des principaux éléments des
interfaces graphiques en Java
Checkbox

Container
Choice

Label
Panel Window

Scrollbar List

Dialog Frame
Applet
TextComponent
(from applet)

FileDialog
TextArea TextField

35/35