Discussion :

[rp37000]

Bonjour,

Je souhaiterais savoir comment vous procédez habituellement pour passer d'une vue à une autre.
Par exemple on est dans la vue1, laquelle contient un Bouton1 censé ouvrir une autre fenêtre : la vue2.

Comment gérez-vous cela?


Moi j'ai commencé comme suit mais je me retrouve bloqué!!


Dans le main() je commence par:

IModele modele=new modeleConcret();
//Avec modeleConcret implémentant IModele

IVue vue1=new vueConcrete();
//Avec vueConcrete implémentant IVue

IController controleur1=new controllerConcret( vue1, modele );
//Avec controllerConcret implémentant IController



Ensuite dans le constructeur controllerConcret( IVue vue, IModele modele) j'ai:

this.modele=modele;
this.vue=vue;
this.vue.setController(this); //< Une IVue attend pour controller un IController


//----------

Quand l'utilisateur cliquera sur le fameux Bouton1 de la vue1, alors le contrôleur controleur1 en sera informé et alors là : je ne sais pas ce que doit faire ce contrôleur dés lors.... pour que la vue2 soit ouverte et associée à un autre contrôleur controller2 ??? Je suis coincé je ne sais pas!

- Qui doit instancier la vue2 ?
- Qui doit instancier le contrôleur pour cette dernière?


Sachant qu'idéalement je souhaiterais au final avoir des instanciations de la forme:
IVueBis vue2=new vueConcreteBis();
IControllerBis controleur2=new controllerConcretBis( vue2, modele );

Mais où écrire ça?
Qui est censé connaître l'interface IVueBis et la classe vueConcreteBis?
Qui est censé connaître l'interface IControllerBis et la classe controllerConcretBis ?


Si vous aviez des réponses, des solutions, ou si vous voulez bien me faire part de vos pratiques habituelles ça me serait d'un grand secours....!


Merci à tous et toutes.

[rp37000]

