Discussion :

[nadong94]

Bonjour à tous,

Pour faire cours j'ai plusieurs onglets, un menu commun et des actionListener.
Le but est : quand je clique sur l'un des onglets il appel l'action qui va bien.
Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public void stateChanged(ChangeEvent e) 
{
	if (Ihm.onglets.getSelectedComponent().equals(Ihm.ongletLivre)) {
		menu.getItmAjouter().addActionListener(new EcouteurLivre(this));
	} else if (Ihm.onglets.getSelectedComponent().equals(Ihm.ongletAuteur)) {
		menu.getItmAjouter().addActionListener(new EcouteurAuteur(this));
	} else if (Ihm.onglets.getSelectedComponent().equals(Ihm.ongletClient)) {
		menu.getItmAjouter().addActionListener(new EcouteurClient(this));
	} else if (Ihm.onglets.getSelectedComponent().equals(Ihm.ongletCommande)) {
		menu.getItmAjouter().addActionListener(new EcouteurCommande(this));
	} else if (Ihm.onglets.getSelectedComponent().equals(Ihm.ongletEditeur)) {
		menu.getItmAjouter().addActionListener(new EcouteurEditeur(this));
	} else if (Ihm.onglets.getSelectedComponent().equals(Ihm.ongletProfil)) {
		menu.getItmAjouter().addActionListener(new EcouteurProfil(this));
	}
}

Dès lors ou je clique sur un onglets il m'indique l'onglet en question en plus des précédents onglets cliqué, hors moi je ne veux que celui en cours

Merci pour votre aide

[joel.drigo]

Salut,

A chaque fois qu'on sélectionne un onglet, un nouvel ActionListener est ajouté, mais les précédents ne sont jamais retirés : donc normal qu'il s'actionne tous. Il faut conserver la référence de tes écouteurs, pour pouvoir enlever le dernier ajouter à chaque fois (ou dans itemAjouter, retirer le dernier ajouté avant de mettre le nouveau).

Tu peux résoudre ça de manière plus générique, par délégation.
Fait un ActionListener que tu affectes à ton menuItem "ajouter". Cette action écoutera la sélection d'onglet, et déterminera à quelle action déléguer lorsqu'elle sera invoquée.

Une classe en gros comme àa :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
private class ActionAjouter implements ActionListener {
 
	private ActionListener ajouterLivre;
	private ActionListener ajouterAuteur;
	private ActionListener ajouterClient;
	/*...*/
 
	private ActionListener delegateAction;
 
	public ActionAjouter(JTabbedPane tabbedPane) {
                setEnabled(false);
                ajouterLivre = new EcouteurLivre();
                ajouterAuteur = new EcouteurAuteur();
                ...etc...
		tabbedPane.addChangeListener(new ChangeListener() {
 
			@Override
			public void stateChanged(ChangeEvent e) {
				if ( tabbedPane.getSelectedComponent()==ihm.ongletLivre ) {
					delegateAction= ajouterLivre;
				}
				else if ( tabbedPane.getSelectedComponent()==ihm.ongletAuteur ) {
					delegateAction=ajouterAuteur;
				}
				... etc ...
                                setEnabled(delegateAction!=null);
			}
		});
	}
 
	@Override
	public void actionPerformed(ActionEvent e) {
		if ( delegateAction!=null) delegateAction.actionPerformed(e);
	}
 
}

Le problème qui vient compliquer un peut tout ça, c'est d'avoir à déterminer quel onglet est sélectionné, par comparaison, pour déterminer quelle est la bonne action de délégation.
Le plus simple et le mieux est de faire que tes composants pour chaque onglet soit capable de réaliser eux même l'action, ou au moins de la fournir.

Par exemple, si tu fais une interface :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public interface ItemAjoutable {
 
        ActionListener getActionAjouter();
 
}

Que tu l'implémentes sur tous tes onglets, de manière à ce que cette méthode retourne la bonne instance d'action, la classe ci-dessus devient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
private class ActionAjouter implements ActionListener { 
	/*...*/
 
	private ActionListener delegateAction;
 
	public ActionAjouter(JTabbedPane tabbedPane) {
                setEnabled(false); 
                ...etc...
		tabbedPane.addChangeListener(new ChangeListener() {
 
			@Override
			public void stateChanged(ChangeEvent e) {
                                Component selectedComponent = tabbedPane.getSelectionComponent();
                                if ( selectedComponent instanceof ItemAjoutable ) {
                                         delegateAction = ((ItemAjoutable)selectedComponent).getActionAjouter();
                                }
                                else {
                                         delegateAction = null;
                                }
                                setEnabled(delegateAction!=null);
			}
		});
	}
 
	@Override
	public void actionPerformed(ActionEvent e) {
		if ( delegateAction!=null) delegateAction.actionPerformed(e);
	}
 
}

[nadong94]

Parfait ! merci beaucoup, je vais le faire de façon qu'il prenne tous mes item du menu (ajouter, modifier, supprimer et autre).

[joel.drigo]

