Les outils pour faciliter le développement de nouveaux ...

quaggaholeInternet and Web Development

Aug 15, 2012 (4 years and 10 months ago)

461 views

Objet Direct Lyon

1 cours Albert Thomas 69003 Lyon

Tél 04 72 33 78 30 Fax 04 72 33 68 67

Objet Direct Grenoble

Les Iles Cordées 38113 Veurey

Tél 04 76 53 72 72 Fax 04 76 53 72 77

Siège : 39 rue des Peupliers 92100
Boulogne

Tel 01 56 88 69
00 Fax 01 56 88 69 01

SAS au capital de 160 000

.

Siret 433 914 322 722 Z

www.objetdirect.com








Objet Direct

O
utils pour faciliter le développement
de nouveaux composants Tatami.

Réf :

Auteur : Vianney Grassaud

Version : 1.0

Septembre 2007


Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

2


Table des
Matières
.


1

INTRODUCTION

................................
................................
................................
.........................

3

2

UNE INTERFACE «

HASDOJO

».

................................
................................
............................

4

3

UNE CLASSE «

HELPER

»

: DOJOCONTROLLER

................................
..............................

6

4

UTILISER L’ABSTRACTI
ON POUR FACTORISER L
E CODE DES COMPOSANT
S
TATAMI.

................................
................................
................................
................................
.................

9

4.1

L
ES CLASSES ABSTRAITE
S PROPOSEES PAR
T
ATAMI
.

................................
..............................

9

4.
2

U
N EXEMPLE DETAILLE
.

................................
................................
................................
.........

9

5

LA CLASSE FISHEYE RE
VISITEE.

................................
................................
......................

12



Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

3


1

Introduction


Ce document est un complément du document intitulé

: «

Créer un composant
Google Web

Toolkit en utilisant Dojo

» écrit

par Henri Darmet (Directeur
Techniq
ue d’Objet Direct). A partir d’
éléments essentiels de l’article, une
stratégie de développement a été déduite afin de simplifier le code des
composants, et d’éviter toute duplication inu
tile entre les composants. Dans
ce document nous allons présenter en détail les différents outils qui
permettent de développer ces nouveaux composants en respectant les
bonnes pratiques énoncées par Henri Darmet.
Une lecture de l’article «

Créer
un composa
nt Google Web Toolkit en utilisant Dojo

» est conseillée pour
comprendre et maitriser les outils et choix présentés.




Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

4


2

Une interface
«

HasDojo

»
.


Tout d’abord, nous devons préciser que notre composant Google Web Toolkit
(GWT) va encapsuler une widget Do
jo. Pour cela une interface de type
HasDojo a été mise au point. Voici, les méthodes préconisée
s

par
l’interface

et que le développeur devra implémenter :




public

JavaScriptObject getDojoWidget()


Renvoie la widget Dojo.





public

void

createDojoWi
dget()
throws

Exception




Crée la widget Dojo via JSNI pour la plus part des cas. Cette méthode n'est
pas à utiliser directement, c'est un contrôleur qui doit l'exécuter. une
Exception est déclenchée si la widget Dojo ne peut pas être créée. Attention
à

bien vérifier les paramètres et la nature des objets JavaScript quand on est
au niveau JSNI.





public

void

onDojoLoad()



Cette méthode exécute les instructions Java ou JavaScript (via JSNI) quelle
contient. Cette méthode est à utiliser après que les

scripts JavaScript
nécessai
res par Dojo ont bien été chargé
s. L'implémentation de cette
méthode n'est pas courant et dépend fortement du widget Dojo à intégrer
mais aussi de la façon d'intégrée la widget.



public

String getDojoName()




Renvoie le nom
du widget dojo exemple : «

FisheyeList

»

Cette méthode est utilisée

pour charger et créer les scripts JavaScripts
nécessaire à Dojo. Voir la documentation de Dojo pour connaître les noms
exacts.



public

void

doAfterCreation()



Construit le composant Do
jo si l'instanciation seule de la widget ne suffit pas.

Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

5


Cette méthode ne doit pas être appelée explicitement sauf par un contrôleur
Dojo.



public

void

doBeforeDestruction()



Permet de libérer l'espace mémoire pris par des composants JavaScript,
Dojo ou

