Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues;

import java.util.Iterator;

import org.tela_botanica.client.interfaces.Filtrable;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.modeles.EntiteGeographiqueObservation;

import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation;

import org.tela_botanica.client.observation.ObservationMediateur;

import com.google.gwt.core.client.GWT;

import com.google.gwt.json.client.JSONArray;

import com.google.gwt.json.client.JSONObject;

import com.google.gwt.user.client.Window;

import com.google.gwt.user.client.ui.Label;

import com.gwtext.client.data.Node;

import com.gwtext.client.data.NodeTraversalCallback;

import com.gwtext.client.data.Tree;

import com.gwtext.client.widgets.Component;

import com.gwtext.client.widgets.Panel;

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

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

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

import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;

import com.gwtext.client.core.EventObject;

/**

 * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton

 * cliquable

 *

 * @author aurelien

 *

 */

public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable,

		Filtrable {

	/**

	 * Le médiateur associé à la vue

	 */

	private ObservationMediateur	observationMediateur		= null;

	/**

	 * Les localites en cours

	 */

	private String entitesGeographiquesEncours = "";

	/**

	 * Le treepanel qui affiche l'arbre

	 */

	private TreePanel arbreEntitesGeographiques = null;

	/**

	 * La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue

	 */

	private Tree donneeEntitesGeographiques = new Tree();;

	/**

	 * booléen d'initialisation

	 */

	private boolean estInstancie = false;

	/**

	 * booléen d'etat

	 */

	private boolean filtreModifie = false;

	private String[] valeursFiltrees = null ;

	private boolean arbreCharge = false ;

	private String nomFiltre = "" ;

	/**

	 * Constructeur sans argument (privé car ne doit pas être utilisé)

	 */

	@SuppressWarnings("unused")

	private ArbreEntiteGeographiqueObservationFiltreVue() {

		super();

	}

	/**

	 * Constructeur avec paramètres

	 *

	 * @param im

	 *            le médiateur à associer

	 */

	public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) {

		// on crée le panel

		super("Localité");

		this.observationMediateur = obs;

		arbreEntitesGeographiques = new TreePanel();

		this.setPaddings(5);

		this.setBorder(false);

		this.setCollapsible(true);

		this.setAutoWidth(true);

		// on ajoute les listeners

		ajouterListenersPanel();

		estInstancie = false;

	}

	/**

	 * 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

			public void onRender(Component component) {

				// on interdit le drag and drop dans l'arbre

				arbreEntitesGeographiques.setEnableDD(false);

				arbreEntitesGeographiques.setId("x-view-tree-filter-entity");

				arbreEntitesGeographiques.setAutoWidth(false);

				if (GWT.isScript()) {

					arbreEntitesGeographiques.setAutoScroll(true);

				}

				arbreEntitesGeographiques.setBorder(false);

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

				TreeNode root = new TreeNode("Localités");

				root.setId("racine_entite");

				String[] usObject = { "Localités" };

				root.setUserObject(usObject);

				arbreEntitesGeographiques.setRootNode(root);

				arbreEntitesGeographiques.setRootVisible(true);

				arbreEntitesGeographiques.setBorder(false);

				root.setExpandable(true) ;

				add(arbreEntitesGeographiques);

				// on ajoute les listeners d'évenements

				ajouterListeners();

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

				estInstancie = true;

			}

		});

	}

	/**

	 * ajoute les listeners pour les boutons et le cochage des entites

	 */

	private void ajouterListeners() {

		arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() {

			public void onClick(TreeNode node, EventObject e) {

				nomFiltre = "" ;

				switch(node.getDepth())

				{

					case 0:

						if(!arbreCharge)

						{

							observationMediateur.obtenirListeEntiteGeographique() ;

							arbreCharge = true ;

						}

						else

						{

							entitesGeographiquesEncours = "" ;

							observationMediateur.obtenirNombreObservation() ;

						}

						return ;

					case 1: nomFiltre = "id_location";

						break;

					case 2: nomFiltre = "location";

						break;

					case 3: nomFiltre = "lieudit";

						break;

					default:

						break;

				}

				if(node.getText().equals("Inconnue"))

				{

					entitesGeographiquesEncours = "000null" ;

				}

				else

				{

					entitesGeographiquesEncours = node.getText() ;

				}

				//Window.alert("Les entités sont : "+entitesGeographiquesEncours) ;

				filtreModifie = true ;

				observationMediateur.obtenirNombreObservation() ;

			}

		}) ;

	}

	/**

	 * Méthode héritée de l'interface rafraichissable

	 */

	public void rafraichir(Object nouvelleDonnees,

			boolean repandreRaffraichissement) {

		if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) {

			String entite=null;

			String idEntite=null;

			String idParent=null;

			ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ;

			if (data.isEmpty()) {

				// on crée un arbre vide

				TreeNode root = new TreeNode();

				root.setId("racine_entite");

				root.setText("Localités");

				String[] usObj = { "Localités"};

				root.setUserObject(usObj);

				donneeEntitesGeographiques.setRootNode(root);

			}

			// on la parse et on récupère les informations qui nous interessent

			for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {

				EntiteGeographiqueObservation ent=(EntiteGeographiqueObservation) data.get(it.next());

				entite=ent.getEntite();

				if(entite.contains("000null")) {

					entite="Inconnue" ;

				}

				idEntite=ent.getIdEntite();

				idParent=ent.getIdParent();

				String[] usObj = { entite };

					// et on construit l'arbre à partir de la racine (qui est

					// toujours le premier élément)

					if (entite.equals("racine_entite")) {

						TreeNode root = new TreeNode();

						root.setId(idEntite);

						root.setText(entite);

						root.setUserObject(usObj);

						donneeEntitesGeographiques.setRootNode(root);

					} else {

						// et en ajoutant les noeuds un à un (qui sont renvoyé

						// dans l'ordre hierarchique de leur niveau

						// ce qui permet de les traiter séquentiellement)

						TreeNode node = new TreeNode();

						node.setId(idEntite);

						node.setText(entite);

						Node parentNode = donneeEntitesGeographiques.getNodeById(idParent);

						if(parentNode != null)

						{

							node.setUserObject(usObj);

							parentNode.appendChild(node);

						}

					}

				}

			}

			// on vide tous les noeuds

			arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() {

				public boolean execute(Node node) {

					node.remove();

					return true;

				}

			});

			// et on recopie le nouvel arbre

			copierFilsNoeud(donneeEntitesGeographiques.getRootNode(), arbreEntitesGeographiques

					.getRootNode());

			// si l'arbre n'était pas encore considéré comme instancié

			if (!estInstancie) {

				// on signale que oui

				estInstancie = true;

			}

			// l'état du filtre est réinitialisé

			filtreModifie = false;

			//show() ;

			doLayout();

	}

	/**

	 * Accesseur pour le panneau contenant l'arbre

	 *

	 * @return le panneau de l'arbre des mots clés

	 */

	public TreePanel getArbreMotsCles() {

		return arbreEntitesGeographiques;

	}

	/**

	 * Méthode héritée de Filtrable renvoie le nom du filtre

	 */

	public String renvoyerNomFiltre() {

		return "Localités";

	}

	/**

	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur

	 *

	 * @return un tableau contenant le nom du champ à filtrer et sa valeur

	 */

	public String[] renvoyerValeursAFiltrer() {

		valider();

		String valeursFiltrees[] = {nomFiltre, entitesGeographiquesEncours } ;

		return valeursFiltrees;

	}

	/**

	 * 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.setUserObject(usObj);

				ndPereCopie.appendChild(child);

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

					copierFilsNoeud(ndNodeFils[i], child);

				}

			}

		}

	}

	/**

	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)

	 */

	public boolean renvoyerEtatFiltre() {

		return filtreModifie;

	}

	public void valider() {

		if (estInstancie) {

		}

	}

}