← (précédent)D.12 Exercices corrigés (2)

F I N

Accueil S O M M A I R E

D.13 Evènements sur les menus

Lorsque vous ouvrez un fichier word, ou excel, etc... ou même un navigateur internet tel que IE ou mozilla, ou n'importe quelle fenêtre d'un logiciel de commerce, vous voyez forcément un menu dont les sous-menus, par exemple sur IE, sont : Fichier, Edition, Affichage, Favoris, Outils, Aide (?).

Pour chaque sous-menu, vous avez des options. Sur le sous-menu Fichier de IE, vous avez les options suivantes : Nouveau, Ouvrir, modifier, etc..

Lorsque vous cliquez sur une option, il se passe quelque chose tel que : ouverture d'un fichier, modification de la taille du texte, etc...

Pour mettre en place ces menus, sous-menus et options, on utilise 3 types d'objets : JMenuBar pour créer la barre de menus. JMenu pour créer les divers menus et JMenuItem pour créer les diverses options.

Chaque action sur une option peut être traité par la méthode actionPerformed() de l'interface ActionListener.
Allons-y pour les exemples.

 EXEMPLE 1 

1.     import javax.swing.*; import java.awt.event.*;
2.     import java.awt.*; import javax.swing.event.*;
3.     
4.     class Fenetre extends JFrame implements ActionListener
5.     {
6.          private JMenuBar barreDeMenus; private JMenu dimension, couleur;
7.          private JMenuItem rouge, vert, bleu, largeur, hauteur;
8.          int l = 400; int h = 200; Container c;
9.          
10.          public Fenetre()
11.         {
12.              setTitle("fenêtre avec menu");
13.              setSize(l, h);
14.              
15.              barreDeMenus = new JMenuBar();
16.              setJMenuBar(barreDeMenus);
17.              
18.              couleur = new JMenu("Couleurs");
19.              barreDeMenus.add(couleur);
20.              
21.              rouge = new JMenuItem("Rouge");
22.              couleur.add(rouge);
23.              rouge.addActionListener(this);
24.              
25.              vert = new JMenuItem("Vert");
26.              couleur.add(vert);
27.              vert.addActionListener(this);
28.               
29.              bleu = new JMenuItem("Bleu");
30.              couleur.add(bleu);
31.              bleu.addActionListener(this);
32.               
33.              dimension = new JMenu("Dimensions");
34.              barreDeMenus.add(dimension);
35.              
36.              largeur = new JMenuItem("Largeur");
37.              dimension.add(largeur);
38.              largeur.addActionListener(this);
39.              
40.              hauteur = new JMenuItem("Hauteur");
41.              dimension.add(hauteur);
42.              hauteur.addActionListener(this);
43.              
44.              c = getContentPane();
45.              setDefaultCloseOperation(3);
46.              
47.         }
48.          
49.         public void actionPerformed(ActionEvent a)
50.         {
51.              if(a.getSource() == rouge)
52.              {
53.                   c.setBackground(new Color(255, 0, 0) );
54.              }
55.              
56.              if(a.getSource() == vert)
57.              {
58.                   c.setBackground(new Color(0, 255, 0) );
59.              }
60.              
61.              if(a.getSource() == bleu)
62.              {
63.                   c.setBackground(new Color(0, 0, 255) );
64.              }
65.              
66.              if(a.getSource() == largeur)
67.              {
68.                   setSize(300, h);
69.              }
70.              
71.              if(a.getSource() == hauteur)
72.              {
73.                   setSize(l, 150);
74.              }
75.         }
76.    }
77.    
78.    public class FabricationMenus
79.    {
80.         public static void main(String [] args)
81.         {
82.              JFrame f = new Fenetre();
83.              f.setVisible(true);
84.         }
85.    }
Compilez puis exécutez ce programme, il sera affiché :

Une fenêtre avec une barre de menus contenant 2 menus : Couleurs et Dimensions.
Cliquez sur Couleurs et le menu se déroule, laissant apparaître 3 options : rouge, vert et bleu. Le clic sur chaque couleur donne à la fenêtre la couleur correspondante.
Cliquez sur le menu Dimensions et il se déroule, laissant apparaître 2 sous-menus: largeur et hauteur. Le clic sur l'un des sous menus change automatique la valeur de la dimension correspondante.