autres. Cette méthode ne doit pas être appelée explicitement sauf
par un contrôleur Dojo.



public

void

free()



Libère, met à null la ressource prise par la
w
idget

dojo

dans la widget GWT.
Cette méthode ne doit pas être appelée explicitement sauf par
un contrôleur
Dojo



Ces méthodes devront être appelées pour la plus part à des moments précis
et pas de manière explicite par le composant GWT à développer pour éviter
une maintenance difficile. On a besoin d’une classe qui va pouvoir contrôler
l’interf
ace HasDojo et, appelé ces méthodes dans un ordre spécifique au
traitement désiré pour le composant GWT.
Cette classe est présentée dans la
section suivante. De cette manière le développeur se focalise sur
l’implémentation des méthodes et non sur comment e
lles sont appelées, toute
fois il est nécessaire de savoir quand, ceci étant clairement documenter.





Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

6


3

Une classe
«

Helper

»

: DojoController


Pour faciliter l’intégration et éviter certaine
s

répétition
s

de code il faut utiliser
la classe DojoController
.

Cette
interface

possède les méthodes permettant

de
charger les scripts JavaScript Dojo, d’instancier les widgets Dojo, de libérer la
mémoire pris par la widgets… Ci
-
dessous la liste détaillée des méthodes de
cette
interface
. Notons que la classe DojoCont
roller est un singleton.




public

static

DojoController getInstance()



Renvoie l'instance unique du singleton.




public

void

destroy(JavaScriptObject dojoWidget)




Détruit la widget Dojo passée en paramètre.




public

void

loadDojoWidget(HasDojo

widget)



Charge si nécessaire les scripts JavaScripts Dojo, pour une widget GWT
implémentant l’interface HasDojo. Cette méthode appelle
HasDojo#onDojoLoad() s'il est nécessaire de charger les scripts JavaScript.
Cette méthode utilise HasDojo#getDojoNa
me() pour connaitre les scripts à
charger.



public

void

constructDojoWidget(Has
Dojo widget, Widget gwtWidget)



Construit la widget Dojo a partir de l'interface HasDojo et relie la widget Dojo
avec la widget GWT donné
e

en paramètre.



public

void

dest
royDojoWidget(HasDojo widget, Widget gwtWidget)



Supprime le lien entre la widget GWT d
onnée en paramètre et l’objet
im
plémentant l'interface HasDojo. La widget Dojo
est détruite p
our éviter les
memory leak.



public

void

link(JavaScriptObject dojoWidg
et, Widget gwtWidget)



Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

7



Crée un lien entre la widget Dojo et la widget GWT. Ajoute aussi l'élément
DOM de la widget Dojo à l'élément DOM du widget GWT.



public

void

unLink(JavaScriptObject dojoWidget, Widget gwtWidget)



Supprime le lien entre une widg
et Dojo et une widget GWT. En plus de
supp
r
imer le lien,
on

retire

aussi l'élément DOM m
a
térialisant la widget
DOJO à la widget GWT.
Ceci en s
upposant que l'élément DOM est ajouté à
l'élément DOM de la widget GWT.



public

Element getDomNode(HasDojo widg
et)



Retourne l'élément

DOM ma
térialisant la widget Dojo
.




public

void

setGWTWidget(JavaScriptObject dojoWidget,Widget
gwtWidget)



Établie

ou brise le lien qui part de la widget DOJO et qui
atterrit

sur la widget
GWT.



static

public

void

alert(Str
ing object)



Affiche

un
e

boite de dialogue d'alerte JavaScript.

NB : si c'est pour

boguer, il est préférable d'utiliser
la méthode
GWT.log(String, Throwable)



public

JavaScriptObj
ect createSimple(String widget)



Cré
e une
«

simple

»

widget Dojo. Si
mple du fait qu'aucun
paramè
tre n'est

demandé

pour la widget

Dojo


Exemple

:
DojoController.getInstance().createSimple("Clock")



public

JavaScriptObject createSimple(HasDojo widget)



Cré
e une
«

simple

»

Dojo widget à partir d'une interface HasDojo.

L
’objet

Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

8


renvoyé

correspond à la widget Dojo créée.






Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

9


4

Utiliser l’abstraction pour factoriser le code des
composants Tatami.


