Intro GUI

Graphical User Interface (GUI)
•Définition
•Java
•Quelques attributs de Component
•Quelques méthodes de Component
•Qu’est-ce qu’un conteneur
•Quelques méthodes de Container
•Quelques composants disponibles
–JFrame, JPanel, JButton
•Gestion simple d’évènements
Graphical User Interface (GUI)
Définition :
– Un GUI est un outil graphique visuel
qui permet de communiquer avec un
utilisateur de votre programme.
Java
– Le paquetage qui contient tous les
composants pour faire un bon GUI
c’est javax.Swing.
(http://java.sun.com/docs/books/tutorial/uiswing/)
Graphical User Interface (GUI)
Java
– Swing hérite de java.awt (abstract
windowing toolkit). C’est l’ancienne
version utilisée pour la création de
GUI.
– Il existe deux principales classes pour
la création de GUI : Component et
Container (hérite de Component)
– Les classes de javax.Swing héritent
toutes de la classe JComponent qui
elle hérite de Container.
Quelques attributs de Component
• Attributs d’un Component
–
–
–
–
–
–
–
Point position
String name
Dimension size (width, height)
Color foreGround, backGround
Font font
Cursor cursor
Boolean visible, enabled
La classe Rectangle regroupe une position(x,y) et une
Dimension(width, height). Quelques méthodes acceptent (ou
retournent) un objet de cette classe.
Quelques méthodes de Component
• Quelques méthodes concernant la position et la taille
–
–
–
–
–
–
–
–
void setBounds(intx, inty, int width, int height);
void setBounds(Rectangle rect);
void setSize(Dimension d);
void setLocation(intx, inty);
void setLocation(Point p);
void setMinimumSize(Dimension d);
void setMaximumSize(Dimension d);
void setPreferredSize(Dimension d);
• Et tous les GET équivalents.
– Rectangle getBounds();
• Retourne la position et la dimension dans un rectangle
– Dimension getSize();
– Point getLocation();
– ...
Quelques méthodes de Container
• Un conteneur permet de contenir plusieurs composants.
• Quelques méthodes concernant les conteneurs
–
–
–
–
–
int getComponentCount();
Component getComponent(int index);
Component[] getComponents();
Component add(Component comp);
void paintComponent(Graphics g);
Pour qu’un conteneur contienne des composants, il faut
utiliser la méthode add.
Quelques conteneurs disponibles
• JFrame
– C’est une fenêtre nécessaire pour créer une
application Java.
– Elle hérite de la classe Container, elle peut
donc contenir n’importe quel composant.
– Un bon programmeur Java ne met pas les
composants directement dans un JFrame.
JPanel
JPanel (panneau):
– C’est un conteneur de composants qui peut
être mis dans une fenêtre.
– Un panneau est un lui-même composant.
– Un panneau peut contenir d’autres
panneaux.
JPanel
Exemple :
JPanel panneau = new JPanel();
JFrame f = new JFrame();
f.add(panneau);
***Le panneau est ajouté dans le JFrame
JFrame
L’organisation d’un JFrame :
– Cette fenêtre contient déjà une zone de titre,
un icône, un panneau principal (root pane) et
un panneau transparent (glass pane)
– Le panneau Root Pane contient un panneau
par couches (layered Pane).
JFrame
L’organisation d’un JFrame :
– Le panneau par couches (JLayeredPane)
contient une barre de menu (JMenuBar) et
un panneau pour mettre les composants
(Content Pane)
JFrame
Dans le cadre de ce cours, nous mettrons
principalement les composants dans le content
Pane.
JFrame
•
Pour faire apparaître un JFrame à l’écran il faut faire setVisible(true) à partir
d’un objet.
•
Pour faire disparaître un JFrame à l’écran il faut faire setVisible(false) à partir
d’un objet.
•
Par défaut un JFrame est en mémoire qu’il soit visible ou non.
•
Si on ferme un JFrame avec le X dans le coin droit, la fenêtre est seulement
rendu invisible.
•
Pour qu’une fenêtre libère la mémoire il faut faire :
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE) à partir d’un objet.
•
Pour qu’une application se termine il faut faire
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) à partir d’un objet.
JFrame
Exemple :
import javax.swing.JFrame;
import java.awt.Rectangle;
public class testFrame {
public static void main(String[] args) {
JFrame unFrame = new JFrame(" un titre ");
unFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
unFrame.setBounds(new Rectangle(100,100,200,200));
//on change la location avec le mutateur de position
unFrame.setLocation(300,300);
unFrame.setVisible(true);
}
}
Consultez l’api pour les JFrame
JButton
• Un JButton est un composant qui représente un
bouton à cliquer.
• Il peut être affiché avec du texte ou un icône ou
les deux.
Constructeurs :
–
–
–
–
JButton(); //bouton pas de texte ni d’icône
JButton(String text);
JButton(Icon icon); //voir ImageIcon
JButton(String text, Icon icon);
JButton
Exemple d’un bouton dans un JPanel dans
un JFrame.
import javax.swing.*;
import java.awt.*;
public class testFrame {
public static void main(String[] args) {
JFrame unFrame = new JFrame(" un titre ");
unFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
unFrame.setBounds(new Rectangle(400,400,200,200));
JPanel panneau = (JPanel) unFrame.getContentPane();
JButton b = new JButton("test");
panneau.setBackground(Color.BLUE);
panneau.add(b);
unFrame.setVisible(true);
}
}
La méthode getContentPane() retourne une référence sur le content Pane associé à un JFrame.
Gestion simple d’évènements
• La programmation Java est dite évènementielle.
•
• Pour chaque composant affiché, l’utilisateur peut
produire un ou plusieurs évènements.
– Ex: cliquer(gauche, droite, centre), déplacer la souris,
déplacer la souris en maintenant le bouton clic, etc.
Gestion simple d’évènements
• Il est possible de savoir quand ces évènements
ont lieu grâce à des écouteurs d’évènements
(listener).
• Les écouteurs sont des interfaces définies dans
Java.
Gestion simple d’évènements
Les écouteurs de bas niveaux sont ceux qui permettent de
gérer des événements système (souris, clavier,
mémoire, ...)
–
–
–
–
–
–
–
–
–
–
MouseListener
FocusListener
KeyListener
MouseMotionListener
MouseWheelListener
ComponentListener
ContainerListener
WindowListener
WindowFocsListener
WindowsStateListener
Gestion simple d’évènements
Les écouteurs de haut niveaux représentent une action de
l’utilisateur qui a un sens. Cela s’avère souvent être une
combinaison d’évènements de bas niveaux.
Exemple : Actionner un bouton est une pression et un relâchement du
bouton de la souris(un clique).
–
–
–
–
–
ActionListener (JButton)
AdjustementListener (JScrollBar)
AncestorListener (JComponent) //laissé aux experts
CaretListener(JTextComponent)
ChangeEventListener (JAbstractButton, JMenuItem, JProgressBar,
JSlider,...)
– DocumentEventListener (JTextComponent)
– HyperlinkEventListener(JEditorPane)
– ...
Gestion simple d’évènements
– Il y a une méthode prédéfinie dans les
interfaces écouteurs pour chaque
évènement.
– Il suffit d’écrire une classe qui implémente
une interface écouteur et d’écrire la
méthode voulue.
Gestion simple d’évènements
– Une référence d’une classe écouteur doit
être ajoutée dans un composant pour gérer
l’évènement(addActionListener,
addFocusListener, ...).
– Si un écouteur est ajouté et que l’évènement
associé à cet écouteur survient, la méthode
associée à l’évènement est exécutée.
Gestion simple d’évènements
ActionListener
•
Survient lors de l’activation d’un JButton. La méthode a
écrire est actionPerformed
public void actionPerformed(ActionEvent e)
•
Le paramètre de la classe ActionEvent fournit de
l’information sur le composant qui a levé l’évènement.
e.getActionCommand() retourne le texte du bouton, par défaut.
e.getSource() retourne une référence de l’objet qui a généré
l’évènement.
e.setActionCommand() permet de changer le texte par défaut
Gestion simple d’évènements
Exemple :
Démarrage d’un GUI
Démarrage d’un GUI
• Il est fortement conseillé de démarrer un
GUI dans un processus ainsi que le code
qui prend du temps à exécuter.
• Il trois façons de faire cela :
– Utiliser la classe Thread et l’interface
Runnable
– Utiliser javax.swing.SwingUtilities.invokeLater
et l’interface Runnable
– Utiliser la classe SwingWorker
Démarrage d’un GUI
• Runnable
– Interface qui demande d’implémenter une
méthode run() qui ne retourne rien
• Thread (Le constructeur reçoit une interface
Runnable)
– Thread t = new
Thread(uneClasseImplementantRunable);
– t.start();
Démarrage d’un GUI
• javax.swing.SwingUtilities.invokeLater
(Exécuteur d’une interface Runnable)
Exemple:
javax.swing.SwingUtilities.invokeLater(
new Runnable() {
public void run() {
//procédure qui crée le GUI
creerEtMontrerGUI();
}
}
);
Démarrage d’un GUI
• SwingWorker
– Doit redéfinir la méthode construct
final SwingWorker worker = new SwingWorker(){
public Object construct()
{
//...code à exécuter ici
}
};
worker.start(); //requis pour SwingWorker version 3
***Cette classe doit être récupérée sur le site de Sun car elle ne fait pas partie
des API standards de Java