Explications :

Ligne 12 : titre de la fenêtre. Ligne 13 : attribution de la taille de la fenêtre avec des paramètres.

Ligne 15 : Création d'une barre de menus grâce à la classe JMenuBar. L'objet de type JMenuBar est un conteneur qui ne continent que des menus. Ce Ce conteneur est placé dans la fenêtre, non pas avec la méthode add() comme pour les autres composants, mais avec la méthode setJMenuBar(). Voir Ligne 16.

Ligne 18 : Création du menu Couleur. L'objet s'appelle Couleur et le nom qui doit apparaître sur cet objet est "Couleurs". Ligne 19 : ajout du menu Couleur dans la barre de menu.

Ligne 21 : création du sous-menu rouge. Ligne 22 : ajout du ce sous-menu dans le menu couleur. Ligne 23 : association de cet objet Couleur à un objet écouteur qui est ici, la fenêtre elle-même.

Lignes 25 à 27 : même chose pour le sous-menu vert que pour le rouge.

Lignes 29 à 31 : même chose pour le sous-menu bleu que pour le rouge.

Ligne 33 : création du menu Dimension et en ligne 34 : ajout de ce menu à la barre de menus.

Ligne 36 : création du sous-menu largeur. Ligne 37 : ajout du ce sous-menu dans le menu Dimension. Ligne 38 : association de cet objet largeur à un objet écouteur qui est ici, la fenêtre elle-même.

Lignes 40 à 42 : même chose pour la hauteur que pour la largeur.

Dans la méthode actionPerformed(), on décrit ce qui doit se passer quand on choisit l'un des 5 sous-menus : rouge, vert, bleu, largeur ou hateur.

Si c'est rouge, la fenêtre se colore en rouge. Plus précisément, le conteneur getContentPane().
Dans le cas où c'est vert, le conteneur se colore en vert.
Pareil pour le bleu.

Dans le cas où c'est la largeur, on a la largeur qui devient 300 pixels et la hauteur qui reste inchangée.
Dans le cas où c'est la hauteur, on a la hauteur qui devient 150 et la largeur reste inchangée.
 EXEMPLE 2 

1.     import javax.swing.*; import java.awt.event.*;
2.     import java.awt.*; import javax.swing.event.*;
3.     
4.     class Fenetre extends JFrame implements ActionListener
5.     {
6.          private JMenuBar barreDeMenus; private JMenu dimension, couleur;
7.          private JMenuItem rouge, vert, bleu, largeur, hauteur;
8.          int l = 400; int h = 200; Container c;
9.          
10.          public Fenetre()
11.         {
12.              setTitle("fenêtre avec menu et sous-menus en option");
13.              setSize(l, h);
14.              
15.              barreDeMenus = new JMenuBar();
16.              setJMenuBar(barreDeMenus);
17.              barreDeMenus.setBackground( new Color(255, 255, 0) );
18.             
19.              couleur = new JMenu("Couleurs");
20.              barreDeMenus.add(couleur);
21.              
22.              rouge = new JRadioButtonMenuItem("Rouge");
23.              couleur.add(rouge);
24.              rouge.addActionListener(this);
25.              
26.              vert = new JRadioButtonMenuItem("Vert");
27.              couleur.add(vert);
28.              vert.addActionListener(this);
29.              
30.              bleu = new JRadioButtonMenuItem("Bleu");
31.              couleur.add(bleu);
32.              bleu.addActionListener(this);
33.              
34.              ButtonGroup gr = new ButtonGroup();
35.              gr.add(rouge);
36.              gr.add(vert);
37.              gr.add(bleu);
38.              
39.              dimension = new JMenu("Dimensions");
40.              barreDeMenus.add(dimension);
41.              
42.              largeur = new JCheckBoxMenuItem("Largeur");
43.              dimension.add(largeur);
44.              largeur.addActionListener(this);
45.              
46.              hauteur = new JCheckBoxMenuItem("Hauteur");
47.              dimension.add(hauteur);
48.              hauteur.addActionListener(this);
49.              
50.              c = getContentPane();
51.              setDefaultCloseOperation(3);
52.              
53.         }
54.         
55.         public void actionPerformed(ActionEvent a)
56.         {
57.              if(a.getSource() == rouge)
58.              {
59.                   c.setBackground(new Color(255, 0, 0) );
60.              }
61.              
62.              if(a.getSource() == vert)
63.              {
64.                   c.setBackground(new Color(0, 255, 0) );
65.              }
66.              
67.              if(a.getSource() == bleu)
68.              {
69.                   c.setBackground(new Color(0, 0, 255) );
70.              }
71.              
72.              if(a.getSource() == largeur)
73.              {
74.                   setSize(300, h);
75.              }
76.              
77.              if(a.getSource() == hauteur)
78.              {
79.                   setSize(l, 150);
80.              }
81.         }
82.    }
83.    
84.    public class FabricationSousMenusOptionnels
85.    {
86.         public static void main(String [] args)
87.         {
88.              JFrame f = new Fenetre();
89.              f.setVisible(true);
90.         }
91.    }
Compilez puis exécutez ce programme, il sera affiché la même chose que dans l'exemple 1. A quelques expressions près.