J'essaye de trouver une solution pendant ce temps, et j'ai une 1ère idée
(je ne sais pas ce qu'elle vaut en terme de MVC-respect)!

Ma première idée est donc de transmettre à chaque Vue (susceptible de mener vers une ou plusieurs autres Vues), des objets Vues (implémentant une interface donnée) qui sont des objets qu'elle saura alors "Ouvrir". La Vue en question
saura donc, sous ordre de son CONTROLEUR , ouvrir l'une des Vues censée lui faire suite. Par contre ce serait le CONTROLEUR , via l'interface CONTROLEUR->Vue, qui ordonnerait à la Vue d'ouvrir telle ou telle vue censée lui succéder.
Un truc du genre:

Le CONTROLEUR dirait à sa Vue this.vue:
this.Vue.showVueXXX();

Et la Vue dans sa méthode showVueXXX() ferait un:
this.vueXXX.open();

vueXXX n'étant connue que par la Vue, laquelle l'a reçue en param. de son constructeur.
Ce qui veut dire que le CONTROLEUR ne connaîtrait pas du tout le type abstrait ou concret de l'objet vueXXX, et qu'il sait juste ordonner à la Vue de l'ouvrir.
L'inconvénient: ça suppose que l'objet vueXXX a été instancié, et initialisé(son Contrôleur,...) avant d'être passée au constructeur de la Vue.
Et il en va de même pour les éventuelles vues qui pourraient succéder à la vueXXX...., etc...


ou qcch comme ça!?
Qu'en pensez-vous??


Auriez-vous d'autres idées, des critiques ?

[tristan_m]

Rebonjour,

J'ai peur de ne pas saisir la problématique en fait ni pourquoi tu as besoin d'avoir simultanément deux vues et deux contrôleurs.

En tout cas, avec les éléments à ma disposition, l'idée immédiate et de faire construire la nouvelle vue et le nouveau controleur au contrôleur1.

Qui mieux que lui sait quelle action effectuer en cas d'évènement?


Donc en gros au moment du clic, vue1 envoie l'évènement au contrôleur1, qui s'occupe de coder les lignes que tu as écrites :

Code :

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

1
2
IVueBis vue2=new vueConcreteBis();
IControllerBis controleur2=new controllerConcretBis( vue2, modele );

Eventuellement il demande une mise à jour au modèle pour prendre en compte le fait que la deuxième vue a été ajoutée.

En tout cas, pour moi ce n'est pas la vue qui doit savoir quelle nouvelle vue doit être créée.
En principe une vue doit juste représenter le modèle. Si le modèle implique la création d'une nouvelle fenêtre alors cette nouvelle fenêtre doit faire partie de la même vue que la première.
En revanche le contrôleur peut décider qu'une vue peut être plus adéquate qu'une autre.


Bref j'ai l'impression de passer à côté de contraintes évidentes mais je n'arrive pas à voir lesquelles

[rp37000]

Bonjour tristan_m,


J'accuse réception de ton point de vue, et t'en remercie.

Je vais te répondre ... prochainement.

Merci encore.

[rp37000]

En fait,

Ce que je veux faire c'est:
Sur la Vue1, par exemple j'ai la liste des clients, je peux en en sélectionnant
un, puis cliquant sur le Bouton "Modifier" (le fameux Bouton1), modifier sa fiche. Cette fiche est ma fameuse Vue2 (pour moi il s'agira d'une autre fenêtre).
Lorsque s'ouvre cette fiche, cette fenêtre donc, je veux que la Vue1 se ferme, puis lorsque l'utilisateur fera "Annuler" ou "Valider" sur cette fiche, ce soit à nouveau la Vue1 qui soit affichée, et que la Vue2 soit fermée.

Voilà pour l'objectif.
Alors selon MVC ça donnerait quoi?

***************************
Toi, tristan_m, tu me proposes en gros que:
Le Bouton "Modifier" de la Vue1 informe le Contrôleur de la Vue1 lorsqu'il est cliqué. Le Contrôleur interroge alors la Vue1 pour vérifier si en parallèle un client est bien sélectionné dans la liste.
Si oui, alors tu suggères que le Contrôleur récupère le client en question et fasse:

IVueFicheClient vue2=new vueFicheClient();
IControllerFicheClient controleur2=
new controllerFicheCLient( vue2, this.modele );

Puis on communique aussi à ce contrôleur-ci les infos concernant le Client
sélectionné.

C'est bien ça??

Ce qui me dérange, dans un premier temps, dans cette façon de procéder, c'est que:

Le Contrôleur initial (celui de la Vue1), disons de type IControllerListeClients, DOIVENT connaître le type CONCRET! : et de la FicheClient, et du Controleur Fiche Client. Donc GROS couplage, ça me plaît pas du tout...
Je souhaite que les seuls types connus par le Contrôleur soient des types Interfaces. Donc je ne veux pas qu'un Contrôleur puisse faire
new Vue() ou new Controller() (types Concrets!) , MAIS que,
soit transmis au Contrôleur de la Vue1(Liste Clients): la Vue2 (de type IVueFicheCLient)(qui elle, connaît son propre Contrôleur à savoir elle sait qu'il est de type IControllerFicheClient, et le possède déjà parmi ses attributs).
Et là je rejoins donc le message que j'ai posté ici le 22/12/2008 à 17h41, à ceci près que cette fois je suis d'accord avec toi: c'est le contrôleur de la Vue1 qui lance DIRECTEMENT l'ouverture de la Vue2 (et non plus le Contrôleur de la Vue1 qui demande à sa Vue1 d'ouvrir sa Vue2).
(En même temps je voudrais aussi éviter de passer par une fabrique abstraite de Vues...: CA EXLUE DONC QU'UN CONTROLEUR CREE UNE VUE, via fabrique ou non(new...).)---> Par contre ça m'oblige à faire un new de toutes les vues
dans le programme principal (main()): et ça niveau mémoire ça pue!!!

Est-ce-que mon problème est plus clair maintenant?

[Patriarch24]

En utilisant le pattern commande, tu peux arriver à tes fins :
- le bouton est cliqué sur la vue 1
- l'évènement remonte au contrôleur, lequel peut alors déléguer cet objet (la commande) à un délégué de traitement
- le délégué de traitement crée la vue concrète (cela dépend de son paramétrage, une fabrique abstraite peut aider) et la retourne au contrôleur
- le contrôleur affiche la vue

En Java, les boutons se voient assigner des actions, avec un nom. Cela peut suffire dans le cadre du pattern commande, mais dans ton cas tu souhaites faire passer une information supplémentaire (le nom du client). Donc dans ce cas, le contrôleur au lieu de faire suivre l'objet commande (event) initial, construit la commande lui-même avec les données qu'il connaît, et fait passer cet objet à son délégué. Et le tour est joué !