IHM7

Interfaces Homme - Machine
Chapitre 7 :
Les Menus
SMI - S6
Année universitaire 2018-2019
Prof. M.D. RAHMANI
mrahmani@fsr.ac.ma
Plan
Hiérarchie des composants pour les menus,
Les composants d'un menu:
JMenuBar
JMenu
Eléments d'un menu:
JMenuItem
JRadioButtonMenuItem
JCheckButtonMenuItem
Menu surgissant JPopupMenu
Création d'un menu
Positionnement de menus
Imbrication des composants
Les raccourcis du clavier
Construction d'un menu avec écouteurs
Menu surgissant
Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 2
1
Les menus (1)
Les menus peuvent être crées de 2 manières :
Les menus déroulants (Drop-Down Menu) : les éléments,

généralement rassemblés dans une barre de menus (JMenuBar), sont
affichés (déroulés) lorsque l'utilisateur clique sur le titre de l'élément
(JMenu).
Les menu contextuels, surgissants (Popup Menu) : les éléments sont

affichés en réaction à un clique sur le bouton droit de la souris et sont
présentés dans une fenêtre Pop-up indépendante (JPopupMenu) qui
est affiché à l'emplacement où l'on a déclenché le menu contextuel.
Les menus (2)

Contrairement aux menus déroulants JMenu, les composants contextuels
JPopupMenu nécessitent de définir un gestionnaire d'événement pour
déclencher l'affichage.
L'affichage d'un menu contextuel est effectué par invocation de la méthode

show() de JPopupMenu associée à l'interface MouseListener.
Caractéristiques : Les éléments (options, items) de menu peuvent :

contenir une image,
être de type bouton radio ou case à cocher,
avoir des raccourcis clavier, sous forme de mnémoniques ou
d'accélérateurs.
2
Les différentes classes d'un Menu
Les menus sont mis en œuvre avec un ensemble de classes:
JMenuBar: Une barre de menus contenant des composants JMenu,
JMenu: Un menu déroulant ou un sous-menu représenté par une étiquette (titre),
JMenuItem: Un élément (option) d'un menu ou d'un sous-menu,
JRadioButtonMenuItem: Un élément d'un menu sous la forme d'un bouton radio,
JCheckBoxMenuItem: Un élément d'un menu sous la forme d'une case à cocher,
JSeparator, Un élément d'un menu sous la forme d'un séparateur de groupes
d'éléments,
JPopupMenu, Un menu contextuel (surgissant),
Toutes ces classes héritent de la classe JComponent.

Les éléments de menus cliquables héritent de la classe JAbstractButton.
MenuShortcut, ajout d'accélérateurs.
Hiérarchie des composants pour les menus

Object
Component
Container
JComponent MenuShortcut
JMenuBar JPopupMenu JAbsractButton JSeparator
JMenuItem
JMenu JCheckboxMenuItem JRadioButtonMenuItem
3
Les composants d'un Menu (1)
1- La classe JMenuBar:
La construction de menus commence par la création d'une barre de menu
JMenuBar,
JMenuBar barre = new JMenuBar(); // création de la barre de menu
Pour ajouter des menus dans une barre de menu, on utilise la méthode add(),
barre.add(unMenu); // ajout d'un menu à la barre de menu
Pour associer la barre de menu à une fenêtre, on utilise la méthode

setJMenuBar(barre),
fenetre.setJMenuBar(barre); // association à une fenêtre
Remarque: Comme la classe JMenuBar hérite de la classe JComponent, il

est possible de créer plusieurs objets de type JMenuBar et de les positionner
par un gestionnaire de placement.

2- La classe JMenu: Cette classe permet de créer un menu.
Un menu sera composé d'un ou plusieurs éléments (items) de menu.
JMenu menu = new JMenu(); // créer un menu
menu.setText("Mon Menu"); // affecter le texte (titre) au menu
// affecter une icône au menu
menu.setIconImage(new ImageIcon(getImage("./image.png")));
menu.setMnemonic(KeyEvent.VK_M); // affecter le raccourci alt+M
barre.add(menu); // ajouter le menu dans la barre de menu
Un menu peut être ajouté à un autre menu : on parle alors de sous-menus.
Pour ajouter des items dans un menu ou un sous menu:

