IHM en Java

Sommaire

 Généralités sur les IHM

 AWT pour la construction de GUI
 Gestion d’évènements
 De AWT à SWING
Généralités sur les IHM
 Principes de base

1. Interface console : c’est le programme qui pilote

l’utilisateur, en le sollicitant quand nécessaire pour qu’il
fournisse des données. Le dialogue se fait en mode texte et
séquentiel dans une fenêtre appelée «Console»;
2. Interface graphique ou Graphical User Interface (GUI)
:
 C’est l’utilisateur qui pilote le programme, qui réagit à ses
demandes (sélection d’articles, d’item de menu, clic bouton,
…);
1. Chaque action de l’user = événement;
2. Programmation «évenementielle».
 IHM = Interface Homme Machine

L’interface visible d’une application est constituée de 2

types d’éléments :
1.Les conteneurs : ils contiennent des objets graphiques
qui peuvent être des composants atomiques ou d’autres
conteneurs;
2. Les composants atomiques : boutons, cases à cocher,
champ de texte, zone de texte, slider, etc.
 IHM = Interface Homme Machine 2
L’interface utilisateur comprend :
1.Une fenêtre de travail;
2.Une zone où afficher les composants graphiques de la
fenêtre de travail (ex : Panel)
3.Des composants à insérer dans la fenêtre (Boutons, cases à
cocher, menus, …)
4.Une mise en page des composants (Layout: mis bout à
bout, centrés, en tableau, …)
5.La représentation graphique des composants ( Couleur,
forme, image, …)
6.Des gestionnaires d’évènements (reponse aux actions de
l’utilisateur)
 Objectifs

 Construire des interfaces graphiques portables GUI

(Graphical User Interface). Deux technologies offertes :
1. AWT (Abstract Window Toolkit) depuis Java 1.1 : package
java.awt, gestion des évènements, composants limités;
2. SWING, depuis Java 2, étend AWT : javax.swing,
composants plus riches et plus performants.
 Comprendre la gestion d’évènements
 Programmation des écouteurs (Listeners)
 Usage des adaptateurs
Arborescence AWT/SWING
Arborescence AWT/SWING 2
AWT pour la construction de
GUI
 Modèle d’une application graphique
Une application AWT est composée de 3 éléments:
1. Les composants graphiques élémentaires ou widgets : boutons,
menu, zones de textes, zones de choix, …. Ils héritent tous de
java.awt.component
2. Le conteneur graphique global qui est une zone spatiale sur laquelle
les composants sont placés: fenêtre, frame, panneau, …. Ils héritent
de java.awt.containter
3. Le gestionnaire de présentation ou LayoutManager, qui détermine le
placement des composants sur le conteneur: FlowLayout,
BorderLayout, le GridLayout, …
 Illustration d'une application graphique
 Objectif : Construire un Frame contenant 2 boutons

 Rendu
Illustration d'une application graphique (v2)
 L'application étend Frame
import java.awt.*;

public class MonApplicationIllustrationV2 extends Frame {

private Button b1;
private Button b2;
public MonApplicationIllustrationV2() //Constructeur
{
super("Ma fenetre a moi V2");
setBounds(300,200, 400,200);
setLayout(new FlowLayout(FlowLayout.CENTER)); //Le Layout manager

b1 =new Button("D'accord ..."); //Un composant

add(b1);
b2 =new Button("Annuler ..."); //Un autre composant
add(b2);

setVisible(true);
}

public static void main(String[] args) {

new MonApplicationIllustrationV2();
}
}
 Les types de layouts

 FLowLayout  GridLayout

une trois one two three

deux

quatre four five six

cinq

 BorderLayout  GridBagLayout

North

West Center East

South
 Les composants

 AWT a un ensemble de composants couvrant

toutes les possibilités d'interaction Object

homme/machine Component

 AWT supporte les menus Canvas

TextComponent

MenuBar
TextField
TextField
Label
TextArea
Choice
List

List Label

Button

Choice
Checkbox
Scrollbar

Checkbox

