[Best practices] Referencement des objets d'un composant à l'autre

Bonjour bonjour,

voila je me demandais quelle était la plus propre façon de faire pour coder des composants graphiques.

J'ai par exemple un Panel P1, contenant un panel P2 contenant à son tour un Label L et une CheckBox C.
Chacun de ces composants ont leur propre classe hérité.

Je suis au niveau de P1, je veux modifier la valeur de L.
Comment faire ? Est ce que je dois aller récupérer L a partir de P2, donc faire quelque chose du genre :

P1.getP2().getL().setText("...)"

Ou alors je rajoute une méthode à P2 du genre :
setLText(String ...)
Methode qui va appeller la méthode setText de L.

Autre problème :

Supposons maintenant que l'on ait l'architecture :
P1 contient P2 et P3.
P2 contient L.
P3 contient C.

Admettons que cocher la checkBox entraine la modification du label. J'ai donc besoin dans ma checkBox d'avoir la référence de L. Comment je donne à C cette référence ? Par quel composant je passe ? Est ce que je créé L et C dans P1, et les passe au constructeur de P2 et P3. Cela me parait très limite, surtout que si demain je déplace P2 je n'ai plus qu'à tout refaire.

Est ce qu'une fois créé, je rajoute la référence de L à C dans P1 en faisant quelque chose du genre
(on est dans P1 )
P3.getC().setL(P2.getL());


Bref j'ai plusieurs problèmes de ce genre, dont je ne vois pas de solution propre. Car si ici les cas sont assez simple, mais si l'on a beaucoup plus d'imbrication ca donne vite des enchainement de get et set, ou des passages de paramètres pendant 10 constructeurs.


De manière général, auriez vous des références à me conseiller pour la structuration du code pour la création de composant graphique ?

Les références majeures sont le MVC, l'encapsulation, etc. Il y en a d'autres comme la séparation des domaines techno / métier, les clients hyper légers, etc. Il y a aussi l'usage des tests, et la simplicité, et la clarté, pour faciliter l'émergence, comme on dit dans les cocktails. Toutes ces choses sont belles et bonnes.

Mais aucune ne te donnera de recette toute faite.

Pour répondre à tes questions plus précisement...

Sur le composant imbriqué dans un composant imbriqué dans un composant imbriqué, moi, je n'hésite pas à parcourir toute la chaîne du plus gros vers le plus petit, par contre j'hésite plus à la parcourir du plus petit vers le plus gros. En général j'essaie de ne laisser ouvert que des interfaces en ce sens.

Donc lorsque une appli doit stipuler le texte d'un bouton, alors je fais monAppli.getPanel1().getPanel2().getPanel3().getPanel4().getBouton().setText("YOUPI !"), mais depuis mon bouton je ferais plutot appliInterface.close(), par exemple. Mais, évidemment, chaque cas est particulier, et j'essaie de voir ce qui me plait le plus à chaque fois.

Pour les problèmes de checkbox qui changent un texte, là je passe surtout par des Actions et des Listeners. Il n'y a donc pas de référence directe du checkbox vers le texte (normalement).

Lorsque les choses deviennent trop compliquées, alors je réfléchis au niveau du modèle, pour mieux correspondre, soit à une pratique propre à la GUI, soit à une pratique propre au métier. Je peux donc avoir un système de modèles qui dialoguent entre eux : un modèle proche pour le composant graphique (souvent le cas pour un JTree, par exemple), qui utilise un modèle proche des contraintes d'accés (vers une BDD...), avec même un modèle intermédiaire (qui est en fait le plus important ! ) celui qui prétend être fidèle au métier.

Et j'essaie d'expliciter tout ça avec un code expressif.

Voili voilà voilou.