menu.add(unItem)
Pour insérer une séparation dans la liste des items

menu.addSeparator()
4
3- Eléments de menu : items (options) d'un menu ou d'un sous menu.
Il y a trois sortes d'éléments de menu :
3.1- La classe JMenuItem

Ce composant permet de créer un élément de menu.
Cet item peut être muni d'un texte, d'une icône, d'un mnémonique et d'un accélérateur.
Il peut être actif ou inactif.
JMenuItem mi = new JMenuItem(); // création
mi.setText("le texte"); // affectation du texte
mi.setIcon(new ImageIcon(getImage("./image.png"))); // affectation d'une image
mi.setEnabled(true); // l'item de menu est actif
menu.add(mi); // ajout de l'item à un menu

3- Item de menu
3.2- La classe JRadioButtonMenuItem
Un item de menu peut être un bouton radio. Il permet de faire des choix exclusifs :
on utilise un ButtonGroup pour grouper les boutons radio : un seul bouton du groupe peut
être sélectionné.
JRadioButtonMenuItem rb1 = new JRadioButtonMenuItem();
rb1.setSelected(true); // bouton choisi par défaut
ButtonGroup bg = new ButtonGroup();
bg.add(rb1);
bg.add(rb2);
bg.add(rb3);
menu.add(rb1); // ajout de l'item jrb1 à un menu
3.3- La classe JCheckButtonMenuItem

Un item de menu peut être une case à cocher.
Les méthodes isSelected() et setSelected(boolean b) permettent de
savoir si une case est cochée, et de la cocher ou de la décocher.
5
4- La classe JPopupMenu
Un menu surgissant se construit comme un menu, mais qui n'est pas rattaché à une barre
de menus mais à un composant.
Pour afficher un menu surgissant, il faut ajouter un écouteur d'événements et utiliser la
méthode show() de la classe JPopupMenu pour l'affichage.
JPopupMenu popup = new JPopupMenu();
JMenuItem item = new JMenuItem("un item surgissant"); // 1er élément
popup.add(item);
item = new JMenuItem("un autre item surgissant"); // 2 ème élément

popup.add(item);
popup.addSeparator(); // 3 ème élément, un séparateur
item = new JMenuItem(); // 4 ème élément avec écouteur

item.setText("Quitter");
item.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev) {
System.exit(0);
}
});
popup.add(item);
Création d'un menu (1)

Classes utilisées:
JMenuBar: représente la barre de menu d'une fenêtre,

Fichier Aide
JMenu: options visibles dans la barre de menu, Nouveau A propos
Quitter
JmenuItem: élément qui déclenchera par sa sélection
une action définie par le programmeur.
6
Exemple 1 (1ère version): MenuEditeur1.java
import javax.swing.*;
public class MenuEditeur1 extends JMenuBar {
JMenuItem nouveau, ouvrir, quitter, aPropos;
public MenuEditeur1() {
JMenu menuFichier = new JMenu("Fichier"); // création des éléments du menu
nouveau = new JMenuItem("Nouveau");
ouvrir = new JMenuItem("Ouvrir");
quitter = new JMenuItem("Quitter");
// ajout des éléments JMenuItem dans un JMenu
menuFichier.add(nouveau);
menuFichier.add(ouvrir);
menuFichier.addSeparator(); // pour séparer
menuFichier.add(quitter);
JMenu menuAide = new JMenu("Aide");
aPropos = new JMenuItem("A propos");
menuAide.add(aPropos);
// ajout des objets JMenu dans la barre de menus
add(menuFichier);
add(menuAide);
}
}