CheckboxGroup
Button
Application AWT
import java.awt ;
–Structure globale
class MonApplicationAWT extends Frame
{ private TextField tf;
private Choice ch;
private List ls;
private Checkbox cbSolaris, cbLinux, cbMacOs;
private CheckboxGroup rbGroup;

public MonApplicationAWT() {
// TextField Panel
// Choice Panel
// List Panel
// Checkbox Panel
// Radiobox Panel
// Buttons Panel
// Menu
// Layout
}
public static void main(String[] args) {
new MonApplicationAWT();
}
}
 Les panneaux TextField et Choice

MonApplicationAWT() {
// TextField panel
Panel tfPanel = new Panel(
new FlowLayout(FlowLayout.LEFT));
tfPanel.setBackground(Color.lightGray);
tfPanel.add(new Label("TextField"));
tf = new TextField(15);
tfPanel.add(tf);

// Choice panel
Panel chPanel = new Panel(
new FlowLayout(FlowLayout.LEFT));
chPanel.setBackground(Color.lightGray);
chPanel.add(new Label("Choice"));
ch = new Choice();
ch.addItem("Solaris");
ch.addItem("Linux");
ch.addItem("MacOS");
chPanel.add(ch);
 Les panneaux List et Checkbox

// List panel
Panel lsPanel = new Panel(
new FlowLayout(FlowLayout.LEFT));
lsPanel.setBackground(Color.lightGray);
ls = new List();
ls.add("Motif");
ls.add("AWT");
ls.add("Windows");
lsPanel.add(new Label("List"));
lsPanel.add(ls);

// Checkbox panel
Panel cbPanel = new Panel(
new FlowLayout(FlowLayout.LEFT));
cbPanel.setBackground(Color.lightGray);
cbPanel.add(cbSolaris = new Checkbox("Solaris"));
cbPanel.add(cbLinux = new Checkbox("Linux"));
cbPanel.add(cbMacOs = new Checkbox("MacOS"));
 Boutons radio et boutons simples

// Radiobox panel
Panel rbPanel = new Panel(
new FlowLayout(FlowLayout.LEFT));
rbPanel.setBackground(Color.lightGray);
//CheckboxGroup (logique)
rbGroup = new CheckboxGroup();
rbPanel.add(new Checkbox("Solaris",rbGroup,true));
rbPanel.add(new Checkbox("Linux",rbGroup,false));
rbPanel.add(new Checkbox("MacOS",rbGroup,false));

// Buttons panel
Panel btPanel = new Panel(
new GridLayout(1,0,3,3));
Button ok = new Button("ok");
Button cancel = new Button("annuler");
Button quitter = new Button("quitter");
btPanel.add(ok);
btPanel.add(cancel);
btPanel.add(quitter);
 La barre de menu

Menu procMenu = new Menu("proceduraux");

procMenu.add(new MenuItem("Pascal"));
procMenu.add(new MenuItem("C"));

Menu functMenu = new Menu("fonctionnels");

functMenu.add(new MenuItem("Lisp"));
functMenu.add(new MenuItem("ML"));

Menu objMenu = new Menu("objets");

objMenu.add(new MenuItem("C++"));
objMenu.add(new MenuItem("Smalltalk"));

Menu langagesMenu = new Menu("Langages");

langagesMenu.add(procMenu);
langagesMenu.add(functMenu);
langagesMenu.add(objMenu);

MenuBar bMenu = new MenuBar();

bMenu.add(langagesMenu);
setMenuBar(bMenu);
 Assemblage des panneaux
public MonApplicationAWT() { //Constructeur
...
// Layout
setLayout(new GridBagLayout());
GridBagConstraints gbc =new
GridBagConstraints();
gbc.fill = GridBagConstraints.BOTH;
gbc.gridwidth = GridBagConstraints.REMAINDER;
gbc.insets = new Insets(5,0,0,0); // top
add(tfPanel,gbc);
add(chPanel,gbc);
add(lsPanel,gbc);
add(cbPanel,gbc);
add(rbPanel,gbc);
gbc.insets = new Insets(5,0,5,0); // top-
bottom
add(btPanel,gbc);
}

 Un objet GridBagConstraints dit comment disposer

 NB : un GridLayout produit des blocs de même taille
Gestion des évènements
 Gestion des évènements

 La gestion des évènements Java 2 obéit au modèle Event Délégation Model :

 Les objets graphiques délèguent le contrôle des évènements utilisateur à des
entités externes dites Listeners (Ecouteurs)
 Ce modèle est requis pour des soucis d'amélioration de performances
 Les écouteurs d'évènements sont des interfaces regroupées par familles d'évènements et
isolées dans java.awt.event.
 On distingue ActionListener, MouseListener,
MouseMotionListener, WindowListener, …
 Pour programmer les évènements sur un composant :
1. Choisir le type d'écouteur, et l'enregistrer sur le composant avec la méthode
addXYZListener()
2. Implémenter le listener XYZ en définissant chacune de ses méthodes
 Gestion des évènements (Exemple)

import java.awt.*;
import java.awt.event.*;

public class MonApplication_ActionListener_V1 {

public static void main(String[] args) {
Frame f = new Frame ("Ma fenetre a moi "); //Le container
...
Button b1 =new Button("D'accord ..."); //Un composant
b1.addActionListener(new Ecouteur_b1()); //Enregistrement de l'écouteur
...
Button b2 =new Button("Annuler ..."); //Un autre composant
b2.addActionListener(new Ecouteur_b2());//Enregistrement de l'écouteur
...
}}
class Ecouteur_b1 implements ActionListener {
public void actionPerformed(ActionEvent e){
System.out.println(" Vous êtes d'accord ... Merci");
}}
class Ecouteur_b2 implements ActionListener{
public void actionPerformed(ActionEvent e){
System.out.println(" Vous avez choisi d'annuler ... au revoir");
//System.exit(-1);
}}
 Gestion des évènements (Exemple ++)
 Objectif : avoir un seul écouteur au lieu de deux
import java.awt.*;
import java.awt.event.*;

public class MonApplication_ActionListener_V2 {

public static void main(String[] args) {
Frame f = new Frame ("Ma fenetre a moi "); //Le container
...
Button b1 =new Button("D'accord ..."); //Un composant
b1.setActionCommand("Label1");
b1.addActionListener(new Ecouteur_Bouton()); //Enregistrement de
l'écouteur
...
Button b2 =new Button("Annuler ..."); //Un autre composant
b2.setActionCommand("Label2");
b2.addActionListener(new Ecouteur_Bouton());//Enregistrement de l'écouteur
...
}}
class Ecouteur_Bouton implements ActionListener {
public void actionPerformed(ActionEvent e)
{ if (e.getActionCommand() == "Label1")
System.out.println(" Vous êtes d'accord ... Merci");
else
System.out.println(" Vous avez choisi d'annuler ... Au revoir");
}}
 Gestion des évènements (Rajout d'un Window
Listener)
 Objectif : Programmer la fermeture de la fenêtre
import java.awt.*;
import java.awt.event.*;

public class MonApplication_WindowListener_V1 {

public static void main(String[] args) {
Frame f = new Frame ("Ma fenetre a moi "); //Le container
f.addWindowListener(new Ecouteur_Fenetre()); //Enregistrement de l'écouteur
...

}}
class Ecouteur_Fenetre implements WindowListener
{
public void windowActivated(WindowEvent e) {} //obligatoire même si
vide
public void windowClosed(WindowEvent e) {}
public void windowClosing(WindowEvent e) {
System.out.println(" Au revoir !!!");
System.exit(-1);
}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowOpened(WindowEvent e) {}
}
 Adaptateurs

 L'implémentation d'une interface nécessite de développer toutes ses

méthodes, ce qui peut être considéré onéreux (en temps de
developpement).
 Afin de réconforter les développeurs, java.awt.event a prévu un
ensemble de classes, dites adaptateurs, qui implémentent toutes les
méthodes des interfaces avec un comportement vide.
 Ainsi, au lieu d'implémenter des interfaces, la programmation
consistera à étendre les adaptateurs et à ne redéfinir que les méthodes
souhaitées.
 L'interface ActionListener n'a pas d'adaptateur étant donné qu'elle ne
contient qu'une unique méthode actionPerformed()
 Introduction d'un WindowAdapter
 Objectif : Programmer la fermeture de la
fenêtre avec l'adaptateur WindwAdapter
import java.awt.*;
import java.awt.event.*;

public class MonApplication_windwoListener_V2 {

public static void main(String[] args) {
Frame f = new Frame ("Ma fenetre a moi "); //Le container
f.addWindowListener(new Ecouteur_Fenetre());//Ajout de l'écouteur
...
}
}
class Ecouteur_Fenetre extends WindowAdapter
{
// On ne redéfint que la méthode de la fermeture de la fenêtre
public void windowClosing(WindowEvent e) {
System.out.println(" Au revoir !!!");
System.exit(-1);
}
}
 Le WindowAdapter déclaré en ligne
 Objectif : Programmer la fermeture de la fenêtre en ligne,
commodité souvent utilisée par les développeurs.
import java.awt.*;
import java.awt.event.*;

public class MonApplication_windwoListener_V3 {

public static void main(String[] args) {
Frame f = new Frame ("Ma fenetre a moi ");//Le container
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) {
System.out.println(" Au revoir !!!");
System.exit(-1);
}
});
...
}
}
De AWT à SWING
 SWING vs. AWT Object Container

