Discussion :

[plegat]

Bonsoir,

J'ai actuellement une application composée d'une fenêtre principale, et de plusieurs fenêtres "filles", et j'aurais besoin de faire transiter des messages de la mère vers les filles.

Pour être précis, il s'agit d'un programme de pre/post traitement de modèles éléments finis.
J'ai une classe "Maillage", qui gère toutes les données, à travers plusieurs objets, par exemple les classes "Noeuds", "Elements", "Groupes", etc.
Les fenêtres filles affichent des outils permettant d'intervenir sur ces objets.
Cependant, lorsque je fais une remise à zéro du Maillage (donc que je réinitialise tous les objets), il faut que les fenêtres filles soient mise à jour au niveau affichage, mais sur ordre de la classe "Maillage" et pas sur ordre des classes liées au fenêtres fille.

Pour l'instant, chaque fille implémente une interface spécifique.
Et chaque fois que j'ai besoin d'envoyer un message, par exemple la remise à zéro du "Maillage", je fais le tour de toutes les fenêtres affichées (via un getFrames() sur la fenêtre mère), et je regarde si chaque fenêtre implémente l'interface spécifique. Si oui, j'appelle la méthode qui lance la réinitialisation des données à afficher, puis qui lance la réinitialisation de l'affichage de la fenêtre.

Ca me semble quand même un peu compliqué tout ceci (déjà à expliquer...). Mais je ne souhaite pas gérer la mise à jour des gui à partir des classes gérant les données à afficher.

Est-ce que vous auriez d'autres méthodes?


Si jamais je n'ai pas été clair, je vais mettre le problème en lettres...

J'ai une classe A, liée à une gui principale GUI_A, et utilisant des objets B,C,D,E...
Chaque classe B,C,D,E... peut être relié à une ou plusieurs gui: GUI_B1, GUI_B2, .... GUI_E1, GUI_E2, ...

Il arrive un moment où j'ai besoin de faire passer une information de la classe A vers les gui GUI_B1, GUI_B2, GUI_C1... mais sans passer par les classes B, C, ...

Voilà.
Merci d'avance pour vos idées.

[sinok]

Aller au hasard, un Système de listeners: dans la classe maillage tu as une liste de composants enregistrés, et si tu remets à 0 ton maillage tu parcours la liste des composants aet leur fait parvenir l'évènement voulu.

Comme ça tu réalise une interface commune (dans le genre d'un ActionListener ), tu enregistres tes listeners sur ta classe principale et tu t'inspires du code du fireActionPErformed d'un JButton par exemple:

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
 
protected void fireActionPerformed(ActionEvent event) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        ActionEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i]==ActionListener.class) {
                // Lazily create the event:
                if (e == null) {
                      String actionCommand = event.getActionCommand();
                      if(actionCommand == null) {
                         actionCommand = getActionCommand();
                      }
                      e = new ActionEvent(AbstractButton.this,
                                          ActionEvent.ACTION_PERFORMED,
                                          actionCommand,
                                          event.getWhen(),
                                          event.getModifiers());
                }
                ((ActionListener)listeners[i+1]).actionPerformed(e);
            }          
        }
    }

[herve91]

Est-ce que les classes GUI_Xx connaissent la classe A ?
Si oui, un système de listeners est en effet approprié.
Si non, tu pourrais avoir un singleton GuiRepository qui maintiendrait la liste des GUI_Xx souhaitant être notifiés d'un événement.

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
 
interface Gui {
   void notify(Event event);
}
public class GuiRepository {
   private Set guiSet = new HashSet(); // of Gui
   private static GuiRepository instance = new GuiRepository();
 
   public static GuiRepository getInstance() {
     return instance;
   }
 
   public void register(Gui gui) {
     instance.add(guiSet);
  }
   public void deregister(Gui gui) {
     instance.remove(guiSet);
  }
 
  public void notify(Event event) {
    Iterator it = guiSet.iterator();
    while (it.hasNext()) {
      Gui gui = (Gui) it.next();
      gui.notify(event);
    }
  }
}

[plegat]

dans la classe maillage tu as une liste de composants enregistrés

ben justement, c'est ce que j'essaye de faire... tout du moins, de les enregistrer en dur dans le code.

Est-ce que les classes GUI_Xx connaissent la classe A ?

oui, elles ont accès à l'instance de la classe A

Je vais approfondir un peu vos propositions sur les listeners, voir si j'arrive à mettre ça en place.

Je vous informe de l'évolution du problème dès que possible.

Merci à tous les deux.

[plegat]

Bon, ben... c'était juste pour dire que ça marche nickel!

J'ai repris mes bouquins ("Au coeur de Java2, volume 1" pour ne pas le citer), page des évènements personnalisés. Je suis tombé sur ce qu'a expliqué Sinok, avec un gros exemple en prime qui m'a bien aidé pour affiner la chose.

J'ai créé mon évènement personnalisé, j'ai rajouté le gestionnaire d'évènements dans ma classe principale, mis en place les écouteurs à partir des fenêtres à rafraichir, fais deux-trois tests, et....

désolé d'être grossier, mais putain que c'est beau quand ça marche bien comme ça!

Encore merci à tous les deux de m'avoir fait découvrir ça!

Sur ce, je peux aller au lit maintenant...

Zou, il est passé où le bouton "résolu"....?
[edit] c'est bon, je l'ai retrouvé!