Discussion :

[jym31]

J'ai une Map<String,String> dans laquelle je stocke des valeurs par défaut pour des composants Swing du style:

compo1,"test1"
compo2,"test2"
compo3,"test3"
...

J'aimerai parcourir les sous-composants d'un JPanel, et en fonction de la propriété name, setter la valeur stockée dans la map sur chaque composant.
Le problème c'est que mon JPanel va contenir de façon indifférencié des textfields, des combobox, des labels etc et donc la méthode pour setter la valeur est spécifique à chaque composant.


Je cherche donc un moyen élégant de pouvoir setter la valeur de ces composants.

Sol1: Je pourrai surcharger tout les composants Swing et leur faire implémenter une interface qui contiendrait une méthode 'setValue' mais je voudrais éviter de devoir étendre tous les composants.

sol2: Je pourrai faire un grand if, me baser sur des instanceof et caster mes components pour pouvoir appelé le bon setter. Je pense que c'est la piste à suivre mais je cherche un moyen plus élégant


Quelqu'un aurait une idée ?

merci !

[dinobogan]

Par qui/quoi est construit ton fichier ? Ton interface graphique évolue-t-elle ?
Explique le contexte de ce besoin de changer certaines valeurs de composants.

[jym31]

Le contexte globale est la sauvegarde & le chargement de critères de recherches.

Mes pages IHM sont divisées en une zone de critère / une table de result.
Selon les pages, les zones de critères sont différentes (des combos, des checkbox etc.) et l'utilisateur à la possibilité de charger/sauver les critères saisies.

Pour sauver ces paramètres en base, je me sers de la propriété name qui a été définie au préalable sur chaque composant. Je sauve donc en base un triplet du genre : User | composant | value.

Lorsque je recharge l'appli, mon DAO userPreferences me remonte un map Composant | value pour l'utilisateur courant et j'aimerai donc parcourir mes composants par nom et leur affecter les valeurs présentes dans la map.

D'où mon problème d'appeler le bon setter en fonction du type de composant.

[fraco]

J'aimerai parcourir les sous-composants d'un JPanel
Le problème c'est que mon JPanel va contenir de façon indifférencié des textfields, des combobox, des labels

comme ça ?

Code :

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

1
2
3
4
5
6
7
 
        for (int i = 1; i < jPanel1.getComponentCount(); i++) {
            JComponent compo = jPanel1.getComponent(i);            
            if (compo.getClass().equals(JTextField.class)) {
                   ...code                  
            }
        }

[jym31]

Oui c'est exactement ça l'idée. Je me demandais juste si quelqu'un voyait un moyen de faire ça plus efficacement et d'éviter d'avoir à faire un bloc if pour chaque type de composant.

Sinon effectivement je me rabatterai sur cette solution

[Heimdal]

Un truc du genre?

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public abstract class JComponentSettingHelper<T extends JComponent> {
 
	private final static Map<Class<?>, JComponentSettingHelper<?>> INTERNAL_MAP = new HashMap<Class<?>, JComponentSettingHelper<?>>();
 
	//on enregistre les implmentations
	static {
		register(JTextField.class, new JTextFieldSettingHelper());
		// ect...
	}
 
	private JComponentSettingHelper() {
	}
 
	// enregistrement d'une implementation
	private static <A extends JComponent> void register(Class<A> key,
			JComponentSettingHelper<A> value) {
		INTERNAL_MAP.put(key, value);
	}
 
	// methode à appeler
	public static <A extends JComponent> A getProperlySetComponent(A a,
			Object value) {
		// on cherche si l'implementation specifique pour la classe existe
		if (INTERNAL_MAP.containsKey(a.getClass())) {
			return ((JComponentSettingHelper<A>) INTERNAL_MAP.get(a.getClass()))
					.getInternalProperlySetComponent(a, value);
		}
		// sinon on cherche si une on a une implmenation d'une superclasse de
		// l'objet sous la main
		else {
			for (Class<?> key : INTERNAL_MAP.keySet()) {
				if (key.isAssignableFrom(a.getClass())) {
					return ((JComponentSettingHelper<A>) INTERNAL_MAP.get(key))
							.getInternalProperlySetComponent(a, value);
				}
			}
			// si y en a pas, on balance une exception
			throw new UnsupportedOperationException(
					"Operation not supported for component: "
							+ a.getClass().getName());
		}
	}
 
	// methode à surcharger selon composant
	abstract T getInternalProperlySetComponent(T t, Object value);
 
	// Une implementation
	private static class JTextFieldSettingHelper extends
			JComponentSettingHelper<JTextField> {
 
		@Override
		public JTextField getInternalProperlySetComponent(JTextField t,
				Object value) {
			t.setText(value.toString());
			return t;
		}
	}
 
	// etc...
}

Et pour l'appeler:

Code :

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

1
2
JFormattedTextField tf = JComponentSettingHelper.getProperlySetComponent(
				unJcomponent, "test");

Je suppose que c'est grandement améliorable, étant donné que comme un gros boulet je me retrouve toujours avec des cast immondes dans des classes soit-disant génériques...

D'ailleurs je suis preneur de toute façon plus clean de faire...