Subversion Repositories eFlore/Applications.cel

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

import org.tela_botanica.client.interfaces.Filtrable;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.observation.ObservationMediateur;

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.dd.DropTargetConfig;

import com.gwtext.client.widgets.Button;

import com.gwtext.client.widgets.Component;

import com.gwtext.client.widgets.Panel;

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

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

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

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

import com.gwtext.client.widgets.menu.BaseItem;

import com.gwtext.client.widgets.menu.Item;

import com.gwtext.client.widgets.menu.Menu;

import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;

import com.gwtext.client.widgets.tree.DropNodeCallback;

import com.gwtext.client.widgets.tree.MultiSelectionModel;

import com.gwtext.client.widgets.tree.TreeDragData;

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, Filtrable {

		/**

		 * 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 ajouterMotCle = 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 nécessaire pour l'affichage

		 *

		 */

		private boolean estInstancie = false;

		/**

		 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu

		 */

		private boolean motsCleInitialises;

		private Component livue = null;

		MultiSelectionModel msModel = null;

		private String cheminTemporaireAjout = null;

		public Rafraichissable thisRafraichissable;

		/**

		 * 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("Projets");

			this.setLayout(new VerticalLayout());

			oMediateur = om;

			setBorder(false);

			setCollapsible(true);

			setTitleCollapse(true);

			setAutoScroll(true);

			// on ajoute les listeners

			ajouterListenersPanel();

		}

		/**

		 * Ajoute les listeners pour le rendu du panel

		 */

		private void ajouterListenersPanel() {

			  this.addListener(new PanelListenerAdapter() {

				// on instancie réellement les composants au moment du rendu pour

				// accélérer l'affichage

				// et éviter des bugs

				@Override

				public void onRender(Component component) {

					livue = oMediateur.getListeObservation();

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

					msModel = new MultiSelectionModel();

					arbreMotsCles.setSelectionModel(msModel);

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

					TreeNode root = new TreeNode("Projets");

					root.setId("racine_obs");

					String[] usObject = { "Projets", "racine_obs" };

					root.setUserObject(usObject);

					root.setExpandable(true);

					arbreMotsCles.setRootNode(root);

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

					tfEdit = new TextField();

					te = new TreeEditor(arbreMotsCles, tfEdit);

					ajouterMotCle = new Button("Ajouter un projet");

					arbreMotsCles.add(te);

					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 interdit le drag and drop dans l'arbre

					arbreMotsCles.setRootVisible(true);

					arbreMotsCles.setBorder(false);

					// on met en forme le layout

					add(arbreMotsCles);

					add(ajouterMotCle);

					// enfin on considère le composant comme instancié

					estInstancie = true;

					configDragAndDrop();

					// on ajoute les listeners d'évenements

					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

				@Override

				public void onClick(TreeNode node, EventObject e) {

					e.stopEvent();

					boolean multi = false;

					if(e.hasModifier()) {

						multi = true;

					}

					gererClicNoeud(node,multi);

				}

				// gestion du clic droit sur un noeud

				@Override

				public void onContextMenu(TreeNode node, EventObject e) {

					e.stopEvent();

					montrerContextMenuArbre(node, e, getTe());

				}

				// gestion du double clic sur un noeud

				@Override

				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

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

					}

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

						ajouterMotCleDansArbreMediateur(nd);

					}

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

					else {

						if (modifNoeud) {

							modifierMotCleDansArbreMediateur(nd);

						}

					}

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

					boolean ok = true;

					if(dragData instanceof TreeDragData) {

						ok = MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());

					}

					return ok;

				}

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

					getOMediateur().deplacerMotCleDansArbre(node,

							getArbreMotsCles().getTree());

				}

				@Override

				public boolean doBeforeNodeDrop(TreePanel treePanel,

						TreeNode target, DragData dragData,

						String point, DragDrop source,

						TreeNode dropNode,

						DropNodeCallback dropNodeCallback) {

					if(dragData instanceof TreeDragData) {

						return true;

					}

					String idMotCle = ((String[])target.getUserObject())[1];

					if(oMediateur.gererDDObsSurMotCle(target, dragData)) {

						cocherMotCle(idMotCle);

						return true;

					}

					return false;

				}

				@Override

				public void onNodeDrop(TreePanel treePanel,

						TreeNode target, DragData dragData,

						String point, DragDrop source, TreeNode dropNode) {

				}

			});

			// gestion de la validation

			ajouterMotCle.addListener(new ButtonListenerAdapter() {

				// lors du clic

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

				}

			});

		}

		private void ajouterMotCleDansArbreMediateur(TreeNode nd) {

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

			// l'arbre

			getOMediateur().ajouterMotCleDansArbre(nd,

					getArbreMotsCles().getTree(), this);

			// et considère l'ajout achevé

			ajoutNoeud = false;

		}

		private void modifierMotCleDansArbreMediateur(TreeNode nd) {

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

		}

		/**

		 * Configure le drag 'n drop pour la liste

		 */

		private void configDragAndDrop()

		{

			// on fabrique la nouvelle configuration

			// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup

			arbreMotsCles.setDdGroup("ObsMotsClesGroup");

			//arbreMotsCles.setEnableDD(true);

			arbreMotsCles.setEnableDrag(true);

			arbreMotsCles.setEnableDrop(true);

			DropTargetConfig dtc = new DropTargetConfig();

			dtc.setdDdGroup("ObsMotsClesGroup");

		}

		/**

		 * 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())) {

				if(Window.confirm("Etes vous sur de vouloir supprimer ce projet ?")) {

					// 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(), this);

				}

			} 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) {

			if(parent == null) {

				parent = arbreMotsCles.getRootNode();

			}

			ajoutNoeud = true;

			TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, false);

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

			parent.appendChild(nd);

			parent.expand();

			cheminTemporaireAjout = nd.getId();

			te.startEdit(nd);

		}

		/**

		 * Fonction de gestion sur le clic sur le noeud

		 *

		 * @param node

		 */

		public void gererClicNoeud(TreeNode node, boolean multi) {

			if(!arbreCharge) {

				obtenirArbreMotsCles();

			} else {

				if(multi) {

				}

				((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi);

				oMediateur.obtenirNombreObservation();

			}

		}

		/**

		 * 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) {

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

										.getUI().getTextEl().addClassName("x-tree-node-text-kw");

											return true;

									}

								}

								if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) {

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

									.getUI().getTextEl().removeClassName("x-tree-node-text-kw");

								}

								// et on passe au suivant

								return true;

							}

						});

			}

			else {

				motsClesEnAttente = motsClesIds ;

			}

		}

		public void cocherMotCle(String motCleId) {

			getArbreMotsCles().getNodeById(motCleId)

			.getUI().getTextEl().addClassName("x-tree-node-text-kw");

		}

		public void initialiser() {

			arbreCharge = false ;

			motsClesEnCours = "";

			arbreMotsCles.collapseAll();

			// on vide l'ancien arbre

			Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();

			for (int i = 0; i < rootChild.length; i++) {

				rootChild[i].remove();

			}

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

				@Override

				public void onExpand(Node node) {

					if(!arbreCharge)

					{

						obtenirArbreMotsCles() ;

						arbreCharge = 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) {

			arbreMotsCles.enable();

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

				}

				MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode(), false);

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

			if (nouvelleDonnees instanceof String) {

				String chaineMc = (String)nouvelleDonnees;

				String[] motsClesIds = chaineMc.split(";");

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

					cocherMotsCles(motsClesIds);

				}

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

				// attente

				else {

					motsClesEnAttente = motsClesIds;

				}

			}

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

					noeudEnAjout.setId(id);

					cheminTemporaireAjout = null;

				}

			}

		}

		public void raz() {

			arbreCharge = false ;

			arbreMotsCles.collapseAll();

			arbreMotsCles.clear() ;

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

			TreeNode root = new TreeNode("Projets");

			root.setId("racine_obs");

			String[] usObject = { "Projets", "racine_obs" };

			root.setUserObject(usObject);

			root.setExpandable(true);

			arbreMotsCles.setRootNode(root);

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

				@Override

				public void onExpand(Node node) {

					if(!arbreCharge)

					{

						obtenirArbreMotsCles() ;

						arbreCharge = true ;

					}

				}

			}) ;

			motsClesEnCours  = "";

		}

		@Override

		public boolean renvoyerEtatFiltre() {

			// TODO Auto-generated method stub

			return false;

		}

		@Override

		public String renvoyerNomFiltre() {

			// TODO Auto-generated method stub

			return null;

		}

		@Override

		public String[] renvoyerValeursAFiltrer() {

			String val = "";

			TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();

			for(int i = 0; i< noeuds.length ; i++) {

				if(noeuds[i].getDepth() > 0) {

					val += ";"+noeuds[i].getId();

				}

			}

			val = val.replaceFirst(";", "");

			String[] valeursFiltres = {"id_mots_cles", val};

			return valeursFiltres;

		}

		@Override

		public void valider() {

			// TODO Auto-generated method stub

		}

		public void montrerContextMenuArbre(final TreeNode n, EventObject e,

				TreeEditor te) {

				Menu mn = new Menu();

				final com.gwtext.client.widgets.menu.Item ajoutN = new Item(

						"Ajouter un projet");

				final com.gwtext.client.widgets.menu.Item suppN = new Item(

						"Supprimer projet");

				mn.addItem(ajoutN);

				mn.addItem(suppN);

				mn.addListener(new MenuListenerAdapter() {

					@Override

					public void onItemClick(BaseItem item, EventObject e) {

						if (item.equals(suppN)) {

							supprimerNoeud(n);

						}

						if (item.equals(ajoutN)) {

							ajouterNoeud(n);

						}

					}

				});

				mn.showAt(e.getXY());

		}

		@Override

		public void viderFiltre() {

			arbreMotsCles.getSelectionModel().clearSelections();

			motsClesEnCours = "";

		}

}