Cette fois, les sous-menus Rouge, vert, Bleu sont précédés d'un bouton radio chacun. Et les sous-menus Largeur et hauteur sont précédés d'une case à cocher.


Ligne 17 : la barre de menus est colorée en jaune.

Lignes 22, 26 et 30 : Les variables rouge, vert et bleu sont maintenant des références à des objets de type JRadioButtonMenuItem au lieu de JMenuItem comme dans l'exemple 1. La classe JRadioButtonMenuItem permet alors de créer des sous-menus avec un bouton Radio.
Vous avez remarqué en ligne 7 : ces variables rouge, vert et bleu sont quand même déclarées de type JMEnuItem. C'est normal. Conséquence du polymorphisme. Comme en ligne 88 : f est de type JFrame mais contient une référence à un objet de type Fenetre. Fenetre est une sous classe de JFrame (voir ligne 4). La classe JRadioButtonMenuItem est une sous-classe de JMenuItem.
Si vous n'avez pas pigé, revoyez le chapitre consacré au polymorphisme.

Lignes 42 et 46 : les variables largeur et hauteur sont maintenant des références à des objets de type JCheckBoxMenuItem au lieu de JMenuItem comme dans l'exemple précédent. La classe JCheckBoxMenuItem permet alors de créer des sous-menus avec une case à cocher.
largeur et hauteur sont des variables de type JMenuItem (ligne 7). La classe JCheckBoxMenuItem est aussi une sous-classe de la classe JMenuItem.

Le contenu de la méthode actionPerformed() s'explique comme dans l'exemple précédent.

Vous savez déjà que l'action dur une case à cocher ou sur un bouton radio peut être traité par la méthode actionPerformed() de l'interface ActionListener. Mais aussi par la méthode itemStateChanged() de l'interface ItemListener. Ici, j'ai choisi ActionListener.

Sachez aussi que l'action sur les menus peut être traité par 3 méthodes :
menuSelected(), menuDeSelected() et menuCanceled() de l'interface MenuListener.
Mais en pratique, cette possibilité est très peu exploitée. On préfère dans la plupart des cas, la méthode actionPerformed() comme dans l'exemple 1.
Nous verrons quand même un cas de MenuListener dans le chapitre D.13 EXERCICES CORRIGES partie 3 : les évènements

Certains menus apparaissent après avoir cliqué le côté droit de la souris. C'est par exemple dans ce type de menu que vous choisissez de cliquer un sous-menu vous permettant de voir le code source d'une page web.
Ce genre de menu a un nom : menu surgissant

C'est ce que nous allons voir dans l'exemple suivant.
 EXEMPLE 3 