JComponent
Component

Container AbstractButton
 Les composants Swing constituent une évolution naturelle
JComponent JToggleButton
des composants AWT. javax.Swing comporte les éléments
suivants : Panel
JCheckBox
 Les conteneurs de plus haut niveau : JFrame, Japplet, Applet JRadioButton
…
JApplet JButton
 Les composants légers (Light-Weight) : JButton,
Window JMenuButton
JCheckBox, etc.
 SWING réorganise les classes selon JFC (Java JWindow JMenu

Foundation Classes) Frame JRadioButtonMenuItem

JCheckButtonMenuItem
 Nombreux nouveaux composants JFrame

Dialog JColorChooser
 Nombreuses facilités JComboBox
JDialog
 Modèle MVC :séparation entre JInternalFrame

 modèle (données) JLabel

JList
 aspect visuel (UI)
JMenuBar
 contrôle
JOptionPane
 Les composants Swing se placent dans un conteneur de plus JPanel
haut niveau “ContentPane” : C’est la fenêtre visible.
JPopupMenu

JProgressBar

...
 SWING : Généralités
 Les widgets
 javax.swing.JButton
 javax.swing.JRadioButton
 javax.swing.JCheckBox
 javax.swing.JLabel
 javax.swing.JList
 …
 javax.swing.JTable
 javax.swing.JSplitPane
 javax.swing.JSlider
 javax.swing.JProgressBar
 SWING est compatible avec AWT. Il utilise le même modèle d'évènements et les