Exemple 1 (suite 1ère version): FenetreAvecMenu.java
public class FenetreAvecMenu extends JFrame {
public FenetreAvecMenu(){
setTitle("Fenêtre avec menu");
setSize(400,200);
setJMenuBar(new MenuEditeur1());
setVisible(true);
}
public static void main(String[] args) {

new FenetreAvecMenu();
}
}
7
Exemple 1 (2ème version): MenuEditeur2.java
public class MenuEditeur2 extends JFrame {
public MenuEditeur2() {
JMenuItem nouveau = new JMenuItem("Nouveau");
JMenuItem ouvrir = new JMenuItem("Ouvrir");
JMenuItem quitter = new JMenuItem("Quitter");
menuFichier.add(nouveau); // ajout des éléments JMenuItem dans un JMenu
JMenuItem aPropos = new JMenuItem("A propos");
// création de la barre de menu et ajout des objets JMenu
JMenuBar bar = new JMenuBar();
bar.add(menuFichier);
bar.add(menuAide);
setTitle("Fenêtre avec menu"); setSize(400,200);
setDefaultCloseOperation(3);
setJMenuBar(bar);
setVisible(true);
}
new MenuEditeur2();
}
}
Positionnement de menus (1)

JMenuBar est un composant qui dérive de JComponent, par conséquent nous
pouvons créer autant de composants JMenuBar et les positionner dans une fenêtre.
Exemple 2: MenuEditeur.java
public class MenuEditeur extends JMenuBar {
JMenuItem nouveau, ouvrir, quitter, aPropos;
public MenuEditeur() {
nouveau = new JMenuItem("Nouveau");
ouvrir = new JMenuItem("Ouvrir");
quitter = new JMenuItem("Quitter");
menuFichier.add(nouveau); // ajout au menu des éléments de menu

aPropos = new JMenuItem("A propos");
add(menuFichier); // ajout des menus à la barre de menu
add(menuAide);
}
}
8
Positionnement de menus (2)
Exemple 2 (suite): FenetreAvec2Menus.java
public class FenetreAvec2Menus extends JFrame {
public FenetreAvec2Menus(){
setTitle("Fenêtre avec 2 menus");
setSize(400,200);
add(new MenuEditeur(), BorderLayout.NORTH);
add(new MenuEditeur(), BorderLayout.SOUTH);
setVisible(true);
}

new FenetreAvec2Menus();
}
}
Imbrication de menus (1)

Exemple 3 : MenuEditeurP.java
public class MenuEditeurP extends JMenuBar {
public MenuEditeurP() {
// création des éléments du menu
JMenu menuFichier = new JMenu("Fichier");
JMenuItem nouveau = new JMenuItem("Nouveau");
JMenuItem ouvrir = new JMenuItem("Ouvrir");
JMenuItem quitter = new JMenuItem("Quitter");
menuFichier.add(nouveau);
menuFichier.addSeparator();

JMenuItem aPropos = new JMenuItem("A propos");
9
Exemple 3 (suite) : MenuEditeurP.java
JMenu divers = new JMenu("Divers");
JMenu sousMenu1 = new JMenu("Sous menu 1"); // prêt à recevoir des sous menus
divers.add(sousMenu1);
JMenu sousMenu2 = new JMenu("Sous menu 2"); // prêt à recevoir des sous menus
divers.add(sousMenu2);
JMenu sousMenu11 = new JMenu("Sous Menu 11"); // prêt à recevoir des sous menus
sousMenu1.add(sousMenu11);
JMenuItem cas11 = new JMenuItem("Cas 11");
sousMenu11.add(cas11);

divers.add(cas1);
divers.add(cas2);
add(menuFichier);
add(menuAide);
add(divers);
}
}

Exemple 3 (suite): MenusImbriques.java
public class MenusImbriques extends JFrame {
public MenusImbriques(){
setTitle("Imbrication de menus");
setSize(400,200);
setJMenuBar(new MenuEditeurP());
setVisible(true);
}

new MenusImbriques();
}
}
10
Imbrication des composants (1)
Exemple 4: ajout d'une barre d'outil à l'éditeur BarreOutils.java
import java.awt.*;
public class BarreOutils extends JPanel {
public BarreOutils(){
String[] etiquetteCouleurs = {"Bleu", "Rouge", "Jaune", "Vert"};
this.setBackground(Color.lightGray);
JComboBox listeCouleurs = new JComboBox(); // liste déroulante
for (int i=0; i<etiquetteCouleurs.length; i++)
listeCouleurs.addItem(etiquetteCouleurs[i]);
// l'ajout de la barre d'outils
this.add(listeCouleurs);
this.add(new JButton("Sauvegarder"));
this.add(new JButton("Tout effacer"));
this.add(new JButton("Quitter"));
}
}
Imbrication des composants (2)