1.     import javax.swing.*; import java.awt.event.*;
2.     import java.awt.*; import javax.swing.event.*;
3.     
4.     class Fenetre extends JFrame implements ActionListener
5.     {
6.          private JPopupMenu couleur; private JMenuItem rouge, vert, bleu;
7.          Container c;
8.          public Fenetre()
9.          {
10.              setTitle("Menu surgissant");
11.              setSize(400, 200);
12.              
13.              couleur = new JPopupMenu();
14.              
15.              rouge = new JMenuItem("Rouge");
16.              couleur.add(rouge);
17.              rouge.addActionListener(this);
18.              
19.              vert = new JMenuItem("Vert");
20.              couleur.add(vert);
21.              vert.addActionListener(this);
22.              
23.              bleu = new JMenuItem("Bleu");
24.              couleur.add(bleu);
25.              bleu.addActionListener(this);
26.              
27.              addMouseListener(new EcouteurDeSouris(couleur) );
28.              c = getContentPane(); setDefaultCloseOperation(3);
29.         }
30.         
31.         public void actionPerformed(ActionEvent a)
32.         {
33.              if(a.getSource() == rouge)
34.              {
35.                   c.setBackground(new Color(255, 0, 0) );
36.              }
37.              
38.              if(a.getSource() == vert)
39.              {
40.                   c.setBackground(new Color(0, 255, 0) );
41.              }
42.              
43.              if(a.getSource() == bleu)
44.              {
45.                   c.setBackground(new Color(0, 0, 255) );
46.              }
47.             
48.        }
49.    }
49.       
50.    class EcouteurDeSouris extends MouseAdapter
51.    {
52.         private JPopupMenu couleur;
53.         
54.         public EcouteurDeSouris(JPopupMenu couleur)
55.         {
56.             this.couleur = couleur;
57.         }
58.          
59.         public void mouseReleased(MouseEvent e)
60.         {
61.             if(e.isPopupTrigger() )
62.             {
63.                  couleur.show(e.getComponent(), e.getX(), e.getY() );
64.             }
65.         }
66.    }
67.      
68.    public class FabricationMenusSurgissants
69.    {
70.         public static void main(String [] args)
71.         {
72.              JFrame f = new Fenetre();
73.              f.setVisible(true);
74.         }
75.    }
Compilez puis exécutez ce programme, il sera affiché :

Une fenêtre vide. Normal, rien n'y a été mis. Mais si vous cliquez le bouton droit de la souris, il apparaît un menu surgissant à l'endroit même où vous avez cliqué. Ce menu est composé de 3 noms : Rouge, Vert et Bleu.
Si vous cliquez sur l'un des noms, la fenêtre prend la couleur correspondant au nom.


Explications :

Le menu Couleur est ici surgissant. C'est pourquoi on le crée non pas avec la classe JMenu, mais avec la classe JPopupMenu.
Les objets rouge, vert et bleu sont des sous-menus. Ils sont créés comme dans les exemples précédents avec la classe JMenuItem.

En ligne 27 : on associe à la fenêtre, un objet écouteur parce qu'il faut traiter l'évènement consistant à cliquer le bouton droit de la souris pour faire apparaître le menu. Explications en détail plus bas.

Pour la méthode actionPerformed(), on y met les instructions correspondantes aux réactions après qu'on ait cliqué sur un sous-menu : rouge, vert ou bleu. Les lignes 17, 21 et 25 montrent d'ailleurs que les objets rouge, vert et bleu sont associés à un objet écouteur d'action (addActionListener)

Maintenant, parlons de la classe EcouteurDeSouris.

D'abord, elle dérive de MouseAdapter. Ainsi, on redéfinit la seule méthode qui nous interesse. (C'est un rappel)

Vous pourriez être étonnés de voir qu'on redéfinit la méthode mouseReleased() au lieu de redéfinir la méthode mouseClicked() puisque c'est le clic (droit) de la souris qui fera apparaître le menu surgissant. L'explication est la suivante :
La méthode isPopupTrigget() de la classe MouseEvent, utilisée en ligne 61, n'est utilisable que dans la méthode mouseReleased() et pas dans la méthode mouseClicked(). Ce qui n'est pas un problème puisque le clic correspond à un appui, suivi d'un relâchement. Donc, en cliquant, c'est au moment du relâchement de la souris que le menu surgissant apparaît. Ce qui est la situation normale d'apparition du menu surgissant.
La méthode isPopupTrigger(), parlons-en :
C'est une méthode de type booléenne qui renvoie true si le clic se fait du côté droit de la souris. Si on n'avait pas émis cette condition (ligne 61), le menu surgissant apparaîtrait après le clic droit comme après le clic gauche.
Vous pouvez d'ailleurs le vérifier. Supprimez les lignes 61 ( if(e.isPopupTrigger() ), 62 ({) et 64 (}) et vous verrez que le menu surgissant apparaitra aussi bien après le clic droit qu'après le clic gauche.