Nous avons vu les outils permettant de faciliter l’intégration d’un composant
Dojo dans un composant GWT. Cependant, on peut enc
ore réduire le coup de
cette intégration en utilisant l’abstraction. En effet, supposons que l’on veuille
intégrer plusieurs composants Dojo dans des composants GWT de type
Widget. Il serait «

dommage

» de réécrire le même code plusieurs fois pour
chacun d
es composants car il est certain qu’il y aura des re
ssemblances entre
ces derniers
. On va alors créer une classe abstraite qui héritera de Widget et
implémentera l’interface HasDojo. Chaqu
e composant à intégrer

devra hériter
de cette classe abstraite.
Le
code qui sera alors factorisé est le code
permettant la création, la destruction des widgets Dojo lors des attachements,
détachement des widgets GWT au navigateur.

Ce
tte façon de faire
peut être
renouvelé
e

pour chaque type de composant GWT
que l’on souhai
te utiliser
pour l’intégration
comme par exemple FocusWidget.



4.1

Les classes abstraites proposées par Tatami.


Tatami intègre des composants Dojo, il est évident qu’il en découle plusieurs
classes abstraites pour faciliter l
eur i
ntégration.
L’utilisation de

ces classes est
préconisée pour de futurs composant Tatami afin de garder l’homogénéité et
d’améliorer la maintenance.

Les classes abstraites sont les suivantes, leur
classe mère GWT est écrite à
droite
.



AbstractDojo



com.google.gwt.user.client.ui.
Wid
get


AbstractDojoComplexPane


com.google.gwt.user.client.ui.
ComplexPane



AbstractDojoFocus



com.google.gwt.user.client.ui.
FocusWidget



4.2

Un exemple
détaillé
.


Étudions le cas de la classe AbstractDojo

:


Tout d’abord la classe doit obligatoirement a
voir comme classe mère haut
plus haut de sa hiérarchie la classe
com.google.gwt.user.client.ui.Widget
.


Et doit implémenter l’interface vu précédemment
HasDojo
.


Ce qui nous donne

:


Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

10



/**

Cette classe abstraite a pour but d'
implémenter

les
méthodes

nécess
aires

pour l'intégration d'une widget Dojo dans une Widget Gwt.
Cette classe implémente l'interface HasDojo

pour préciser que la
widget GWT a bien un composant Dojo.


Les méthodes
à

implémenter son
t

:


-

La création du widget Dojo
.


-

Une méthode qui
s'e
xécute après le chargement de script
s

Dojo
.



-

C
onnaitre le nom du widget Dojo
à

créer.


La classe abstraite permet d'appeler ces méthodes "aux bons moments"
afin
d'é
viter des problèmes de memory leak, et d'assurer que les
scripts JavaScript Dojo soit bi
en charges par le browser, et que ces
mêmes script soient chargés qu'un
e

seul
e

fois.

*/

public

abstract

class

AbstractDojo
extends

Widget
implements

HasDojo



L’interface HasDojo implique que l’on retourne un objet de type
JavaScriptObjet, pour cela nous a
llons
déclarer

l’attribut de classe :
dojoWidget de ce même type.


/**

L
a

Widget DOJO recommand
ée

par l'interface

*/

protected

JavaScriptObject
dojoWidget
;



Occupons nous
maintenant
d’implémenter les méthodes recommandées par
l’interface HasDojo.
Il
para
it
évident que les méthodes getDojoName() et
createDojoWidget() ne peuvent pas être implémentées car elles sont trop
spécifique
s

au stade où on est

dans l’intégration
.
Ci
-
dessous les méthodes en
allant vers les besoins les plus basiques

:


/**


Renvoie la

widget Dojo intégrée par la widget GWT.


@return

l'objet JavaScript correspondant à la widget Dojo


*/

public

JavaScriptObject getDojoWidget() {



return

this
.
dojoWidget
;

}


/**


Libère la ressource utilisée par la widget Dojo, dans la widget GWT.


Ne
pas appeler cette méthode explicitement, laisser le

D
ojoController s'en occuper.

*/

public

void

free() {


this
.
dojoWidget

=
null
;

}




/** Ne fait rien, surcharger cette
méthode

si
nécessaire

*/


public

void

