WebSVN – eFlore/Applications.cel – Diff – /branches/v2.3-faux/src/org/tela_botanica/client/vues/image/FenetreGestionMotsCles.java


package org.tela_botanica.client.vues.image;
 
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
 
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragDrop;
 
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
 
 
 
import com.gwtext.client.widgets.event.WindowListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.layout.HorizontalLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
 
 
import com.gwtext.client.widgets.tree.MultiSelectionModel;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
 
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
/**
 * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
 * clés cochables et réorganisables à volonté
 * 
 * @author aurelien
 * 
 */
public abstract class FenetreGestionMotsCles extends com.gwtext.client.widgets.Window implements Rafraichissable {
 
	/**
	 * Le treepanel qui affiche l'arbre
	 */
	private TreePanel arbreMotsCles = null;
	/**
	 * L'éditeur qui permet de modifier les mots clés dans l'arbre
	 */
	private TreeEditor te = null;
	/**
	 * Le textfield associé à l'éditeur
	 */
	private TextField tfEdit = null;
	/**
	 * Bouton de validation
	 */
	private Button valider = null;
	
	/**
	 * Bouton d'annulation
	 */
	private Button annuler = null;
	
	/**
	 * Bouton d'ajout de tag
	 */
	private ToolbarButton ajouterTag = null;
	
	/**
	 * Bouton de suppression de tag
	 */
	private ToolbarButton supprimerTag = null;
	
	/**
	 * Bouton de renommage de tag
	 */
	private ToolbarButton renommerTag = null;
	
	/**
	 * Une string permettant connaitre les mots clés cochés en cours séparés par
	 * des virgules
	 */
	private String motsClesEnCours = "";
	
	private String[] tableauMotsClesEnCours = new String[0];
	/**
	 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
	 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
	 * du conteneur n'ai été effectué)
	 */
	private String[] motsClesEnAttente = new String[0];
	/**
	 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
	 * noeud
	 */
	private boolean ajoutNoeud = false;
	/**
	 * Booléen d'évènement qui sert à savoir si on est en train de modifier un
	 * noeud
	 */
	private boolean modifNoeud = false;
	/**
	 * Booléen d'instanciation du conteneur
	 */
	private boolean arbreCharge = false;
	/**
	 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
	 */
	private boolean motsCleInitialises;
	
	/**
	 * panneau intermédiaire contenant l'arbre
	 */
	private Panel panelIntermediaire;
	private String cheminTemporaireAjout;
 
