Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues.observation.filtres;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.observation.ObservationMediateur;

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.widgets.Button;

import com.gwtext.client.widgets.Panel;

import com.gwtext.client.widgets.event.ButtonListenerAdapter;

import com.gwtext.client.widgets.form.TextField;

import com.gwtext.client.widgets.layout.VerticalLayout;

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;

public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable {

		/**

		 * Le médiateur associé à la vue

		 */

		private ObservationMediateur oMediateur = null;

		/**

		 * Le treepanel qui affiche l'arbre

		 */

		private static 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;

		/**

		 * Une string permettant connaitre les mots clés cochés en cours séparés par

		 * des virgules

		 */

		private String motsClesEnCours = "";

		/**

		 * 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;

		/**

		 * Constructeur sans paramètre (privé car interdit d'utilisation)

		 */

		@SuppressWarnings("unused")

		private ArbreMotsClesObservationVue() {

			super();

		}

		/**

		 * Constructeur avec paramètre

		 *

		 * @param im

		 *            le médiateur à associer

		 */

		public ArbreMotsClesObservationVue(ObservationMediateur om) {

			// on crée le panel

			super("Mots clés");

			this.setLayout(new VerticalLayout());

			oMediateur = om;

			// 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-obs");

			// on crée une racine pour l'arbre

			TreeNode root = new TreeNode("Tags");

			root.setId("racine_obs");

			String[] usObject = { "Mots clés", "racine" };

			root.setUserObject(usObject);

			root.setExpandable(true);

			arbreMotsCles.setRootNode(root);

			arbreMotsCles.setRootVisible(true);

			arbreMotsCles.setBorder(false);

		//	arbreMotsCles.setWidth(500);

			arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {

				public void onClick(Node node, EventObject e) {

					if(!arbreCharge) {

						expand();

					}

				}

				public void onExpand(Node node) {

					if(!arbreCharge) {

						obtenirArbreMotsCles();

						arbreCharge = true;

					}

				}

			});

			// on crée l'éditeur pour l'arbre

			tfEdit = new TextField();

			te = new TreeEditor(arbreMotsCles, tfEdit);

			valider = new Button("Appliquer");

			arbreMotsCles.add(te);

			// on met en forme le layout

			this.add(arbreMotsCles);

			this.add(valider);

			this.setBorder(false);

			this.setCollapsible(true);

			this.setTitleCollapse(true);

			// on ajoute les listeners

			ajouterListeners();

		}

		/**

		 * Acesseur pour le médiateur

		 *

		 * @return le médiateur associé à la vue

		 */

		private ObservationMediateur getOMediateur() {

			return oMediateur;

		}

		/**

		 * 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;

		}

		/**

		 * Ajoute les listeners nécessaires pour la gestion des évènements

		 */

		private void ajouterListeners() {

			arbreMotsCles.addListener(new TreePanelListenerAdapter() {

				// gestion du clic sur un noeud

				public void onClick(TreeNode node, EventObject e) {

					e.stopEvent();

					gererClicNoeud(node);

				}

				// gestion du clic droit sur un noeud

				public void onContextMenu(TreeNode node, EventObject e) {

					e.stopEvent();

					getOMediateur().montrerContextMenuArbre(node, e, getTe());

				}

				// gestion du double clic sur un noeud

				public void onDblClick(TreeNode node, EventObject e) {

					modifNoeud = true;

					if (!node.getId().equals("racine_obs")) {

						te.startEdit(node);

					}

				}

				// gestion de la modification du texte d'un noeud

				public void onTextChange(TreeNode node, String text, String oldText) {

					// 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 notifie le médiateur de l'ajout et on lui passe

						// l'arbre

						getOMediateur().ajouterMotCleDansArbre(nd,

								getArbreMotsCles().getTree());

						// et considère l'ajout achevé

						ajoutNoeud = false;

					}

					// si c'est noeud déjà existant

					else {

						if (modifNoeud) {

							// on notifie le médiateur de la modification et on lui

							// passe l'arbre

							getOMediateur().modifierMotCleDansArbre(nd,

									getArbreMotsCles().getTree());

							// et on considère la modification achevée

							modifNoeud = false;

						}

					}

				}

				// gestion du déplacement d'un noeud

				public void onMoveNode(Tree tree, TreeNode node,

						TreeNode oldParent, TreeNode newParent, int index) {

					// on notifie le médiateur et on lui passe l'arbre

					getOMediateur().deplacerMotCleDansArbre(node,

							getArbreMotsCles().getTree());

				}

			});

			// gestion de la validation

			valider.addListener(new ButtonListenerAdapter() {

				// lors du clic

				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

								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();

									getOMediateur().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

					getOMediateur().mettreAjourMotsCles(motsClesEnCours,

							arbreMotsCles.getTree());

				}

			});

		}

		/**

		 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés

		 */

		public void obtenirArbreMotsCles() {

			getOMediateur().obtenirArbreMotsCles(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())) {

				// 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

				getOMediateur()

						.supprimerMotCleDansArbre(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) {

			// on met l'ajout du noeud à vrai

			ajoutNoeud = true;

			// on crée un nouveau noeud vide

			TreeNode nd = new TreeNode("");

			nd.setCls("x-view-treenode-keyword");

			nd.setChecked(true);

			// on associe un objet au noeud qui contient des infos

			String[] usObject = new String[2];

			// l'objet contient le nom du noeud

			usObject[0] = "";

			usObject[1] = genererIdMotCle(nd);

			nd.setId(usObject[1]);

			nd.setUserObject(usObject);

			// l'identifiant d'un noeud c'est son hashcode

			// l'objet associé au noeud contient aussi son identifiant

			// on le concatène au parent et on étend ses enfants

			parent.appendChild(nd);

			parent.expand();

			// enfin on place le curseur et on fait apparaitre le champ d'édition

			// pour que l'utilisateur nomme son mot clé

			te.startEdit(nd);

		}

		/**

		 * 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

							public boolean execute(Node node) {

								getArbreMotsCles().getNodeById(node.getId())

								.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

									String usObject[] = (String[]) node

											.getUserObject();

									String nodeId = usObject[1];

									if (nodeId.equals(motsClesIds[i])) {

											getArbreMotsCles().getNodeById(nodeId+"_obs")

													.getUI().toggleCheck(true);

											return true;

									}

								}

								// et on passe au suivant

								return true;

							}

						});

			}

			else {

				motsClesEnAttente = motsClesIds ;

			}

		}

		/**

		 * 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

		 */

		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;

				}

				// s'il y a des mots clés en attente (lors du premier rendering)

				if (motsCleInitialises == false && motsClesEnAttente != null) {

					// on les coche

					// cocherMotsCles(motsClesEnAttente) ;

					motsCleInitialises = true;

				}

				if(motsClesEnAttente.length > 0) {

							cocherMotsCles(motsClesEnAttente);

				}

			}

			// Si on reçoit un tableau de String (cas ou l'on séléectionne une

			// nouvelle image)

			if (nouvelleDonnees instanceof String[]) {

				// et que l'arbre est instancié

				if (arbreCharge) {

					// 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

					String[] motsClesIds = (String[]) nouvelleDonnees;

					cocherMotsCles(motsClesIds);

				}

				// si l'arbre n'est pas encore instancié on met les mots clés en

				// attente

				else {

					motsClesEnAttente = (String[]) nouvelleDonnees;

				}

			}

		}

		private String genererIdMotCle(TreeNode nd) {

			return "" + (nd.hashCode() + (Math.random() * 10000));

		}

		/**

		 * 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] +"_obs");

					child.setChecked(false);

					child.setUserObject(usObj);

					ndPereCopie.appendChild(child);

					if (!ndNodeFils[i].isLeaf()) {

						copierFilsNoeud(ndNodeFils[i], child);

					}

				}

			}

		}

}