FenetreAvecBarreOutils.java
import java.awt.*;
public class FenetreAvecBarreOutils extends JFrame {
public FenetreAvecBarreOutils(){
setTitle("Fenêtre avec barre d'outils");
setSize(400,300);
setJMenuBar(new MenuEditeur());
add(new BarreOutils());
setVisible(true);
}
new FenetreAvecBarreOutils();
}
}
Remarque: nous pouvons utiliser le gestionnaire de placement BorderLayout et positionner

la barre d'outils au nord.
11
Les raccourcis clavier (1)
Les éléments de menus peuvent être associés à 2 types de raccourcis claviers:
Les mnémoniques : ils apparaissent sous la forme d'une lettre soulignée,
ils sont utilisables en combinaison avec la touche Alt.
Les mnémoniques concernent les menus et les éléments de menus
JMenuItem mi = new JMenuItem();
mi.setMnemonic(KeyEvent.VK_I); // affectation du raccourci alt+I
ou JMenuItem mi = new JMenuItem("Item",'I'); // valable uniquement pour un item
Les accélérateurs : sont des touches (peuvent être des touches de

fonction) ou des combinaisons de touches avec les touches Shift, Ctrl ou
Alt qui sont affichés à la droite de l'étiquette de l'élément du menu.
mi.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z,
InputEvent.CTRL_MASK)); // affectation de l'accélérateur ctrl+z
Remarque : Lire VK, value of key ou virtual key


o Un mnémonique est un caractère alphanumérique unique souligné dans un
nom de menu ou d'un élément de menu.
On agit sur un menu de caractère mnémonique C en frappant la
combinaison Alt et C.
Si le menu est affiché, on agit sur un élément de menu de caractère
mnémonique C en frappant uniquement ce caractère.
Pour associer un caractère mnémonique à un menu ou à un élément de
menu, on utilise la méthode setMnemonic de la classe
AbstractButton comme suit :
JMenu unMenu = new JMenu("Menu1");
unMenu.setMnemonic('M'); // M est le caractère mnémonique du menu unMenu.
ou unMenu.setMnemonic(KeyEvent.VK_M); // affectation du raccourci alt+M
JMenuItem item1 = new JMenuItem("Item1");
item1.setMnemonic('I'); // I est le caractère mnémonique de l'élément item1
Une autre forme possible valable uniquement pour un item et non un
menu: Jmenu item1 = new JMenuIem("Item1",'I')
12
o Un accélérateur est une combinaison de touches qu'on associe à un
élément de menu (pas à un menu) et qui s'affiche à droite de son nom.
• Même si le menu n'est pas affiché, l'appui sur la combinaison des
touches de l'accélérateur provoque la sélection de l'élément
correspondant.
• Pour associer un accélérateur à un élément de menu, on utilise la
méthode setAccelerator de la classe JMenuItem, à laquelle on
fournit, en argument, la combinaison de touches voulue.
Pour cela, on utilise la méthode getKeyStroke de la classe
KeyStroke (touche du clavier) comme suit:
KeyStroke.getKeyStroke(KeyEvent.VK_I, // touche I
InputEvent.CTRL_MASK); // + touche CTRL
ou KeyStroke.getKeyStroke('I') // touche I, cette forme respecte la casse
Association de la combinaison CTRL+I à un élément item1 :
JMenuItem item1 = new JMenuItem("Item1");
item1.setAcclerator(KeyStroke.getKeyStroke(KeyEvent.VK_I,
InputEvent.CTRL_MASK));