mêmes gestionnaires de Layouts de l'AWT.
 JFrame
 Une JFrame contient une fille unique,
JFrame
de la classe JRootPane
 Cette fille contient deux filles, JRootPane

glassPane (JPanel) et layeredPane glassPane layeredPane

(JLayeredPane)
contentPane menuBar
 La layeredPane a deux filles,
contentPane (JPanel) et menuBar
(JMenuBar)
 On travaille dans contentPane. class MonAppli extends JFrame {
MonAppli() {
 JApplet, JWindow et JDialog sont JPanel panel;
getContentPane().add(panel);
semblables. ...
}
...
}
 Modèles et vues
 Les composants (sauf les conteneurs) ont un modèle qui contient les données associées
 ButtonModel pour les boutons
 ListModel pour les données d’une JList
 TableModel pour les JTable
 TreeModel pour les JTree
 Document pour tous les composants de texte

 La vue d’un composant est aggrégé en un délégué UI (User Interface)

 détermine le look-and-feel du composant (bord, couleur, ombre, forme des coches)
 peut-être changé
 est parfois spécifié par un dessinateur (renderer) à un niveau plus élevé
 un changement global, pour tous les composants, est le pluggable look and feel
(plaf)
 trois implémentations (quatre ave le Mac) existent : Windows, CDE/Motif, Metal
(défaut).
 Le contrôle est assuré par le modèle.
 Exemples SWING : JFrame
