Java Eclipse JTabbedPane stateChanged

Version imprimable

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:

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 :)

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:

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:

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:

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);
	}
 
}

29/01/2016, 09h17
nadong94

Parfait ! merci beaucoup, je vais le faire de façon qu'il prenne tous mes item du menu (ajouter, modifier, supprimer et autre).
29/01/2016, 10h47
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:

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:

new JMenuItem(new ActionAjouter(tabbbedPane))

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

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:

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);

29/01/2016, 11h59
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...

Citation:

Envoyé par nadong94

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.

Citation:

Envoyé par nadong94

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:

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:

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:

1 2 3 4 5 public interface ItemAjoutable { Action getAjoutAction(); }
Tes onglets implémentent ces interface
Code:

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:

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
Citation:
Envoyé par nadong94
3. code du item ajouter :
Code:

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:

putValue(MNEMONIC_KEY, mnemonic);

01/02/2016, 11h44
nadong94
Je vois l'idée je pense.

problème :
1. la classe abstract ActionCRUD : super(nom) demande un objet au lieu d'un string ou aucun argument (ce ne m'arrange pas je crois)
2. pour la classe ActionAjouter je suppose que ça concerne tous mes onglets donc :
Code:

1 2 ajouterLivre = new EcouteurLivre(ihm);
pour ajouter un livre si je me trouve dans l'onglet livre, idem pour le reste, mais comment fait-il la différence entre ajouterLivre et ajouterAuteur par exemple.

3. merci pour l'info du mnémonic sur le bouton

Citation:

Envoyé par nadong94

1. la classe abstract ActionCRUD : super(nom) demande un objet au lieu d'un string ou aucun argument (ce ne m'arrange pas je crois)

C'est juste que j'ai oublié l'extends :

Code:

public abstract class ActionCRUD extends AbstractAction

Chaque composant d'onglet implémente ItemAjout, ItemSupprimer, etc. Le composant d'affichage de livres retourne donc l'action pour ajouter un livre... D'aileurs, ce serait mieux de faire :
Code:

1 2 3 4 5 public interface ItemAjoutable { ActionListener getAjoutAction(); }
Puisque l'action est générique : elle a un libellé commun, une image unique, etc. On pourrait faire des Action pour la délégation : simplement, il faudrait faire remonter les paramètres de l'action de délégation dans l'action principale lors de la sélection.

La sélection de la bonne action en fonction de l'onglet sélectionné se faisant par (exécutée à chaque changement de sélection) :
Code:

1 2 3 4 5 6 protected ActionListener getAction(Component component) { if ( component instanceof ItemAjoutable ) { return ((ItemAjoutable)component).getAjoutAction(); } return null; }
ActionCrud est juste une coquille vide, qui a une représentation (nom, image...), et qui sélectionne la bonne action à qui déléguer, lorsqu'on sélectionne un onglet, en demandant au composant de cet onglet quelle est cette action de délégation. ActionAjouter est la version spécifique de ActionCrud qui sait sélectionner l'action de délégation pour ajouter, par la redéfinition de getAction(Component component). Il faudra bien sûr faire une ActionSupprimer,pour la suppression, etc.

J’espère avoir compris voici mes changement :
classe ActionCRUD code :

Code:

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
 
public abstract class ActionCRUD extends AbstractAction 
{
	private static final long serialVersionUID = 1L;
	private Ihm ihm;
    private ActionListener delegateAction;
 
	public ActionCRUD(JTabbedPane tabbedPane, String nom, Ihm ihm) 
	{
		super(nom);
 
		this.ihm = ihm;
		tabbedPane.addChangeListener(new ChangeListener() 
		{
			@Override
			public void stateChanged(ChangeEvent e) 
			{
				Component selectedComponent = tabbedPane.getSelectedComponent();
				delegateAction = getAction(selectedComponent);
				Ihm.getMenu().setEnabled(delegateAction!=null);
			}
		});
		System.out.println(delegateAction);
	}
 
    protected abstract ActionListener getAction(Component component);
}

maintenant la classe ActionAjouter code :

Code:

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
 
public class ActionAjouter extends ActionCRUD 
{
	private static final long serialVersionUID = 1L;
	private Ihm ihm;
	private ActionListener ajouterLivre;
	private ActionListener delegateAction;
 