Exemple 5 : menu avec mnémoniques et accélérateurs,
public class MenuAvecRaccourcis extends JFrame implements ActionListener {
JMenu couleur;
JMenuItem rouge, vert;
public MenuAvecRaccourcis() {
setTitle("Un menu avec raccourcis");
setSize(350, 100);
JMenuBar barreMenus = new JMenuBar(); // création de la barre de menus
setJMenuBar(barreMenus);
// création des menus et éléments de menus
couleur = new JMenu("Couleur"); couleur.setMnemonic('C');
barreMenus.add(couleur);
rouge = new JMenuItem("Rouge"); rouge.setMnemonic('R');

rouge.setAccelerator(
KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.CTRL_MASK));
couleur.add(rouge);
rouge.addActionListener(this);
vert = new JMenuItem("Vert"); vert.setMnemonic('V');
vert.setAccelerator(KeyStroke.getKeyStroke(
KeyEvent.VK_V, InputEvent.CTRL_MASK));
couleur.add(vert);
vert.addActionListener(this);
}
13
Exemple 5 (suite) : menu avec mnémoniques et accélérateurs,

System.out.println("Action avec chaine de commande = " +
ev.getActionCommand());
if(ev.getSource()==rouge) System.out.println("Action option rouge");
if(ev.getSource()==vert) System.out.println("Action option vert");
}

MenuAvecRaccourcis mr = new MenuAvecRaccourcis();
mr.setDefaultCloseOperation(3);
mr.setVisible(true);
}
}
Nous pouvons associer plus d'une touche de commande à un accélérateur:
Exemple: le cas de Ctrl + Maj + R

JMenItem item = new JMenuItem("Rouge");
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,
KeyEvent.CTRL_MASK + KeyEvent.SHIFT_MASK));
Remarque: On peut utiliser pour les touches de commande les 2 formes suivantes,
KeyEvent.CTRL_MASK ou InputEvent.CTRL_MASK
14
Exemple 5bis : accélérateur avec 2 touches de commande,
public class MenuAvecRaccourcis2 extends JFrame implements ActionListener {
JMenuItem rouge;
public MenuAvecRaccourcis2() {
setTitle("Un menu avec raccourcis");
setSize(350, 100);
JMenuBar barreMenus = new JMenuBar();
setJMenuBar(barreMenus);
JMenu couleur = new JMenu("Couleur"); couleur.setMnemonic('C');
barreMenus.add(couleur);
rouge.setAccelerator(
KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.CTRL_MASK +
InputEvent.SHIFT_MASK )); // Ctrl + Maj + R
couleur.add(rouge);
rouge.addActionListener(this);
}
}
MenuAvecRaccourcis2 mr = new MenuAvecRaccourcis2();
mr.setDefaultCloseOperation(3); mr.setVisible(true);
}
}
Ajout d'une icone (1)

Ajout d'une icône à un élément JItem de menu:
Les éléments d'un menu héritent comme les boutons de
JAbstractButton, ils peuvent contenir une étiquette, une image ou les 2.
Nous pouvons spécifier une icône à l'aide des constructeurs suivant:
JMenuItem(String etiquette); // étiquette sans icone
JMenuItem(Icone icone); // icone sans étiquette
JMenuItem(String etiquette, Icon icone); // icone et étiquette
après la création, à l'aide de la méthode setIcon();

15
Ajout d'une icone (2)
Exemple 6 : Ajout d'icônes,
class MenuAvecIcones extends JFrame{
public MenuAvecIcones() {
setTitle ("Editeur avec icônes"); setSize (300, 150); setVisible(true);
JMenuBar barreMenus = new JMenuBar() ; /* création barre des menus */
setJMenuBar(barreMenus) ;
JMenu edition = new JMenu ("Edition") ;
barreMenus.add(edition) ;
/* création, ajout des items et lien avec écouteurs */
edition.add(new JMenuItem("Copier", new
ImageIcon("copier.gif"))).addActionListener (new ActionListener(){
edition.copy();
}
});
edition.add(new JMenuItem("Couper", new
ImageIcon("coller.gif"))).addActionListener (new ActionListener(){
edition.paste();
}
});
}
public static void main (String args[]) {
MenuAvecIcones f = new MenuAvecIcones();
f.setVisible(true);
}
}
Construction d'un menu avec écouteurs (1)