import javax.swing.*;
import java.awt.*; //Pour le FlowLayout
class MonFrame_V0 extends JFrame
{
private JButton b1 = new JButton("Tic");
private JButton b2 = new JButton("Tac");
private JButton b3 = new JButton("Toe");

public MonFrame_V0(){
setSize(new Dimension(220,150));
setTitle("Mon tout premier JFrame");
getContentPane().setLayout(new
flowLayout());
getContentPane().add(b1);
getContentPane().add(b2);
getContentPane().add(b3);
setVisible(true);
}

public static void main(String args[]){

new MonFrame_V0();
}
}
 Exemples SWING : JApplet
import java.awt.*; //pour le Layout
import javax.swing.*;

public class MonJApplet_V0 extends JApplet

{
private JLabel lab = new JLabel("Votre nom :");
private JTextField tf = new JTextField(10);

public void init()

{
getContentPane().setBackground(new Color (210,235,210));
getContentPane().setLayout(newFlowLayout(FlowLayout.LEFT));
getContentPane().add(lab);
getContentPane().add(tf);
}
}
 Exemple SWING : Les onglets (JTabbedPane)
import javax.swing.*;
import java.awt.*;
class MonJTabbedPane_V0 extends JFrame {
private JTabbedPane tabbedPane = new JTabbedPane();
privateJPanel p1 = new JPanel();
privateJPanel p2 = new JPanel();
privateJPanel p3 = new JPanel();
privateJTextArea textArea = new JTextArea();
privateJLabel textAreaLabel = new JLabel();
privateJButton benvoyer = new JButton();
public MonJTabbedPane_V0(){ //Constructeur
setTitle("Exemple d'onglets");
setSize(400,250);
textArea.setBounds(14,29,234,154);
textAreaLabel.setText("Indiquez votre souhait");
textAreaLabel.setBounds(14,7,211,15);
benvoyer.setText("Envoyer");
benvoyer.setBounds(258,158,121,23);
p1.setLayout(null); //Caractérisation du panneau p1
p1.add(textArea, null);
p1.add(textAreaLabel, null);
p1.add(benvoyer,null);
//Définition des onglets
tabbedPane.addTab("Saisie de texte", p1);
tabbedPane.addTab("Couleur", p2);
tabbedPane.addTab("Fontes", p3);
getContentPane().add(tabbedPane,BorderLayout.CENTER);
setVisible(true);
}
public static void main(String [] args){
new MonJTabbedPane_V0();
}}
 Exemple SWING : Le contrôle JTable
import javax.swing.*;
import javax.swing.table.*;
import java.awt.Dimension;
class MonJTable_V0 extends JFrame{
public MonJTable_V0(){
final Object[][]lignes = {
{new Integer(15),"Romdhani","Mohamed","30-09-1967","Kairouan"},
{new Integer(20),"Ben Salah","Ali","12-10-1975","Sfax"},
{new Integer(25),"Mahjoub","Mona","15-03-1990","Gafsa"},
{new Integer(30),"Amri","Khaled","21-10-1973","Tunis"},
{new Integer(30),"Achour","Salma","30-07-2001","Tunis"}};
final Object[] colonnesNom={"Nins", "Nom", "Prénom", "DN","Lieu"};
TableModel dataModel = new AbstractTableModel(){ //Inner class
public int getColumnCount(){return colonnesNom.length;}
public int getRowCount(){return lignes.length;}
public Object getValueAt(int l, int c) {return lignes[l][c];}
public String getColumnName(int col) {return
(String)colonnesNom[col];}
public Class getColumnClass(int cl) {return
getValueAt(0,cl).getClass();}
};// fin de définition de AbstractTableModel
JTable table = new JTable(dataModel);
JScrollPane scrollpane = new JScrollPane(table);
scrollpane.setPreferredSize(new Dimension(500, 300));
setTitle("Mon exemple JTable");
getContentPane().add(scrollpane);
pack();
setVisible(true);
}
public static void main(String[] args) {
new MonJTable_V0();
}}
 Look and feel
 Trois “look and feel” existent, de noms
"com.sun.java.swing.plaf.windows.WindowsLookAndFeel"
"com.sun.java.swing.plaf.motif.MotifLookAndFeel"
"javax.swing.plaf.metal.MetalLookAndFeel”

 On essaye de l’utiliser par

UIManager.setLookAndFeel(lf);

 et de l’appliquer à la racine de l’arbre par