Donc, si le clic se passe du côte droit (ligne 61), alors on applique à l'objet couleur, la méthode show() (ligne 63).
La méthode show() de la classe JPopupMenu requiert 3 arguments :
le premier est la fenêtre ou doit apparaître le menu surgissant. Ici, la méthode getComponent() de la classe MouseEvent permet d'obtenir la fenêtre sur laquelle on clique pour faire apparaître le menu.
Le deuxième et le troisième argument sont l'abscisse et l'ordonnée du point où doit apparaître le coin supérieur gauche du menu. e.getX() et e.getY() renvoient les coordonnées de l'endroit où on clique. Nous avons déjà vu les méthode getX() et getY() de la classe MousEvent dans le chapitre D.2 Les bases de la programmation graphique : partie 2 en exemple numéro 5.

Parlons maintenant du constructeur de la classe EcouteurDeSouris (ligne 50).

On a besoin de créer ce constructeur qui requiert un argument de type JPopMenu parce que en ligne 63, on manipule l'objet couleur de type JPopMenu. Or l'objet couleur de la classe Fenetre est déclarée en private (encapsulation). On ne peut donc pas le manipuler dans une autre classe. La seule façon d'y arriver, c'est justement d'en créer un autre dans la classe EcouteurDeSouris. En associant donc l'objet écouteur à la fenêtre (ligne 27), on passe en paramètre, le véritable objet couleur de la classe Fenetre.
 EXEMPLE 4 

1.     import javax.swing.*; import java.awt.event.*;
2.     import java.awt.*; import javax.swing.event.*;
3.     
4.     class Fenetre extends JFrame implements ActionListener
5.     {
6.          private JMenu couleur, dimension; private JMenuItem rouge, vert, bleu, largeur, hauteur;
7.          JMenuBar barreDeMenus; Container c; int l = 400; int h = 200; 
8.          
9.          public Fenetre()
10.         {
11.              setTitle("Menu particulier");
12.              setSize(400, 200);
13.              
14.              barreDeMenus = new JMenuBar(); 
15.              setJMenuBar(barreDeMenus);
16.              
17.              couleur = new JMenu("Couleurs");
18.              couleur.setMnemonic('C');
19.              barreDeMenus.add(couleur);
20.              
21.              rouge = new JMenuItem("Rouge");
22.              rouge.setMnemonic('R'); rouge.setToolTipText("fond rouge");
23.              rouge.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.CTRL_MASK) );
24.              couleur.add(rouge);
25.              rouge.addActionListener(this);
26.              
27.              vert = new JMenuItem("Vert");
28.              vert.setMnemonic('V'); vert.setToolTipText("fond vert");
29.              vert.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_MASK) );
30.              couleur.add(vert);
31.              vert.addActionListener(this);
32.              
33.              bleu = new JMenuItem("Bert");
34.              bleu.setMnemonic('B'); bleu.setToolTipText("fond bleu");
35.              bleu.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_B, InputEvent.CTRL_MASK) );
36.              couleur.add(bleu);
37.              bleu.addActionListener(this);
38.              
39.              dimension = new JMenu("Dimensions");
40.              dimension.setMnemonic('D');
41.              barreDeMenus.add(dimension);
42.              
43.              largeur = new JMenuItem("Largeur");
44.              largeur.setMnemonic('L'); largeur.setToolTipText("modifier largeur");
45.              largeur.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_L, InputEvent.CTRL_MASK) );
46.              dimension.add(largeur);
47.              largeur.addActionListener(this);
48.              
49.              hauteur = new JMenuItem("Hauteur");
50.              hauteur.setMnemonic('H'); hauteur.setToolTipText("modifier hauteur");
51.              hauteur.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_H, InputEvent.CTRL_MASK) );
52.              dimension.add(hauteur);
53.              hauteur.addActionListener(this);
54.              
55.              c = getContentPane();
56.              setDefaultCloseOperation(3);
57.              
58.         }
59.         
60.         public void actionPerformed(ActionEvent a)
61.         {
62.              if(a.getSource() == rouge)
63.              {
64.                   c.setBackground(new Color(255, 0, 0) );
65.              }
66.              
67.              if(a.getSource() == vert)
68.              {
69.                   c.setBackground(new Color(0, 255, 0) );
70.              }
71.              
72.              if(a.getSource() == bleu)
73.              {
74.                   c.setBackground(new Color(0, 0, 255) );
75.              }
76.                           
77.              if(a.getSource() == largeur)
78.              {
79.                   setSize(300, h);
80.              }
81.              
82.              if(a.getSource() == hauteur)
83.              {
84.                   setSize(l, 150);
85.              }
86.         }
87.         
88.    }
89.    
90.    public class FabricationMenuParticuliers
91.    {
92.         public static void main(String [] args)
93.         {
94.              JFrame f = new Fenetre();
95.              f.setVisible(true);
96.         }
97.    }
Compilez puis exécutez ce programme, il sera affiché :

