Discussion :

[M€lK!oR]

Bonjour,

J'aimerai savoir si il est possible en GWT d'inclure un module dans d'autres modules ? A la manière d'un jsp:include.

Concrètement, j'aimerai inclure un module "bandeau" mes autres modules GWT.

Est ce possible ?

J'ai tenté de contourner le problème en créant un module que je déclare dans tout les autres modules :

Code :

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

1
2
  <!-- On inclue ici le panel  -->
  <inherits name='com.empeiria.modele.ui.IncludePanel'/>

Ce module IncludePanel est ajouté dans chaque EntryPoint (autres modules) :

Code :

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

RootPanel.get("includePanel").add(IncludePanel.getInstance());

"includePanel" étant une div présente dans chaque page html.

IncludePanel :

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
package com.empeiria.modele.ui.client;
 
import com.google.gwt.user.client.ui.HasHorizontalAlignment;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Label;
 
public class IncludePanel extends HorizontalPanel{
 
	private static IncludePanel instance = getInstance();
 
	public final static IncludePanel getInstance(){
		if(instance == null){
			initIncludePanel();
		}
 
		return instance;
	}
 
	private static void initIncludePanel(){
		instance = new IncludePanel();
		instance.setBorderWidth(1);
		instance.setWidth("100%");
 
		Label l = new Label("Panel inclu !");
		l.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER);
		l.setStyleName("titre");
 
 
 
		instance.add(l);
 
 
	}
 
 
 
}

Je me rapproche du comportement attendu, seulement, l'objet IncludePanel est réinstancié pour chaque module l'appelant. Je voudrai qu'il soit construit une seule fois et utilisable dans son état dans tout les autres modules

Des idées ? Conseils ? Solutions ?

Merci d'avance !

[benwit]

On peut faire des modules réutilisables dans d'autres modules.

Je pense que si ce n'est pas nécessaire, il faut se passer de leur mettre un entrypoint puisque au chargement des modules, tous les entrypoint sont executés et comme ils modifient la même page, on en arrive au comportement que tu cites.

Ceci dit, et même si je ne connais pas exactement ce que tu fais, j'ai l'impression que tu essayes de reproduire en gwt (par ta comparaison avec jsp) un comportement inadéquate.

JSP, c'est de la navigation entre pages et on peut factoriser des bouts de code.

GWT, c'est du SPI : Single Page Interface. On a une seule page que l'on modifie via le DOM. Si tu veux réutiliser du code, il te faut créer des composants (en faire éventuellement des modules) et les utiliser dans ton module principale.

Il faut oublier la notion de page. Au besoin, se créer des vues et dans la page principale unique, on met un panneau à carte où on empile ces vues au fur et à mesure ... mais on affiche à un instant t uniquement une vue.

[M€lK!oR]

C'est exactement ça benwit. J'ai bien conscience que GWT est du SPI seulement j'ai une contrainte projet qui m'oblige à découper chaque page en module (pour des raisons de travail en équipe) et donc je suis forcé de créer un mécanisme d'inclusion.

Je te remercie pour tes réponses.

Je vais tenter de concerver mon composant "bandeau" pour chaque module et si je n'y parviens pas, je proposerais la solution classique, une page avec des ajouts/suppressions de composant dans le DOM

Merci bien.

[benwit]

Dans ton cas, je procéderai de la façon suivante :

Découpage par développeur = un module par développeur.

Et le super développeur qui manage le tout a le module de l'application qui utilise les modules des autres.

[M€lK!oR]

Si l'on suit cette démarche, il n'y aura donc qu'un seul point d'entrée et des modules à a jouter au dom ?

Comment alors définir ses modules ?

[benwit]

Je ne connais pas ton appli mais imaginons que tu es 4/5 pages classiques avec un bandeau commun.

Le développeur principal crée un module gwt (celui de l'application) avec la vue comportant le bandeau + la partie variable.

Chacun des autres développeurs récupère ce module car pour tester leur partie, il leur faut bien un point d'entrée.

Chacun crée à côté leur module spécifique (création habituelle) :
vire l'entry point du module (créé par défaut)
crée sa vue sous forme de composite
référence son module dans le module principale
et dans l'entry point du module principal, instancie la vue composite.

Le développeur principal n'aura qu'à référencer l'ensemble des sous modules dans le module principal et à ajouter le code qui permet de sélectionner le bon module spécifique.

[M€lK!oR]

Si je t'ai bien saisi, je pense que c'est ce que je fait.

- J'ai un module principale avec un entry point. La page html associée contient deux div d'ids "bandeau" et "page".
- J'ai trois classes "Bandeau", "Page1" et "Page2" qui étendent VerticalPanel et contiennent le contenu de mes pages.
- Dans le onModuleLoad() de ma page principale, je place mon composant Bandeau (verticalPanel) dans la div "bandeau" et en fonction de l'action d'un utilisateur, le composant pageX qui va bien dans la div "page".

Actuellement, mes modules annexes n'en sont pas vraiment, je n'ai pas écrit de gwt.xml pour décrire chaque sous module.
- Me conseille tu de le faire ?
- De simples "inherit" dans mon module principal suffiront à utiliser mes modules annexes ?
- Comment charger mes sous modules qu'une seule fois ?

Merci d'avance pour les précisions que tu m'apporteras.

[benwit]

L'idée du sous module gwt, c'est pour être réutilisé ailleurs et éventuellement pour des développeurs qui ne partageraient pas du code via un svn.

Si c'est juste un découpage fonctionnel, ce n'est pas nécessaire surtout si chaque développeur peut accéder au code via un svn.

Un simple inherits suffit et les sous modules ne sont chargés qu'une fois (pas d'entry point nécessaire pour eux)