Nous pouvons associer des écouteurs à un menu ou ses éléments:
Exemple 7 :
class MenuAvecEcouteurs extends JFrame implements ActionListener, ItemListener {
public MenuAvecEcouteurs() {
setTitle ("Editeur avec ecouteurs") ;
setSize (300, 150) ;
barreMenus = new JMenuBar() ; /* création barre des menus */
setJMenuBar(barreMenus) ; /* création menu Couleur et son groupe de 2 boutons radio :
Rouge et Vert */
couleur = new JMenu ("Couleur") ;
barreMenus.add(couleur) ;
rouge = new JRadioButtonMenuItem ("Rouge") ;
couleur.add(rouge) ;
rouge.addActionListener (this) ;
rouge.addItemListener (this) ;
vert = new JRadioButtonMenuItem ("Vert") ;
couleur.add(vert) ;
vert.addActionListener (this) ;
vert.addItemListener (this) ;
ButtonGroup groupe = new ButtonGroup() ;
groupe.add(rouge) ;
groupe.add(vert) ;
16
Exemple 7 (suite) :
/* création du menu Formes et ses cases a cocher Rectangle et Ovale */
formes = new JMenu ("Formes") ;
barreMenus.add(formes) ;
rectangle = new JCheckBoxMenuItem ("Rectangle") ;
formes.add(rectangle) ;
rectangle.addActionListener (this) ;
rectangle.addItemListener (this) ;
ovale = new JCheckBoxMenuItem ("Ovale") ;
formes.add(ovale) ;
ovale.addActionListener (this) ;
ovale.addItemListener (this) ;
}
public void actionPerformed (ActionEvent ev ) { // boutons radios
Object source = ev.getSource() ;
if (source == rouge) System.out.println ("** Action option rouge") ;
if (source == vert) System.out.println ("** Action option vert") ;
if (source == rectangle) System.out.println ("** Action option rectangle") ;
if (source == ovale) System.out.println ("** Action option ovale") ;
}

public void itemStateChanged (ItemEvent ev) {
Object source = ev.getSource() ; // à vérifier directement avec if(rouge==ev.getSource())
if(source == rouge) System.out.println ("** Item option rouge") ;
if(source == vert) System.out.println ("** Item option vert") ;
if(source == rectangle) System.out.println ("** Item option rectangle") ;
if(source == ovale) System.out.println ("** Item option ovale") ;
System.out.print ("Option selectionnée : ") ;
if(rouge.isSelected()) System.out.print(" rouge");
if(vert.isSelected()) System.out.print(" vert");
if(rectangle.isSelected()) System.out.print(" rectangle");
if(ovale.isSelected()) System.out.print (" ovale");
System.out.println() ;
}
private JMenuBar barreMenus ;
private JMenu couleur, formes ;
private JRadioButtonMenuItem rouge, vert;
private JCheckBoxMenuItem rectangle, ovale;

MenuAvecEcouteurs f = new MenuAvecEcouteurs();
f.setVisible(true);
}
}
17
Remarques:
Les menus (JMenu) génèrent des événements de type MenuEvent lors de leur
affichage ou de leur disparition.
L'écouteur associé est ajouté par addMenuListener().
L'interface d'écoute à implémenter MenuListener est contenu dans le paquetage
javax.swing.event contient 3 méthodes (pas d'adaptateurs !):
menuSelected()
menuDeselected()
menuCanceled()
peu utilisé généralement.
Forme condensée de construction d'un menu (1)

La méthode add() de JMenu, permet de créer automatiquement un
élément de menu JMenuItem.
Exemple: rajouter l'élément Ouvrir au menu Fichier
au lieu de:
JMenu fichier = new JMenu("Fichier");
JMenuItem ouvrir = new JMenuItem("Ouvrir"); // création
fichier.add(ouvrir); // ajout
nous avons:
fichier.add("Ouvrir"); // création et ajout
pour lui associer un écouteur:
JMenuItem ouvrir = fichier.add("Ouvrir");
ouvrir.addActionListener(écouteur); // ajout d'un écouteur
Nous pouvons même faire 3 traitement en une seule ligne:
// création, ajout et lier un écouteur
fichier.add("Ouvrir").addActionListener(ecouteur);
18
Forme condensée de construction d'un menu (2)
Exemple 8 : Ecriture condensée, création, ajout d'un item et d'un écouteur
class MenuAvecEcouteurs2 extends JFrame{
public MenuAvecEcouteurs2() {
setTitle ("Editeur avec ecouteurs"); setSize (300, 150); setVisible(true);
JMenuBar barreMenus = new JMenuBar() ; /* création barre des menus */
setJMenuBar(barreMenus) ;
JMenu fichier = new JMenu ("Fichier") ;
barreMenus.add(fichier) ;
/* création, ajout des items et lien avec écouteurs */
fichier.add("Ouvrir").addActionListener (new ActionListener(){
System.out.println("** Iem Ouvrir **");
}
});
fichier.add("Quitter").addActionListener (new ActionListener(){
System.out.println("** Iem Quitter **");
}
});
}
MenuAvecEcouteurs2 f = new MenuAvecEcouteurs2();
f.setVisible(true);
}
} Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 37
Construction d'un menu surgissant (1)