Tu as posé une question au sujet de setEnabled() mais tu l'as supprimée ensuite. Mais je te réponds quand même. La méthode n'existe pas dans ActionListener. Elle existe sur le composant sur lequel tu vas mettre l'ActionListener. Donc tu peux par exemple fournir le composant en paramètre de l'actionListener ce qui te permet d'appeler sa méthode. Mais il y a plus simple, plus souple et plus générique : au lieu d'un ActionListener, utilise une Action (javax.swing.Action). Cela a non seulement la même utilité qu'un ActionListener, mais ça porte également les informations "visuelles" (le nom de l'action, l'image, etc...) et ça a la méthode setEnabled().

Cela s'utilise encore plus simplement qu'un ActionListener. Dans le code que je t'ai déjà donné, tu remplaces implements ActionListener par extends javax.swing.AbstractAction.
Dans le constructeur, au début, tu fais super("Ajouter"); ("Ajouter c'est le texte du bouton, menu, etc.), ou super("Ajouter", uneimage) pour indiquer l'image (Regarde la JavaDoc de la classe pour voir tout ce que tu peux paramétrer sur une Action).

Ensuite, pour créer un bouton, il suffira de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new JButton(new ActionAjouter(tabbedPane))

tout simplement (et le bouton sera automatiquement rendu actif ou pas, en fonction de la sélection d'un onglet qui permet d'ajouter, ou pas)
idem pour un menu

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new JMenuItem(new ActionAjouter(tabbbedPane))

Tu peux même utiliser la même instance d'action pour les deux.

[nadong94]

D'accord,
1. donc je fait : tabbedPane.setEnabled(false); au lieu de : setEnabled(false);
2. super("Ajouter"); : cependant comment je fait pour modifier et supprimer car le super prend qu'un seul élément ?
3. code du item ajouter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
//ajouter
itmAjouter = new JMenuItem(new ActionCRUD(ihm,Ihm.getOnglets()));
itmAjouter.setAccelerator(KeyStroke.getKeyStroke('A', Toolkit.getDefaultToolkit().getMenuShortcutKeyMask(), false));
mnuGestion.add(itmAjouter);

[nadong94]

Petit problème de nullPointer pour le : Ihm.getOnglets() que je passe en paramètre.

Aurais-tu une idée ?

Pour le cheminement comme tu l'a sans doute compris je lance la classe ihm qui récupère le menu, les onglets...

[joel.drigo]

D'accord,
1. donc je fait : tabbedPane.setEnabled(false); au lieu de : setEnabled(false);

Non c'est le composant qui fait l'action qui est concerné : le bouton, ou le menu.

2. super("Ajouter"); : cependant comment je fait pour modifier et supprimer car le super prend qu'un seul élément ?

Il faut faire une Action différente pour chaque type d'action. C'est plus simple, plus propre. Il n'y a rien de commun entre les actions. Maintenant, tu peux faire une classe d'action générique abstraite,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
oublic abstract class ActionCRUD {
 
      protected ActionListener crudLivre;
 
       public ActionCRUD(JTAbbedPane pane, String nom/*...+ les autres paramètres*/) {
            super(nom);
            // ... etc ...
            initActions();
       }
 
       protected abstract void initActions();
 
}

Et ensuite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ActionAjouter {
 
    private ActionListener ajouterLivre = ...;
 
    public ActionAjouter(JTAbbedPane tab) {
         super(tab, "Ajouter");
    }
 
    protected void initActions() {
           crudLivre = ajouterLivre;
           ...
    }
 
}

Avec les interfaces ça peut être plus simple à gérer.
Tu fais une interface pour chaque type d'actions du CRUD : ItemAjoutable, ItemSupprimable, ... qui étendent une interface sans méthode ItemCRUD

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public interface ItemAjoutable {
 
     Action getAjoutAction();
 
}

Tes onglets implémentent ces interface

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
oublic abstract class ActionCRUD {
 
       public ActionCRUD(JTAbbedPane tabbedPane, String nom/*...+ les autres paramètres*/) {
            super(nom);
            tabbedPane.addChangeListener(new ChangeListener() {
 
			@Override
			public void stateChanged(ChangeEvent e) {
                                Component selectedComponent = tabbedPane.getSelectionComponent();
                                 delegateAction = getAction(selectionComponent);
                                setEnabled(delegateAction!=null);
			}
		});
 
       }
 
       protected abstract Action getAction(Component component);
 
}

Exemple pour ajout

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ActionAjouter extends ActionCRUD {
 
    private ActionListener ajouterLivre = ...;
 
    public ActionAjouter(JTAbbedPane tab) {
         super(tab, "Ajouter");
    }
 
    protected Action getAction(Component component) {
          if ( component instanceof ItemAjoutable ) {
              return ((ItemAjoutable)component).getAjoutAction();
         }
         return null;
    }
 
}

Pareil pour les autres actions du crud

3. code du item ajouter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
//ajouter
itmAjouter = new JMenuItem(new ActionCRUD(ihm,Ihm.getOnglets()));
itmAjouter.setAccelerator(KeyStroke.getKeyStroke('A', Toolkit.getDefaultToolkit().getMenuShortcutKeyMask(), false));
mnuGestion.add(itmAjouter);

Pourquoi me montrer çà ? tu as une question ?
Sinon, en plus de l'accelerator pour un menu, tu peux paramétrer directement le mnémonic (valable pour les boutons également) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

putValue(MNEMONIC_KEY, mnemonic);