	/**
	 * Constructeur avec paramètre
	 * 
	 * @param im
	 *            le médiateur à associer
	 */
	public FenetreGestionMotsCles() {
				
		// on crée le panel
		setTitle("Mots clés");
		this.setLayoutData(new RowLayout());
 
		// on crée le conteneur de l'arbre
		arbreMotsCles = new TreePanel();
		// on permet le drag and drop dans l'arbre
		arbreMotsCles.setEnableDD(true);
		arbreMotsCles.setId("x-view-tree-keyword-imgs");
 
		arbreMotsCles.setSelectionModel(new MultiSelectionModel());
 
		// on crée une racine pour l'arbre
		TreeNode root = new TreeNode("Tags");
		root.setId("racine");
		String[] usObject = { "Mots clés", "racine" };
		root.setExpandable(true);
		arbreMotsCles.setRootNode(root);
		arbreMotsCles.setRootVisible(true);
		arbreMotsCles.setBorder(false);
		arbreMotsCles.setWidth(500);
		
		root.setUserObject(usObject);
		
		arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
 
			@Override
			public void onClick(Node node, EventObject e) {
				if(!arbreCharge) {
					expand();
				}
			}
 
			@Override
			public void onExpand(Node node) {
				if(!arbreCharge) {
					obtenirArbreMotsCles();
					arbreCharge = true;
				}
			}
 
		});
 
		// on crée l'éditeur pour l'arbre
		tfEdit = new TextField();
		tfEdit.setAutoWidth(true);
		te = new TreeEditor(arbreMotsCles, tfEdit);
		valider = new Button("Appliquer");
		annuler = new Button("Annuler");
		arbreMotsCles.add(te);
		
		panelIntermediaire = new Panel();
		panelIntermediaire.setLayout(new FitLayout());
		panelIntermediaire.setAutoScroll(true);
		panelIntermediaire.setWidth("100%");
		arbreMotsCles.setWidth("100%");
		arbreMotsCles.setHeight("100%");
		
		Panel panelBoutons = new Panel();
		panelBoutons.setLayout(new HorizontalLayout(130));
		panelBoutons.setWidth("100%");
 
		// on met en forme le layout
		panelIntermediaire.add(arbreMotsCles);
		panelBoutons.add(annuler);
		panelBoutons.add(valider);
		
		this.add(panelIntermediaire, new RowLayoutData());
		this.add(panelBoutons, new RowLayoutData(30));
		arbreMotsCles.setHeight("100%");
		arbreMotsCles.setAutoScroll(true);
		
		Toolbar barreBouton = new Toolbar();
		ajouterTag = new ToolbarButton("Nouveau Tag");
		ajouterTag.setIcon("mot_cle_ajouter.png");
		renommerTag = new ToolbarButton("Renommer");
		renommerTag.setIcon("mot_cle_editer.png");
		renommerTag.disable();
		supprimerTag = new ToolbarButton("Supprimer");
		supprimerTag.setIcon("mot_cle_supprimer.png");
		supprimerTag.disable();
		barreBouton.addButton(ajouterTag);
		barreBouton.addSeparator();
		barreBouton.addButton(renommerTag);
		barreBouton.addSeparator();
		barreBouton.addButton(supprimerTag);
		this.setTopToolbar(barreBouton);
		
		setCloseAction(com.gwtext.client.widgets.Window.HIDE);		
		// on ajoute les listeners
		ajouterListeners();
 
	}
 
 
	/**
	 * Acesseur pour l'arbre des mots clés
	 * 
	 * @return le panel contenant l'arbre
	 */
	public TreePanel getArbreMotsCles() {
		return arbreMotsCles;
	}
 
	/**
	 * Accesseur pour l'éditeur
	 * 
	 * @return l'éditeur associé à l'arbre
	 */
	public TreeEditor getTe() {
		return te;
	}
 
	/**
	 * Acesseur pour le TextField associé à l'éditeur
	 * 
	 * @return le champ texte associé à l'éditeur
	 */
	public TextField getTfEdit() {
		return tfEdit;
	}
	
	protected abstract void surAffichageMenuContextuel(TreeNode node, EventObject e, TreeEditor te);
	protected abstract void surAjoutMotCle(TreeNode node, Tree arbre);
	protected abstract void surSuppressionMotCle(TreeNode node, Tree arbre);
	protected abstract void surDeplacementMotCle(TreeNode node, Tree arbre);
	protected abstract void surChangementTexte(TreeNode node, Tree arbre);
	protected abstract void surClicValider(String chaineMotsCles, Tree arbre);
	protected abstract void demanderArbreMotsCles(Rafraichissable r);
	protected abstract void surRetourWebService(Tree arbre);
 
	/**
	 * Ajoute les listeners nécessaires pour la gestion des évènements
	 */
	private void ajouterListeners() {
		
		this.addListener(new WindowListenerAdapter() {			
			@Override
			public void onResize(com.gwtext.client.widgets.Window source, int width,
					int height) {
					panelIntermediaire.setHeight(getHeight() - 80);		
			}
		});
						
		arbreMotsCles.addListener(new TreePanelListenerAdapter() {
			@Override
			public void onAfterLayout(Container self) {
				panelIntermediaire.setHeight(getHeight() - 80);		
			}
			
			@Override
			public void onExpandNode(TreeNode node) {		
				cocherMotsCles(tableauMotsClesEnCours);
			}
 
			// gestion du clic sur un noeud
			@Override
			public void onClick(TreeNode node, EventObject e) {
 
				e.stopEvent();
				gererClicNoeud(node);
				if(!node.equals(arbreMotsCles.getRootNode())) {
					supprimerTag.enable();
					renommerTag.enable();
				}
			}
 
			// gestion du clic droit sur un noeud
			@Override
			public void onContextMenu(TreeNode node, EventObject e) {
 
				e.stopEvent();
				surAffichageMenuContextuel(node, e, getTe());
				if(!node.equals(arbreMotsCles.getRootNode())) {
					supprimerTag.enable();
					renommerTag.enable();
				}
			}
 
			// gestion de la modification du texte d'un noeud
			@Override
			public void onTextChange(TreeNode node, String text, String oldText) {
				
				if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) {
					te.startEdit(node);
					Window.alert("Un mot clé ne peut pas être vide ou contenir les caractères suivants : "+MotsClesUtilitaire.getChaineCaracteresInterdits());
					return;
				}
				
				if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
					te.startEdit(node);
					Window.alert("Un mot clé de même nom existe déjà à cette position");
					return;
				}
 
				if(node.equals(arbreMotsCles.getRootNode())) {
					return;
				}
 
				// on récupère les informations associées au noeud
				TreeNode nd = node;
				String[] usObject = new String[2];
				usObject[0] = text;
				usObject[1] = ((String[]) nd.getUserObject())[1];
				nd.setUserObject(usObject);
 
				// si c'est un nouveau noeud
				if (ajoutNoeud) {
					// on considère l'ajout achevé
					ajoutNoeud = false;
					// et on notifie le médiateur de l'ajout et on lui passe
					// l'arbre
					surAjoutMotCle(nd, getArbreMotsCles().getTree());
					arbreMotsCles.disable();
				}
				// si c'est noeud déjà existant
				else {
					// on considère la modification achevée
					modifNoeud = false;
					
					if(!text.equals(oldText)) {
						// et on notifie le médiateur de la modification et on lui
						// passe l'arbre
						surChangementTexte(nd, getArbreMotsCles().getTree());
						arbreMotsCles.disable();
					}
				}
			}
			
			@Override
			public boolean doBeforeMoveNode(Tree tree, TreeNode node,
					TreeNode oldParent, TreeNode newParent, int index) {
				boolean ok = true;
				if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
					ok = false;
					Window.alert("Un mot clé de même nom existe déjà à cette position");
				}
				return ok;
			}
			
			@Override
			public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
					DragData dragData, String point, DragDrop source,
					TreeNode dropNode) {
				return MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
			}
 
			// gestion du déplacement d'un noeud
			@Override
			public void onMoveNode(Tree tree, TreeNode node,
					TreeNode oldParent, TreeNode newParent, int index) {
				// on notifie le médiateur et on lui passe l'arbre
				surDeplacementMotCle(node, getArbreMotsCles().getTree());
			}
 
		});
 
		// gestion de la validation
		valider.addListener(new ButtonListenerAdapter() {
 
			// lors du clic
			@Override
			public void onClick(Button button, EventObject e) {
 
				// on vide les mots clés en cours
				motsClesEnCours = "";
				// pour chaque noeud à partir de la racine
				getArbreMotsCles().getRootNode().cascade(
						new NodeTraversalCallback() {
 
							// on éxécute une fonction
							@Override
							public boolean execute(Node node) {
 
								// on récupère le mot clé associé au noeud et
								// ses infos
								TreeNode tn = getArbreMotsCles().getNodeById(
										node.getId());
 
								String[] usObject = (String[]) tn
										.getUserObject();
								/*getIMediateur().mettreAjourMotsClesId(
										usObject[0], usObject[1]);*/
 
								if (tn.getUI().isChecked()) {
									// et les concatène à la string des mots
									// clés en cours
									motsClesEnCours += usObject[1] + ",";
								}
 
								return true;
							}
 
						});
 
				// enfin on notifie le médiateur et on lui passe l'arbre et la
				// liste des mots clés ainsi obtenue
				surClicValider(motsClesEnCours, arbreMotsCles.getTree());
			}
		});
		
		annuler.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button button, EventObject e) {
				hide();
			}
		});
		
		renommerTag.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button button, EventObject e) {
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
				TreeNode noeudRenommage;
				if(noeuds.length > 0) {
					noeudRenommage = noeuds[noeuds.length - 1];
				} else {
					noeudRenommage = arbreMotsCles.getRootNode();
				}
				renommerNoeud(noeudRenommage);
			}
		});
		
		ajouterTag.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button button, EventObject e) {
				
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
				TreeNode noeudAjout;
				if(noeuds.length > 0) {
					noeudAjout = noeuds[noeuds.length - 1];
				} else {
					noeudAjout = arbreMotsCles.getRootNode();
				}
 
				ajouterNoeud(noeudAjout);
			}
		});
		
		supprimerTag.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button button, EventObject e) {
				
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
				for (int i = 0; i < noeuds.length; i++) {
					supprimerNoeud(noeuds[i]);
				}
			}
		});
	}
 
	/**
	 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
	 */
	public void obtenirArbreMotsCles() {
		demanderArbreMotsCles(this);
	}
 
	/**
	 * Supprime un noeud de l'arbre
	 * 
	 * @param n
	 *            le noeud à supprimer
	 */
	public void supprimerNoeud(TreeNode n) {
		// si ça n'est pas la racine (qu'on ne peut pas supprimer)
		if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
			if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) {
				// on détache le noeud et on le détruit
				n.getParentNode().removeChild(n);
				n.destroy();
				// puis on en notifie le médiateur en lui passant le noeud supprimé
				// et l'arbre
				surSuppressionMotCle(n, arbreMotsCles.getTree());
			}
		} else {
			// si l'utilisateur tente de supprimer la racine, on l'avertit de
			// son erreur
			Window.alert("Impossible de supprimer la racine de l'arbre");
		}
	}
 
	/**
	 * Ajoute un noeud dans l'arbre au parent donné
	 * 
	 * @param parent
	 *            le futur parent du noeud à ajouter
	 */
	public void ajouterNoeud(TreeNode parent) {
		ajoutNoeud = true;		
		TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, true);
		// on le concatène au parent et on étend ses enfants
		parent.appendChild(nd);
		parent.expand();
		cheminTemporaireAjout = nd.getId();
		te.startEdit(nd);
	}
 
	/**
	 * Renomme le noeud passé en paramètre
	 */
	public void renommerNoeud(TreeNode n) {
		// TODO Auto-generated method stub
		te.startEdit(n);
	}
 
	/**
	 * Coche le noeud s'il est décoché, le décoche sinon
	 * 
	 * @param node
	 */
	public void gererClicNoeud(TreeNode node) {
		if (node.getUI().isChecked()) {
			node.getUI().toggleCheck(false);
		} else {
			node.getUI().toggleCheck(true);
		}
	}
 
	/**
	 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
	 * clés à cocher
	 * 
	 * @param motsClesIds
	 *            un tableau contenant les identifiants des mots clés à cocher
	 */
	public void cocherMotsCles(final String[] motsClesIds) {
		if (getArbreMotsCles() != null
				&& getArbreMotsCles().getRootNode() != null) {
			// à partir de la racine
			getArbreMotsCles().getRootNode().cascade(
				new NodeTraversalCallback() {
 
					// pour chaque noeud
					@Override
					public boolean execute(Node node) {
 
						String usObject[] = (String[]) node
								.getUserObject();
						String nodeId = usObject[1];
						
						TreeNode tn = getArbreMotsCles().getNodeById(node.getId());
						if(tn != null) {
							tn.getUI().toggleCheck(false);
							// on parcourt le tableau des mots clés
							for (int i = 0; i < motsClesIds.length; i++) {
								// si le mot clé fait partie des id à cocher on
								// le coche
 
								if (nodeId.equals(motsClesIds[i])) {
									tn.getUI().toggleCheck(true);
									tn.ensureVisible();
									return true;
								}
							}
							// et on passe au suivant
						}
						
						return true;
					}
 
				});
		}
	}
 
	/**
	 * Méthode héritée de l'interface rafraichissable
	 * 
	 * @param nouvelleDonnees
	 *            les nouvelles données pour l'objet
	 * @param repandreRafraichissement
	 *            booleen qui dit si on doit répandre l'évenement
	 */
	@Override
	public void rafraichir(Object nouvelleDonnees,
			boolean repandreRafraichissement) {
		
		if(nouvelleDonnees instanceof Tree) {
 
			Tree nouvelArbre = (Tree)nouvelleDonnees ;
 
			// on prend sa racine et on l'attache à l'arbre des mots clés
			Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
			for (int i = 0; i < rootChild.length; i++) {
				
				rootChild[i].remove();
			}
			
			copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
 
			// si l'arbre n'était pas encore considéré comme instancié
			if (!arbreCharge) {
				// on signale que oui
				arbreCharge = true;
			}
		}
 
		// Si on reçoit un tableau de String (cas ou l'on séléectionne une
		// nouvelle image)
		if (nouvelleDonnees instanceof String[]) {
 
			// le tableau de String contient les id des mots clés associés à
			// l'image
			// on coche les mots clés contenu dans le tableau
			tableauMotsClesEnCours = (String[]) nouvelleDonnees;
			if(this.isVisible()) {
				cocherMotsCles(tableauMotsClesEnCours);
			} else {
				addListener(new WindowListenerAdapter() {
					
					@Override
					public void onShow(Component component) {
						cocherMotsCles(tableauMotsClesEnCours);
					}
				});
			}
		}
		
		// reception d'un nouvel identifiant de mot clé
		if(nouvelleDonnees instanceof Integer) {
			if(cheminTemporaireAjout != null) {
				String id = ((Integer)(nouvelleDonnees)).toString();
				TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
				String[] userObj = {noeudEnAjout.getText(), id};
				noeudEnAjout.setUserObject(userObj);
				cheminTemporaireAjout = null;
			}
		}
		surRetourWebService(arbreMotsCles.getTree());
		arbreMotsCles.enable();
	}
	
	/**
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
	 * 
	 * @param ndPereOriginal
	 *            le père des noeuds de l'arbre original
	 * @param ndPereCopie
	 *            le père qui va recevoir les copies
	 */
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
		if (ndPereCopie != null && ndPereOriginal != null) {
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
			
			for (int i = 0; i < ndNodeFils.length; i++) {
 
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
				TreeNode child = new TreeNode(usObj[0]);
				child.setId(usObj[1]);
				child.setChecked(false);
				child.setUserObject(usObj);
				ndPereCopie.appendChild(child);
 
				if (!ndNodeFils[i].isLeaf()) {
					copierFilsNoeud(ndNodeFils[i], child);
				}
 
			}
		}
	}
 
 
	public void activerBoutonValider(boolean activer) {
		valider.setVisible(activer);
	}
}
 