Un menu surgissant de type JPopupMenu est un menu, sans nom, non
rattaché à une barre de menu dont la liste d'éléments apparaît suite à un clic
sur le bouton droit de la souris.
On crée un objet de type JPopupMenu, auquel on ajoute des objets de

type JMenuItem de la même manière que l'ajout à un objet de type
JMenu.
Exemple :
JPopupMenu menuS = new JPopupMenu(); // création d'un objet menu surgissant
JMenuItem haut = new JMenuItem("Haut"); // création d'un élément Haut
menuS.add(haut); // ajout au menu surgissant
JMenuItem bas = new JMenuItem("Bas"); // création d'un élément Bas
menuS.add(bas); // ajout au menu surgissant
19
Remarques :
On peut utiliser des cases à cocher ou des boutons radio comme éléments d'un menu
surgissant,
Contrairement à un menu usuel qui est affiché en permanence, un menu surgissant doit
être affiché explicitement par le programme en utilisant la méthode show de la classe
JPopupMenu, avec comme arguments, le composant parent et les coordonnées de la
position du menu.
Exemple : menuS.show(ev.getComponent(), ev.getX(), ev.getY());
Le menu reste affiché jusqu'à ce que l'utilisateur sélectionne un élément ou en cliquant à
côté.
La classe MouseEvent dispose d'une méthode isPopupTrigger qui fournit la
valeur true si le bouton droit de la souris est concerné. Cette méthode est utilisable
dans mouReleased
Exemple :
public void mouseReleased(MouseEvent ev) {
if(ev.isPopupTrigger())
menuS.show(ev.getComponent(), ev.getX(), ev.getY());
}

Exemple 9: Un menu surgissant simple
public class MenuSurgissant1 extends JFrame {
public MenuSurgissant1(){
setTitle("Menu Surgissant");
setDefaultCloseOperation(3); setSize(300,150); setVisible(true);
// création du menu surgissant niveau et ses options haut et bas
JPopupMenu menuS = new JPopupMenu();
JMenuItem haut = new JMenuItem("Haut");
menuS.add(haut);
JMenuItem bas = new JMenuItem("Bas");
menuS.add(bas);
// asociation de l'écouteur MouseListener pour réagir au bouton droit
addMouseListener(new MouseAdapter() {
if(ev.isPopupTrigger()
menuS.show(ev.getComponent(),ev.getX(),ev.getY());
System.out.println("Position x= "+ev.getX()+" y= "+ev.getY());
}
});
}
new MenuSurgissant1();
}
} Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 40
20
Exemple 10: Ajout de raccourcis
public class MenuSurgissant2 extends JFrame {
public MenuSurgissant2() {
setTitle("Menu Surgissant"); setDefaultCloseOperation(3);
setSize(300,150); setVisible(true);
// créatiion du menu surgissant couleur et ses options rouge et vert
JPopupMenu couleur = new JPopupMenu();
JMenuItem rouge = new JMenuItem("Rouge"); rouge.setMnemonic('R'); // Alt+r
rouge.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,InputEvent.CTRL_MASK));
couleur.add(rouge);
JMenuItem vert = new JMenuItem("Vert"); vert.setMnemonic('V'); // Alt+v
vert.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V,
KeyEvent.CTRL_MASK + KeyEvent.SHIFT_MASK)); // Ctrl+Maj+v
couleur.add(vert);
if (ev.isPopupTrigger())
couleur.show(ev.getComponent(),ev.getX(),ev.getY());
System.out.println("Position x= "+ev.getX()+" y= "+ev.getY());
}
});
}
}
}