doBeforeDestruction() { }




Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

11


/** Ne fait rien, s
urcharger cette
méthode

si
nécessaire

*/


public

void

doAfterCreation() { }




/** Ne fait rien, surcharger cette
méthode

si
nécessaire

*/


public

void

onDojoLoad() {}





Attaquons nous au constructeur

de la classe abstraite.

Plusieurs
constructeu
rs peuvent être nécessaires, dans notre cas un seul suffit.

N
ous
devons ajouter l’élément DOM matérialisant la widget Dojo à l’élément DOM
de la widget GWT

durant la création de la widget Dojo. L’élément DOM de la
widget GWT sera initialisé dans le constru
cteur de la classe abstraite.

C
’est

aussi

durant la création de la widget GWT que nous devons charger les
scripts JavaScripts nécessaires

pour la création de la widget Dojo
. Voici la
mise en œuvre.


/**

Charge les scripts JavaScript nécessaires au widget

dojo a integrer.

@param

element element de l'arbre DOM a associer comme element à la
widget GWT.

@see

DojoController#loadDojoWidget(HasDojo)


*/

protected

AbstractDojo(Element element) {


super
();


DojoController.
getInstance
().loadDojoWidget(
this
);


this
.setElement(element);

}


A ce stade nous

avons implémenté les méthodes

de l’interface
, et créer un
constructeur pour charger les scripts JavaScript

et initialiser l’élément DOM
de notre composant GWT
. Il reste une dernière étape

: la création de la
widget
Dojo durant l’attachement au navigateur et la destruction de la widget
Dojo durant le détachement.
Pour cela nous allons surcharger les méthodes
onAttach() et on Detach() de la classe Widget. Notons aussi que l’on veut que
ces m
éthodes soient «

symétriques

», c'est
-
à
-
dire que

l’on garde la même
philosophie dans chacune d’elle.




/**

Quand la widget GWT est détachée du browser, on détruit le lien entre
celle
-
ci et la widget Dojo.

On détruit aussi la widget Dojo.

Ceci permettant de ne pas garder l'objet Doj
o dans l'a
r
bre DOM du
navigateur.

@see

DojoController#destroyDojoWidget(HasDojo,
com.google.gwt.user.client.Element)

@see

#doBeforeDestruction()

*/


protected

void

onDetach() {


DojoController.
getInstance
().destroyDojoWidget(
this
,
this
);


super
.onD
etach();


}



Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

12



/**

Quand la widget GWT est attachée au navigateur, on crée la widget
Dojo et la lie avec la widget GWT. Si la création échoue pour une
cause de mauvais paramètre comme un nom de widget Dojo inconnu, une
alert
e

sera
pré
sente

(
Problème

sous IE
) Cette

thode peut
êt
r
e

surcharg
ée

pour rajouter d'autre
s

dépendances entre la widget GWT et
Dojo.

@see

Widget#onLoad()

@see

#doAfterCreation()


*/

protected

void

onAttach() {


DojoController.
getInstance
().constructDojoWidget(
this
,
this
);


super
.onAttac
h();

}



Au final, l
e code de la classe abstraite n’
a rien de
compliqué. En héritant de
cette classe, le développeur s’occupera du problème

:
«

comment créer la
widget Dojo

?

»
en implémentant la méthode createDojoWidget()
recommandée par l’interface HasDo
jo. Il devra évidemment rajouté les
méthodes qui seront spécifique
s

à la widget à intégrer.



5

La classe FishEye revisitée.


Voici ci
-
dessous la classe FishEye revisitée en utilisant les outils présentés ci
-
dessus.



public

class

FishEye
extends