Subversion Repositories eFlore/Applications.cel

(root)/branches/v2.3-faux/src/org/tela_botanica/client/vues/image/FenetreGestionMotsCles.java – Rev 2221 → 2230

Rev 2221		Rev 2230
1	`package org.tela_botanica.client.vues.image;`	1	`package org.tela_botanica.client.vues.image;`
2		-
3	`import org.tela_botanica.client.cel2;`	2
4	`import org.tela_botanica.client.interfaces.Rafraichissable;`	3	`import org.tela_botanica.client.interfaces.Rafraichissable;`
5	`import org.tela_botanica.client.util.MotsClesUtilitaire;`	4	`import org.tela_botanica.client.util.MotsClesUtilitaire;`
6		-
7	`import com.google.gwt.core.client.JavaScriptObject;`	5
8	`import com.google.gwt.user.client.Window;`	6	`import com.google.gwt.user.client.Window;`
9	`import com.gwtext.client.core.EventObject;`	7	`import com.gwtext.client.core.EventObject;`
10	`import com.gwtext.client.data.Node;`	8	`import com.gwtext.client.data.Node;`
11	`import com.gwtext.client.data.NodeTraversalCallback;`	9	`import com.gwtext.client.data.NodeTraversalCallback;`
12	`import com.gwtext.client.data.Tree;`	10	`import com.gwtext.client.data.Tree;`
13	`import com.gwtext.client.dd.DD;`	-
14	`import com.gwtext.client.dd.DragData;`	11	`import com.gwtext.client.dd.DragData;`
15	`import com.gwtext.client.dd.DragDrop;`	12	`import com.gwtext.client.dd.DragDrop;`
16	`import com.gwtext.client.widgets.BoxComponent;`	-
17	`import com.gwtext.client.widgets.Button;`	13	`import com.gwtext.client.widgets.Button;`
18	`import com.gwtext.client.widgets.Component;`	14	`import com.gwtext.client.widgets.Component;`
19	`import com.gwtext.client.widgets.Container;`	15	`import com.gwtext.client.widgets.Container;`
20	`import com.gwtext.client.widgets.Panel;`	16	`import com.gwtext.client.widgets.Panel;`
21	`import com.gwtext.client.widgets.Toolbar;`	17	`import com.gwtext.client.widgets.Toolbar;`
22	`import com.gwtext.client.widgets.ToolbarButton;`	18	`import com.gwtext.client.widgets.ToolbarButton;`
23	`import com.gwtext.client.widgets.event.ButtonListenerAdapter;`	19	`import com.gwtext.client.widgets.event.ButtonListenerAdapter;`
24	`import com.gwtext.client.widgets.event.ContainerListener;`	-
25	`import com.gwtext.client.widgets.event.PanelListener;`	-
26	`import com.gwtext.client.widgets.event.WindowListener;`	-
27	`import com.gwtext.client.widgets.event.WindowListenerAdapter;`	20	`import com.gwtext.client.widgets.event.WindowListenerAdapter;`
28	`import com.gwtext.client.widgets.form.TextField;`	21	`import com.gwtext.client.widgets.form.TextField;`
29	`import com.gwtext.client.widgets.layout.FitLayout;`	22	`import com.gwtext.client.widgets.layout.FitLayout;`
30	`import com.gwtext.client.widgets.layout.HorizontalLayout;`	23	`import com.gwtext.client.widgets.layout.HorizontalLayout;`
31	`import com.gwtext.client.widgets.layout.RowLayout;`	24	`import com.gwtext.client.widgets.layout.RowLayout;`
32	`import com.gwtext.client.widgets.layout.RowLayoutData;`	25	`import com.gwtext.client.widgets.layout.RowLayoutData;`
33	`import com.gwtext.client.widgets.layout.VerticalLayout;`	-
34	`import com.gwtext.client.widgets.tree.DropNodeCallback;`	-
35	`import com.gwtext.client.widgets.tree.MultiSelectionModel;`	26	`import com.gwtext.client.widgets.tree.MultiSelectionModel;`
36	`import com.gwtext.client.widgets.tree.TreeEditor;`	27	`import com.gwtext.client.widgets.tree.TreeEditor;`
37	`import com.gwtext.client.widgets.tree.TreeNode;`	28	`import com.gwtext.client.widgets.tree.TreeNode;`
38	`import com.gwtext.client.widgets.tree.TreePanel;`	29	`import com.gwtext.client.widgets.tree.TreePanel;`
39	`import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;`	30	`import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;`
40	`import com.gwtext.client.widgets.tree.event.TreePanelListener;`	-