SwingUtilities.updateComponentTreeUI(
SwingUtilities.getRoot(this));
 Plaf : le menu
public class PlafMenu extends JMenu implements ActionListener {
UIManager.LookAndFeelInfo[] lfi = UIManager.getInstalledLookAndFeels();
public PlafMenu () {
super("Plaf");
ButtonGroup rbGroup = new ButtonGroup();
JRadioButtonMenuItem rb;
String lfs = UIManager.getCrossPlatformLookAndFeelClassName();
String lfName;
for (int i = 0; i < lfi.length; i++) {
rb = new JRadioButtonMenuItem(lfi[i].getName());
rb.addActionListener(this);
rbGroup.add(rb);
add(rb);
lfName = lfi[i].getClassName();
if (lfs.equals(lfName))
rb.setSelected(true); // par defaut
else
try {
LookAndFeel lf = (LookAndFeel) Class.forName(lfName).newInstance();
if (!lf.isSupportedLookAndFeel()) // n’est pas “supporté” par la plate-forme
rb.setEnabled(false);
}
catch ( Exception ex ) {
rb.setEnabled(false);
}
}
}...
 Plaf : changement
...
public void actionPerformed(ActionEvent e) {
String lfName = null;
String comm = e.getActionCommand();
for (int i = 0; i < lfi.length; i++)
if (comm.equals(lfi[i].getName())) {
lfName = lfi[i].getClassName();
break;
}
try {
UIManager.setLookAndFeel(lfName);
SwingUtilities.updateComponentTreeUI(SwingUtilities.getRoot(this));
}
catch ( Exception ex ) {
System.err.println( "Could not load " + lfName );
}
}
 Exemple complet SWING + Plaf (1/5)
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

public class MonApplicationSwingPlaf extends JFrame

implements ActionListener {
JTextField tf; JComboBox ch; JList ls;
JCheckBox cbSolaris, cbLinux, cbMacOs;
ButtonGroup rbGroup;

public MonApplicationSwingPlaf() {
// JTextField
JPanel tfPanel = new JPanel(new
FlowLayout(FlowLayout.LEFT));
tfPanel.add(new JLabel("TextField"));
tf = new JTextField(15);
tfPanel.add(tf);
// JComboBox
JPanel chPanel = new JPanel(new
FlowLayout(FlowLayout.LEFT));
chPanel.add(new JLabel("Combobox"));
ch = new JComboBox();
ch.addItem("Solaris"); ch.addItem("Linux");
ch.addItem("MacOS");
chPanel.add(ch);
...
 Exemple complet SWING + Plaf (2/5)
JPanel lsPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
String[] donnees = { "Motif", "AWT", "Windows", "Swing" ,
"IlogViews", "XWindow", "Tcl/Tk", "gtk", "gnome"};
ls = new JList(donnees);
lsPanel.add(new JLabel("Liste"));
lsPanel.add(new JScrollPane(ls)); // ascenseur
JPanel cbPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
cbPanel.setBorder(new TitledBorder("Boutons a cocher"));
cbPanel.add(cbSolaris = new JCheckBox("Solaris"));
cbPanel.add(cbLinux = new JCheckBox("Linux"));
cbPanel.add(cbMacOs = new JCheckBox("MacOS"));
JPanel rbPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
rbPanel.setBorder(new TitledBorder("Boutons radio"));
rbGroup = new ButtonGroup();
JRadioButton rb;
rb = new JRadioButton("Solaris",true);
rb.setActionCommand("Solaris");
rbPanel.add(rb); rbGroup.add(rb);
rb = new JRadioButton("Linux",false);
rb.setActionCommand("Linux");
rbPanel.add(rb); rbGroup.add(rb);

rb = new JRadioButton("MacOS",false);
rb.setActionCommand("MacOS");
rbPanel.add(rb); rbGroup.add(rb);
...
 Exemple complet SWING + Plaf (3/5)
//Buttons panel
JPanel btPanel = new JPanel( new GridLayout(1,0,3,3));
JButton ok = new JButton("ok");
JButton cancel = new JButton("annuler");
JButton quitter = new JButton("quitter");
btPanel.add(ok); btPanel.add(cancel); btPanel.add(quitter);

//Menus
//JMenu functMenu = new JMenu("fonctionnels");
JMenu procMenu = new JMenu("proceduraux");
procMenu.add(new JMenuItem("Pascal"));
procMenu.add(new JMenuItem("C"));

JMenu functMenu = new JMenu("fonctionnels");

functMenu.add(new JMenuItem("Lisp"));
functMenu.add(new JMenuItem("ML"));

JMenu objMenu = new JMenu("objets");

objMenu.add(new JMenuItem("C++"));
objMenu.add(new JMenuItem("Smalltalk"));

JMenu langagesMenu = new JMenu("Langages");

langagesMenu.add(procMenu);
langagesMenu.add(functMenu);
langagesMenu.add(objMenu);
...
 Exemple complet SWING + Plaf (4/5)
PlafMenu mon_plaf_a_moi = new PlafMenu(); //PlafMenu est défini dans
// une classe publique à part
JMenuBar bMenu = new JMenuBar();
bMenu.add(langagesMenu);
bMenu.add(mon_plaf_a_moi);

getRootPane().setJMenuBar(bMenu);

JPanel panneau = (JPanel)getContentPane();

panneau.setLayout( new BoxLayout(panneau, BoxLayout.Y_AXIS));
panneau.add(Box.createVerticalStrut(5));// Un “Strut” est un composant
// réduit à un espacement rigide
panneau.add(tfPanel);
panneau.add(Box.createVerticalStrut(5));
panneau.add(chPanel);
panneau.add(Box.createVerticalStrut(5));
panneau.add(lsPanel);
panneau.add(Box.createVerticalStrut(5));
panneau.add(cbPanel);
panneau.add(Box.createVerticalStrut(5));
panneau.add(rbPanel);
panneau.add(Box.createVerticalStrut(5));
panneau.add(btPanel);
}
...
 Exemple complet SWING + Plaf (5/5)
public void actionPerformed(ActionEvent e) { // boutons
if (e.getActionCommand().equals("quitter"))
System.exit(0);
System.out.println();
// Texte : getText()
System.out.println( "textfield = " + tf.getText());
// ComboBox : getSelectedItem()
System.out.println( "combobox = " + ch.getSelectedItem());
// Liste : getSelectedValue()
System.out.println( "list = " + ls.getSelectedValue());
// CheckBox : isSelected()
System.out.println( "checkbox = " + cbSolaris.isSelected()
+ " " + cbLinux.isSelected() + " " + cbMacOs.isSelected());
// Radio : group.getSelection().getActionCommand()
System.out.println("radiobox =“ + rbGroup.getSelection().getActionCommand() );
}

public static void main(String[] args) {

MonApplicationSwingPlaf t = new MonApplicationSwingPlaf();
t.pack();
t.setVisible(true);
}
}
Les Layout
 FlowLayout
Ligne par ligne, de gauche à droite
public class Fenetre extends JFrame{

public Fenetre() {
super();
setTitle(" Titre de la Fenetre ");
setSize(300, 150);
setLayout(new FlowLayout());
add(new Button("Bouton 1"));
add(new Button("Bouton 2"));
add(new Button("Bouton 3"));
pack();
setVisible(true);
}

public static void main(String[] args){

new Fenetre();
}
}
 BorderLayout
5 emplacements : North, South, East, West, Center

public class Fenetre extends JFrame{

public Fenetre() {
super();
setTitle(" Titre de la Fenetre ");
setSize(300, 150);
setLayout(new BorderLayout());
add("North", new Button(" bouton haut "));
add("South", new Button(" bouton bas "));
add("West", new Button(" bouton gauche "));
add(new Button(" bouton droite "),
BorderLayout.EAST);
add("Center", new Button(" bouton milieu "));
pack();
setVisible(true);
}

public static void main(String[] args){

new Fenetre();
}
}
 GridLayout
Comme un tableau, les éléments sont dans des cellules

public class Fenetre extends JFrame{

public Fenetre() {
super();
setTitle(" Titre de la Fenetre ");
setSize(300, 150);
setLayout(new GridLayout(2, 3));
add(new Button("bouton 1"));
add(new Button("bouton 2"));
add(new Button("bouton 3"));
add(new Button("bouton 4"));
add(new Button("bouton 5 tres long"));
add(new Button("bouton 6"));
pack();
setVisible(true);
}

public static void main(String[] args){

new Fenetre();
}
}
 GridBagLayout
Les éléments peuvent être dans plusieurs cellules, +flexible
public class Fenetre extends JFrame{
public Fenetre() {
super();
setTitle(" Titre de la Fenetre ");
setSize(300, 150);
JPanel panel = new JPanel();
GridBagLayout layout = new GridBagLayout();
panel.setLayout(layout);
GridBagConstraints gbc = new GridBagConstraints();

gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.gridx = 0;
gbc.gridy = 0;
panel.add(new JButton("Button1"), gbc);

gbc.gridx = 1;
gbc.gridy = 0;
panel.add(new JButton("Button 2"), gbc);

gbc.gridx = 0;
gbc.gridy = 2;
gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.gridwidth = 2;
panel.add(new JButton("Button 3"), gbc);
getContentPane().add(panel);
setVisible(true);
}
 GridBagLayout
Les éléments peuvent être dans plusieurs cellules, +flexible

• gridx : position en x dans le grille

• gridy : position en y dans la grille
• gridwidth : nombre de colonnes occupées
• gridheight : nombre de lignes occupées
GridBagLayout
Exemple plus complexe
Couplage AWT/SWING
et JDBC
 Principe du couplage
 AWT et SWING offrent les composants permettant aussi bien de
saisir des données afin de préparer des requêtes, que d'afficher les
résultats des requêtes de manière ergonome.
 Le lien entre l'interface GUI et le mécanisme JDBC est la gestion
d'évènements
 L'événement de validation de l'interface provoque la dynamique
JDBC et permet de retourner les résultats sur la même boite de
dialogue
 SWING offre le contrôle Jtable (javax.swing) avec son modèle
générique AbstractTableModel (javax.swing.table) qui est commode
pour l'affichage des résultats des requêtes select
 AWT et JDBC –Illustration (1/2)
import java.sql.*;
import java.awt.*;
import java.awt.event.*;
public class JDBC_Avec_Client_AWT extends Frame implements ActionListener {
TextField departement;
TextArea table;
Panel p;
String url = "jdbc:mysql://localhost:3306/bdpersonnel";
String driver = "com.mysql.jdbc.Driver";
Connection conn;
Statement state;
public static void main(String[] args) {
JDBC_Avec_Client_AWT dbInst = new JDBC_Avec_Client_AWT();
dbInst.setSize(400, 300);
dbInst.setVisible(true);
}
public JDBC_Avec_Client_AWT() { //Le constructeur
super("JDBC_Avec_Client_AWT - TextArea");
setLayout(new BorderLayout());
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) { System.exit(0); }
});
p = new Panel();
p.setLayout(new FlowLayout());
p.add(new Label("Numéro du département :"));
p.add(departement = new TextField(5));
departement.addActionListener(this);
Button B = new Button("rechercher");
B.addActionListener(this);
B.setActionCommand("rechercher");
p.add(B);
add(p,BorderLayout.NORTH);
table = new TextArea("",20,20,TextArea.SCROLLBARS_NONE);
add(table, BorderLayout.CENTER);
} …
 AWT et JDBC –Illustration (2/2)
public void actionPerformed(ActionEvent evt) {
if (evt.getActionCommand().equals("rechercher")) {
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, usr, pwd);
state = conn.createStatement();
String sql = "SELECT * FROM etudiant WHERE id = "+
etudiant.getText();
ResultSet results = state.executeQuery(sql);
ResultSetMetaData metadonnees = results.getMetaData();
int columns = metadonnees.getColumnCount();
for(int i = 0; i < columns; i++)
table.append(metadonnees.getColumnLabel(i+1) + " | ") ;
table.append("\n");
while(results.next ()) {
for(int i = 0; i < columns; i++)
table.append(results.getString(i+1) + " | ");
table.append("\n");
}
results.close(); state.close(); conn.close();
}
catch(Exception e) {
System.err.println("Attention, Une exception : "+ e.toString());
}
} Fin du if
} //Fin de actionPerformed
} // fin de la classe