Abstract
Dojo {


...

/**


Construction d'une barre d'icone (pour l'instant encore sans icone)

*/

public

FishEye(
int

itemWidth,


int

itemHeight,



int

itemMaxWidth,


int

itemMaxHeight,



String orientation,



int

effectUnits,



int

itemPadding,



String attachEdge,



String labelEdge,



boolean

conservativeTrigger) {


super
();


this
.
itemWidth

= itemWidth;


this
.
itemHeight

= itemHeight;


this
.
item
MaxWidth

= itemMaxWidth;


this
.
itemMaxHeight

= itemMaxHeight;


this
.
orientation

= orientation;


this
.
effectUnits

= effectUnits;


this
.
itemPadding

= itemPadding;


this
.
attachEdge

= attachEdge;


Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

13



this
.
labelEdge

= labelEdge;


this
.
conservativeTrigger

= conserv
ativeTrigger;


DOM.
sinkEvents
(getElement(), Event.
ONMOUSEOVER
);


DOM.
setEventListener
(getElement(),
this
);

}


...


/
**

Re
définition de la méthode qui capte les événements venant du
navigateur

afin de réagir si la souris passe au dessus de la widget :
on
me
t

à jour

la structure de capture des événements souris de la
widget DOJO, si on

s'
aperçoit

que la widget à été déplacée.

@param

event événement provenant du navigateur
.

*/

public

void

onBrowserEvent(Event event) {


if

(DOM.
eventGetType
(event) == Event.
ONM
OUSEOVER
) {


if

(getAbsoluteLeft() !=
x

|| getAbsoluteTop() !=
y
) {



x

= getAbsoluteLeft();



y

= getAbsoluteTop();



resetLocation(getDojoWidget());


}


}


// Par défaut la mé
thode onBrowserEvent ne fait rien


super
.onBrowserEvent(event);


}


/**


Cré
e

la widget Dojo FishEyeList


*/

public

void

createDojoWidget()
throws

Exception {


this
.
dojoWidget

= createFishEye(

itemWidth
,

itemHeight
,

itemMaxWidth
,


itemMaxHeight
,

orientation
,

effectUnits
,

itemPadding
,


attachEdge
,

labelEdge
,

enableCrappySv
gSupport
,


conservativeTrigger
);

}


/**

Ajoute une icone à la barre d'icones
.

@param

icon

URL de l'image qui représente l'icone à l'écran, l'icone
doit

ê
tre unique pour la barre d'icones
.

@param

caption

titre associé à cet
te

icône.

@param

command

commande
qui sera exécutée lorsque l'icone est
sélectionné

(
peut être null)

*/

p
ublic

void

add(String icon, String caption, Command command) {


Item item =
new

Item(icon, caption, command);


items
.add(item);


// Si la widget est rattachée au navigateur.


// On
construit le nouvel Item
.


if

(isAttached()) {


Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

14



buildItem(item);


}

}



/**


Construit tous les items du FishEyeList


*/

private

void

buildItems() {


for

(
int

i = 0; i <
items
.size(); i++) {




Item item = (Item)
items
.get(i);



buildItem(it
em);


}

}


/**

Construit un FishEyeItem et le rajoute à la liste.

@param

item

Item à

rajouter

*/

void

buildItem(Item item) {


JavaScriptObject child = createFishEyeItem(getDojoWidget(),
item.
icon
,item.
caption
);


addChildWidget(getDojoWidget(), child);


ite
m.
child

= child;

}



/**

Retire un Item du FishEye (Dojo) et detruit l'item.

@param

item Item à retirer

*/

private

void

removeItem(Item item) {


removeChildWidget(getDojoWidget(), item.
child
);


DojoController.
getInstance
().destroy(item.
child
);


item.
chi
ld

=
null
;

}


/
**

Supprime tous item "Dojo" rajout
és

à

la barre d'icone.

Ne pas utiliser cette
méthode
, elle est
appelé
e

par un
contrôleur

quand la widget GWT est
détachée

du navigateur.

*/

public

void

doBeforeDestruction() {


removeItems();
// dé
truit t
ous les items.

}



...



private

native

JavaScriptObject createFishEye(

int

itemWidth,


int

i
temHeight,

int

itemMaxWidth,

int

i
temMaxHeight,

String orientation,

int

effectUnits,

int

itemPadding,


String attachEdge,

String labelEdge,


boolean

enable
CrappySvgSupport,


Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

15


boolean

c
onservativeTrigger)

/*
-
{



var fisheye = $wnd.dojo.widget.createWidget(


"FisheyeList",



{



itemWidth: itemWidth,



itemHeight: itemHeight,



itemMaxWidth: itemMaxWidth,



itemMaxHeight:

itemMaxHeight,



orientation: orient
ation,



effectUnits: effectUnits,



itemPadding: itemPadding,



attachEdge: attachEdge,



labelEdge: labelEdge,



enableCrappySvgSupport: enableCrappySvgSupport,



conservativeTrigger: conservativeTrigger



}



);



return fisheye;



}
-
*/
;


/
**


* Ajoute
une widget DOJO (matérialisant une icone) à la liste des
widgets

DOJO filles de la widget DOJO matérialisant la barre
d'icones.

@param

panel

widget DOJO matérialisant la barre d'icones

@param

child widget DOJO matérialisant une icone à insérer

*/

p
rivate

n
ative

void

addChildWidget(JavaScriptObject panel,


JavaScriptObject child)

/*
-
{


panel.addChild(child);


}
-
*/
;


/
**

Enlève une widget DOJO (matérialisant une icone) de la liste des
widgets

DOJO filles de la widget DOJO matérialisant la barre
d'ic
ones.


@param

panel

widget DOJO matérialisant la barre d'icones

@param

child

widget DOJO matérialisant une icone à retirer


*/

private

native

void

removeChildWidget(JavaScriptObject panel,






JavaScriptObject child)

/*
-
{



panel.remove
Child(child);



panel._initializePositioning();


}
-
*/
;


/**


Construit la widget DOJO (pas GWT !) qui matérialise une icone.


Attention, la méthode n'insère pas cette icone dans la barre
d'icones.

Cette méthode arme l'appel à la méthode réflèxe JAVA
(dispa
tchClick) qui

doit être invoquée lorsque l'icone est
sélectionnée.

@param

dojo
Widget
Widget GWT (pas DOJO !) représentant la barre
d'icone (c.a.d.

this). Cette information est nécessaire pour armer la
méthode

réflèxe.

@
param

icon


URL de l'image qui représ
ente l'icone à l'écran

@param

caption

titre associé à cet icone


Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

16


@return

la widget DOJO construite par cette méthode


*/

private

native

JavaScriptObject createFishEyeItem(


JavaScriptObject
dojo
Widget,


String icon,


String caption)


/*
-
{


var c
hild = $wnd.dojo.widget.createWidget(



"TatamiFisheyeItem",


{


parent: dojo
Widget,



iconSrc: icon,



caption: caption



}


);


return child;

}
-
*/
;




/**

Construit

les items "Dojo"

rajoutés à la barre d'icô
ne
s
, lor
s
que la
widget GWT est

rattachée au navigateur. Cette méthode est appelé
e

par
un
contrôleur
. Il ne faut pas l'appeler explicitement
.

*/

public

void

doAfterCreation() {


buildItems();

}



/**

Renvoie le nom de la widget Dojo.

@return

"FishEyeList"


*/

public

String getDojoName(
) {


return

"FisheyeList"
;

}


/**


finit un item p
our la barre d'icone. L'objet dé
fini est une widget
Dojo

nommé
e : TatamiFisheyeItem. Capte les
é
vènements de click souris
sur les

icô
nes.

*/

public

void

onDojoLoad() {


defineTatamiItem();

}


/**

Demande
à DOJO de charger les scripts JavaScript nécessaires à DOJO
pour construire une barre d'icones grossissantes. Cette méthode ne
doit pas être appelée si ces scripts ont été déjà chargés.

*/

private

native

void

defineTatamiItem()

/*
-
{


$
wnd.dojo.widget.defin
eWidget("dojo.widget.TatamiFisheyeItem",

$wnd.dojo.widget.FisheyeListItem, {



onClick:function (e) {

t
his.parent.gwtWidget.@com.objetdirect.tatami.client.FishEye::dispatc
hClick(Ljava/lang/String;)(this.iconSrc);


}

});




}
-
*/
;


Outils pour faciliter le développement de nouveaux
composants Tatami


Réf :

Version 1.
0

17



/**

Méthod
e invoquée par JavaS
cript lorsqu'une icone à été cliquée. Cette

métho
de invoque l'objet commande idoine.

@param

icon nom de l'icone cliquée

*
/

protected

void

dispatchClick(String icon) {


for

(
int

i = 0; i <
items
.size(); i++) {


Item item = (Item)
items
.
get(i);



if

(item.
icon
.equals(icon)) {





if

(item.
command

!=
null
) {





item.
command
.execute();




}



}



}


}


...

}
//fin de la classe