Une fenêtre avec une barre de menus contenant 2 menus : Couleurs et Dimensions.
Cliquez sur Couleurs et le menu se déroule, laissant apparaître 3 options : rouge, vert et bleu. Le clic sur chaque couleur donne à la fenêtre la couleur correspondante.
Cliquez sur le menu Dimensions et il se déroule, laissant apparaître 2 sous-menus: largeur et hauteur. Le clic sur l'un des sous menus change automatique la valeur de la dimension correspondante.


Vous avez sans doute remarqué quelque chose :

Les menus Couleurs et Dimensions ont leur première lettre soulignée.

Les sous-menus rouge, vert bleu, largeur et hauteur ont aussi leur première lettre soulignée. De plus, les sous-menus sont suivis de ctrl + première lettre du sous-menu

Lorsque les sous-menus sont visibles, vous pouvez modifier la couleur en appuyant successivement sur la touche ctrl de votre clavier et la première lettre su sous-menu. De la même façon, vous pouvez modifier la dimension de la fenêtre.

Autre chose :

Lorsque les sous-menus sont visibles, si vous approchez la souris sur l'un d'eux, un texte apparaît sous la souris.


Explications :

Lignes 18, 22, 28, 34, 40, 44 et 50 : on applique la méthode setMnemonic() à un objet JMenu ou un objet JMenuItem pour souligner l'une des lettres du nom attribué à cet objet.
Pour un objet de type JMenu, on appuie sur la touche alt du clavier puis sur la lettre en question et la liste des options du menu devient visible.
Pour un objet de type JMenuItem(sous-menu), lorsqu'on clique sur la lettre soulignée, il se produit la même réaction que si l'on avait sélectionné l'option avec la souris.
C'est donc un raccourci clavier. La méthode setMnemonic() requiert un argument de type char qui est le caractère à souligner.

Lignes 22, 28, 34, 44 et 50 : on applique la méthode setToolTipTex() à un objet de type JMenuItem (option du menu) pour afficher un texte explicatif de ce qu'est l'option lorsqu'on approche la souris près de cette option.
La méthode setToolTipTex() requiert un argument de type String qui est le texte explicatif

Lignes 22, 28, 34, 44 et 50 : on applique à un objet de type JMenuItem, la méthode setAccelerator() pour indiquer un autre type de raccourci clavier. Pour ce type de raccourci, on appui successivement sur la touche CTRL et sur une autre touche représentant un caractère.
La méthode setAccelerator() fait appel dans ses parenthèses à une autre méthode : la méthode static getKeyStroke() de la classe KeyStroke. Cette méthode ( getKeyStroke() ) requiert 2 arguments : Le premier re^résente la touche contenant le caractère souligné du sous-menu et le deuxième représente la touche CTRL.
La touche contenant un caractère s'obtient grâce à la classe KeyEvent dont l'un des champ (constant) est par exemple VK_A pour la touche a, VK_B pour la touche b, VK_C pour la touche c, ainsi de suite.
Une touche représentant quelque chose qui n'est pas un caractère, par exemple, touche majuscule, touche ctrl, touche alt, s'obtient grâce à la classe InputEvent dont l'un des champs constants est par exemple CTRL_MASK pour la touche ctrl ou SHIFT_MASK pour la touche majuscule, ou ALT_MASK pour la touche alt, etc...

Cet exemple vous montre à quel point il est indispensable de connaître les classes prédéfinies.
 EXEMPLE 5 