    public ActionAjouter(JTabbedPane tab,Ihm ihm) 
    {
         super(tab, "Ajouter", ihm);
 
         this.ihm = ihm;
         ajouterLivre = new EcouteurLivre(ihm);
    }
 
	protected ActionListener getAction(Component component) {
		if ( component instanceof ItemAjoutable ) {
			delegateAction = ((ItemAjoutable)component).getAjoutAction();
			return delegateAction;
		}
	return null;
	}
 
	@Override
	public void actionPerformed(ActionEvent e) {
		if ( delegateAction!=null) delegateAction.actionPerformed(e);		
	}
}

Au fait petite interrogation par rapport à ma question précédent sur ajouterLivre et ajouterAuteur, d'accord le componon va recup tout les item mes comment dire que ajouterLivre = ecouteurLivre et ajouterAuteur = ecouteurAuteur car s'il ne fait pas la différence en appuyer sur ajouter il va bien le faire par rapport à l'onglets sélectionné mais il va lancer tous les écouteurs

La méthode actionPerformed() c'est dans ActionCrud. ActionAjouter ne fait que sélectionner l'action de délégation.

Voici un petit POC : (en plus je te montre comment gérer une action spécifique qui dépend en plus de la sélection (la suppression) :

Code:

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
public class Poc {
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("POC");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		JTabbedPane tab = new JTabbedPane();
		tab.add("Livres", new OngletLivre());
		tab.add("Auteurs", new OngletAuteur());
 
		JPanel panel = new JPanel(new BorderLayout());
		panel.add(tab);
 
		JButton buttonAjouter = new JButton(new ActionAjouter(tab));
		JButton buttonSupprimer = new JButton(new ActionSupprimer(tab));
		JPanel buttonPanel = new JPanel();
		buttonPanel.add(buttonAjouter);
		buttonPanel.add(buttonSupprimer);
		panel.add(buttonPanel, BorderLayout.SOUTH);
 
		frame.add(panel);
 
		tab.setSelectedIndex(0);
 
		frame.setSize(400, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	public static abstract class ActionCRUD extends AbstractAction {
 
		protected ActionListener delegateAction;
 
		public ActionCRUD(JTabbedPane tabbedPane, String nom) {
			super(nom);
			tabbedPane.addChangeListener(new ChangeListener() {
 
				@Override
				public void stateChanged(ChangeEvent e) {
					updateAction(tabbedPane);
				}
			});
			updateAction(tabbedPane); // il faut au moins l'appeler une fois pour la première fois (un onglet étant sélectionné par défaut)
		}
 
		protected void updateAction(JTabbedPane tabbedPane) {
			Component selectedComponent = tabbedPane.getSelectedComponent();
			delegateAction = getAction(selectedComponent);
			setEnabled(delegateAction != null); 
		}
 
		protected abstract ActionListener getAction(Component component);
 
		@Override
		public void actionPerformed(ActionEvent e) {
			if ( delegateAction!=null ) {
				delegateAction.actionPerformed(e);
			}
		}
 
	}
 
	public static class ActionAjouter extends ActionCRUD {
 
		public ActionAjouter(JTabbedPane tabbedPane) {
			super(tabbedPane,"Ajouter");
		}
 
		@Override
		protected ActionListener getAction(Component component) {
			if ( component instanceof ItemAjoutable ) {
				ItemAjoutable itemAjoutable = (ItemAjoutable) component;
				return itemAjoutable.getAjoutItem();
			}
			return null;
		} 
 
	}
 
	public static class ActionSupprimer extends ActionCRUD implements ActionEnabled {
 
		private ItemSupprimable lastItemSupprimable;
		private boolean isEnabled;
 
		public ActionSupprimer(JTabbedPane tabbedPane) {
			super(tabbedPane,"Supprimer");
		}
 
		@Override
		protected ActionListener getAction(Component component) {
			if ( lastItemSupprimable!=null ) {
				lastItemSupprimable.removeSupprimeEnabled(this);
				lastItemSupprimable=null;
			}
			if ( component instanceof ItemSupprimable ) {
				ItemSupprimable itemAjoutable = (ItemSupprimable) component;
				itemAjoutable.addSupprimeEnabled(this);
				lastItemSupprimable=itemAjoutable;
				return itemAjoutable.getSupprimeItem();
			}
			return null;
		}
 
		@Override
		public void setEnabled(boolean newValue) {
			super.setEnabled(newValue&&isEnabled);
		}
 
		@Override
		public void setActionEnabled(boolean enabled) {
			isEnabled=enabled; 
			setEnabled(true);
		} 
 
	}
 
	public static abstract class AbstractOnglet extends JPanel implements ItemAjoutable, ItemSupprimable {
 
		protected final DefaultTableModel tableModel;
		protected final JTable jtable;
		private final List<ActionEnabled> actionEnabled;
 
		public AbstractOnglet() {
			super(new BorderLayout());
			actionEnabled = new ArrayList<>();
			tableModel = createTableModel();
			jtable = new JTable(tableModel);
			jtable.getSelectionModel().addListSelectionListener(e-> changeTableSelection());
			add( new JScrollPane(jtable));
		}
 
		protected abstract DefaultTableModel createTableModel();
 
		@Override
		public void addSupprimeEnabled(ActionEnabled actionEnabled) {
			if ( actionEnabled!=null && !this.actionEnabled.contains(actionEnabled) ) {
				this.actionEnabled.add(actionEnabled);
				actionEnabled.setActionEnabled(jtable.getSelectionModel().getMinSelectionIndex()!=-1);
			}
		}
 
		@Override
		public void removeSupprimeEnabled(ActionEnabled actionEnabled) {
			this.actionEnabled.remove(actionEnabled);
		}
 
		protected void changeTableSelection() {
			boolean enabled = jtable.getSelectionModel().getMinSelectionIndex()!=-1;
			for(ActionEnabled action : actionEnabled) {
				action.setActionEnabled(enabled);
			}
		}
 
 
	}
 
	public static class OngletLivre extends AbstractOnglet  { 
 
		public OngletLivre() {
			super();
		}
 
		@Override
		protected DefaultTableModel createTableModel() {
			return new DefaultTableModel(new String[]{"Titre","Auteur","Editeur"},0); 
		}
 
		@Override
		public ActionListener getAjoutItem() {
			return event -> ajouterLivre();
		}
 
		@Override
		public ActionListener getSupprimeItem() {
			return event -> supprimerLivre();
		}
 
		public void ajouterLivre() {
			// ici le code pour ajouter un livre
			System.out.println("J'ajoute un livre");
			tableModel.addRow(new Object[]{"Truc","Bidule","Machin"});
		}
 
		public void supprimerLivre() {
			// ici le code pour supprimer un livre
			System.out.println("Je supprime un livre");
			int min = jtable.getSelectionModel().getMinSelectionIndex();
			int max = jtable.getSelectionModel().getMaxSelectionIndex();
			for (int i=max; i>=min; i--) {
				tableModel.removeRow(i);
			}
		} 
 
	}
 
	public static class OngletAuteur extends AbstractOnglet { 
 
		public OngletAuteur() {
			super();
		}
 
		@Override
		protected DefaultTableModel createTableModel() {
			return new DefaultTableModel(new String[]{"Nom","Prénom","Date de naissance"},0);
		}
 
		@Override
		public ActionListener getAjoutItem() {
			return event -> ajouterAuteur();
		}
 
		@Override
		public ActionListener getSupprimeItem() {
			return event -> supprimerAuteur();
		}
 
		public void ajouterAuteur() {
			// ici le code pour ajouter un auteur
			System.out.println("J'ajoute un auteur");
			tableModel.addRow(new Object[]{"Victor","Hugo",LocalDate.of(1802, Month.FEBRUARY, 26)});
		}
 
		public void supprimerAuteur() {
			// ici le code pour supprimer un auteur
			System.out.println("Je supprime un auteur");
			int min = jtable.getSelectionModel().getMinSelectionIndex();
			int max = jtable.getSelectionModel().getMaxSelectionIndex();
			for (int i=max; i>=min; i--) {
				tableModel.removeRow(i);
			}
		} 
	}
 
	public static interface ItemAjoutable {
		ActionListener getAjoutItem();
	}
 
	public static interface ItemSupprimable {
		ActionListener getSupprimeItem();
		void addSupprimeEnabled(ActionEnabled actionEnabled);
		void removeSupprimeEnabled(ActionEnabled actionEnabled);
	}
 
	public static interface ActionEnabled {
		void setActionEnabled(boolean enabled);
	}
 
}

02/02/2016, 11h02
nadong94

Très sympa ! je m'occupe d'une app Administrateur, donc j'ai besoin d'avoir accès à n'importe quelle cellule pour l'id ou autre et aussi besoin de pouvoir modifier