Exemple 11: Ajout d'écouteurs d'événements
public class MenuSurgissant3 extends JFrame implements ActionListener {
JPopupMenu couleur;
JMenuItem rouge, vert;
public MenuSurgissant3() {
setTitle("Menu Surgissant");
setSize(300,150);
setVisible(true);
couleur = new JPopupMenu(); // création du menu surgissant couleur et ses options rouge et vert
rouge.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,InputEvent.CTRL_MASK));
couleur.add(rouge);
rouge.addActionListener(this); // ajout d'écouteurs
vert = new JMenuItem("Vert"); vert.setMnemonic('V');
vert.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V,
KeyEvent.CTRL_MASK + KeyEvent.SHIFT_MASK)); // Ctrl+Maj+v
couleur.add(vert);
vert.addActionListener(this); // ajout d'écouteurs
if (ev.isPopupTrigger())
couleur.show(ev.getComponent(),ev.getX(),ev.getY());
}
});
}
21
Exemple 11: Ajout d'écouteurs d'événements

System.out.println("Action avec chaine de commande = "
+ ev.getActionCommand());
if(ev.getSource()==vert) System.out.println("Action option vert");
}

}
}
22

IHM7

Transféré par

Droits d'auteur :

Formats disponibles

IHM7

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

IHM7

Transféré par

Droits d'auteur :

Formats disponibles

Interfaces Homme - Machine

Les menus déroulants (Drop-Down Menu) : les éléments,

Les menu contextuels, surgissants (Popup Menu) : les éléments sont

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 3

Les menus (2)

L'affichage d'un menu contextuel est effectué par invocation de la méthode

Caractéristiques : Les éléments (options, items) de menu peuvent :

Toutes ces classes héritent de la classe JComponent.

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 5

Hiérarchie des composants pour les menus

JMenuBar JPopupMenu JAbsractButton JSeparator

JMenu JCheckboxMenuItem JRadioButtonMenuItem

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 6

Pour associer la barre de menu à une fenêtre, on utilise la méthode

Remarque: Comme la classe JMenuBar hérite de la classe JComponent, il

Les composants d'un Menu (2)

Un menu peut être ajouté à un autre menu : on parle alors de sous-menus.

Pour ajouter des items dans un menu ou un sous menu:

Pour insérer une séparation dans la liste des items

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 8

3.1- La classe JMenuItem

JMenuItem mi = new JMenuItem(); // création

mi.setText("le texte"); // affectation du texte

mi.setIcon(new ImageIcon(getImage("./image.png"))); // affectation d'une image

mi.setEnabled(true); // l'item de menu est actif

menu.add(mi); // ajout de l'item à un menu

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 9

Les composants d'un Menu (4)

3.3- La classe JCheckButtonMenuItem

item = new JMenuItem("un autre item surgissant"); // 2 ème élément

popup.addSeparator(); // 3 ème élément, un séparateur

item = new JMenuItem(); // 4 ème élément avec écouteur

Création d'un menu (1)

JMenuBar: représente la barre de menu d'une fenêtre,

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 12

Création d'un menu (3)

public static void main(String[] args) {

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 14

Positionnement de menus (1)

menuFichier.add(nouveau); // ajout au menu des éléments de menu

public static void main(String[] args) {

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 17

Imbrication de menus (1)

JMenu menuAide = new JMenu("Aide");

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 18

JMenuItem cas1 = new JMenuItem("Cas 1");

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 19

Imbrication de menus (3)

public static void main(String[] args) {

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 20

Prof M.D. RAHMANI Interface Homme-Machine SMI - S6 Année 2018-2019 21

Imbrication des composants (2)

Remarque: nous pouvons utiliser le gestionnaire de placement BorderLayout et positionner

Les accélérateurs : sont des touches (peuvent être des touches de

Remarque : Lire VK, value of key ou virtual key

Les raccourcis clavier (2)

Les raccourcis clavier (4)

rouge = new JMenuItem("Rouge"); rouge.setMnemonic('R');

public void actionPerformed(ActionEvent ev) {

public static void main(String[] args) {