1.     import javax.swing.*; import java.awt.event.*;
2.     import java.awt.*; import javax.swing.event.*;
3.     
4.     class Fenetre extends JFrame implements ActionListener
5.     {
6.          private JMenu couleur, rouge, vert; private JMenuItem rougeVif, rougePale, vertVif, vertPale;
7.          JMenuBar barreDeMenus; Container c; int l = 400; int h = 200; 
8.          
9.          public Fenetre()
10.         {
11.              setTitle("Menu particulier");
12.              setSize(400, 200);
13.              
14.              barreDeMenus = new JMenuBar(); 
15.              setJMenuBar(barreDeMenus);
16.              
17.              couleur = new JMenu("Couleurs");
18.              barreDeMenus.add(couleur);
19.              
20.              rouge = new JMenu("Rouge");
21.              couleur.add(rouge);
22.              
23.              rougeVif = new JMenuItem("RougeVif");
24.              rouge.add(rougeVif);
25.              rougeVif.addActionListener(this);
26.             
27.              rougePale = new JMenuItem("RougePale");
28.              rouge.add(rougePale);
29.              rougePale.addActionListener(this);
30.              
31.              vert = new JMenu("Vert");
32.              couleur.add(vert);
33.              
34.              vertVif = new JMenuItem("VertVif");
35.              vert.add(vertVif);
36.              vertVif.addActionListener(this);
37.              
38.              vertPale = new JMenuItem("VertPale");
39.              vert.add(vertPale);
40.              vertPale.addActionListener(this);
41.              
42.              c = getContentPane();
43.              setDefaultCloseOperation(3);
44.              
45.         }
46.         
47.         public void actionPerformed(ActionEvent a)
48.         {
49.              if(a.getSource() == rougeVif)
50.              {
51.                   c.setBackground(new Color(255, 0, 0) );
52.              }
53.              
54.              if(a.getSource() == rougePale)
55.              {
56.                   c.setBackground(new Color(255, 208, 208) );
57.              }
58.              
59.              if(a.getSource() == vertVif)
60.              {
61.                   c.setBackground(new Color(0, 255, 0) );
62.              }
63.              
64.              if(a.getSource() == vertPale)
65.              {
66.                   c.setBackground(new Color(208, 255, 208) );
67.              }
68.         }
69.           
70.    }
71.        
72.    public class FabricationMenuComposes
73.    {
74.         public static void main(String [] args)
75.         {
76.              JFrame f = new Fenetre();
77.              f.setVisible(true);
78.         }
79.    }


Compilez puis exécutez ce programme, il sera affiché :

Une fenêtre contenant un menu : Couleurs. Puis en cliquant sur ce menu, on voit 2 options : vert et rouge. Chacune des options est suivie d'une flèche. En pointnant la souris sur chacune des options, on voit apparaître des sous-options : RougeVif et RougePale sont les sous-options de l'option Rouge. VertVif et VertPale sont les sous-menus de Vert.
En cliquant sur l'une des sous-options, on obtient la couleur correspondante.

Explications :

On a affaire ici à un menu composé.

Ici, on a un seul menu : couleur dans la barre de menus. Les sous-menus rouge et Vert contiennent chacun des sous-menus. Pour cette raison, on crée les sous-menus rouge et vert non pas avec la classe JMenuItem, mais avec la classe JMenu(lignes 20 et 31). Car si on les crée avec JMenuItem, on ne pourra plus ajouter des options sur ces sous-menus.

Ce n'est plus aux options vert et rouge qu'on associe un objet écouteur. Mais aux sous-options RougeVif, RougePal, VertVif et VertPale : lignes 25, 29, 36 et 40.



Pour l'instant, c'est la fin. Mais d'ici à Janvier 2013, de nouveaux chapitres et de nouveaux exemples viendront s'ajouter.
La connaissance, c'est bien. La partager, c'est mieux
Conseiller ce site à un(e) ami(e):

Son e-mail est :       
Une suggestion à faire pour ce site ? ... Contact : webmaster@debutantprog.com
← (précédent)D.12 Exercices corrigés (2)

F I N

Accueil S O M M A I R E contact pour java : webmaster@debutantprog.com

D.13 Evènements sur les menus