Subversion Repositories eFlore/Applications.cel

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

import java.util.Comparator;

import java.util.Iterator;

import org.tela_botanica.client.image.ImageMediateur;

import org.tela_botanica.client.interfaces.Filtrable;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.modeles.objets.DateObservation;

import org.tela_botanica.client.modeles.objets.ListeDate;

import org.tela_botanica.client.util.Util;

import com.gwtext.client.data.Node;

import com.gwtext.client.data.NodeTraversalCallback;

import com.gwtext.client.data.Tree;

import com.gwtext.client.widgets.Panel;

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;

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 ArbreDateImageFiltreVue extends Panel implements Rafraichissable,

		Filtrable {

	/**

	 * Le médiateur associé à la vue

	 */

	private ImageMediateur	imageMediateur		= null;

	/**

	 * Les localites en cours

	 */

	private String donneesDateEnCours = "";

	/**

	 * Le treepanel qui affiche l'arbre

	 */

	private TreePanel arbreDonneesDates = null;

	/**

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

	 */

	/**

	 * booléen d'initialisation

	 */

	private boolean estInstancie = false;

	/**

	 * booléen d'etat

	 */

	private boolean filtreModifie = false;

	private boolean arbreCharge = false ;

	private String nomFiltre = "" ;

	private String prefixeId = "date_image_";

	/**

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

	 */

	@SuppressWarnings("unused")

	private ArbreDateImageFiltreVue() {

		super();

	}

	/**

	 * Constructeur avec paramètres

	 *

	 * @param im

	 *            le médiateur à associer

	 */

	public ArbreDateImageFiltreVue(ImageMediateur imgMed) {

		// on crée le panel

		super("Dates");

		this.imageMediateur = imgMed;

		arbreDonneesDates = new TreePanel();

		this.setPaddings(5);

		this.setCollapsible(true);

		this.setAutoScroll(true);

		this.setBorder(false);

		arbreDonneesDates.setBorder(false);

		// on ajoute les listeners

		ajouterListenersPanel();

		estInstancie = false;

	}

	/**

	 * Ajoute les listeners pour le rendu du panel

	 */

	private void ajouterListenersPanel() {

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

		arbreDonneesDates.setEnableDD(false);

		arbreDonneesDates.setId("x-view-tree-filter-date-image");

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

		TreeNode root = new TreeNode("Dates");

		root.addListener(new TreeNodeListenerAdapter() {

			@Override

			public void onExpand(Node node) {

				if(!arbreCharge)

				{

					obtenirDatesImages();

					arbreCharge = true ;

				}

			}

		}) ;

		root.setId("racine_date");

		String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };

		root.setUserObject(usObject);

		arbreDonneesDates.setRootNode(root);

		arbreDonneesDates.setRootVisible(true);

		setBorder(false);

		root.setExpandable(true) ;

		add(arbreDonneesDates);

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

		estInstancie = true;

	}

	/**

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

	 */

	public void ajouterListeners() {

		arbreDonneesDates.addListener(new TreePanelListenerAdapter() {

			@Override

			public void onClick(TreeNode node, EventObject e) {

				gererClicNoeud(node);

			}

		}) ;

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

			@Override

			public void onExpand(Node node) {

				if(!arbreCharge)

				{

					obtenirDatesImages();

					arbreCharge = true ;

				}

			}

		}) ;

	}

	private void gererClicNoeud(TreeNode node) {

		mettreAJourValeurEnCours(node);

		imageMediateur.obtenirPhotoGalerie() ;

	}

	private void mettreAJourValeurEnCours(TreeNode node) {

		nomFiltre = "" ;

		donneesDateEnCours = "" ;

		String nomPere = "" ;

		String nomGrandPere = "" ;

		switch(node.getDepth())

		{

			case 0:

				if(arbreCharge) {

					nomFiltre = "";

					donneesDateEnCours = "";

				}

				break;

			case 3: nomFiltre += "annee,mois,jour";

				nomPere = ((String[])node.getParentNode().getUserObject())[1] ;

				nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;

				donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;

				break;

			case 2: nomFiltre += "annee,mois";

				nomPere = ((String[])node.getParentNode().getUserObject())[1] ;

				donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;

				break;

			case 1: nomFiltre += "annee";

				donneesDateEnCours += ((String[])node.getUserObject())[1] ;

				break;

			default:

				break;

		}

		filtreModifie = true ;

	}

	public void initialiser() {

		arbreCharge = false ;

		donneesDateEnCours = "";

		arbreDonneesDates.collapseAll();

		// on vide l'ancien arbre

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

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

			rootChild[i].remove();

		}

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

			@Override

			public void onExpand(Node node) {

				if(!arbreCharge)

				{

					obtenirDatesImages() ;

					arbreCharge = true ;

				}

			}

		}) ;

	}

	/**

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

	 */

	@Override

	public void rafraichir(Object nouvelleDonnees,

			boolean repandreRaffraichissement) {

		if (nouvelleDonnees instanceof ListeDate) {

			String annee=null;

			String mois=null;

			String jour=null;

			ListeDate data = (ListeDate) nouvelleDonnees ;

				// on crée un arbre vide

				TreeNode root = new TreeNode();

				root.setId("racine_date");

				root.setText("Dates");

				String[] usObjRoot = { "Dates", "Dates", prefixeId+"racine_date"};

				root.setUserObject(usObjRoot);

				Tree nouvelArbre = new Tree();

				nouvelArbre.setRootNode(root);

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

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

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

				annee= ent.getAnnee() ;

				mois= ent.getMois() ;

				String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;

				jour= ent.getJour() ;

				if(annee.contains("0000")) {

					annee="Inconnue" ;

				}

				if(jour.contains("00")) {

					jour="Inconnue" ;

				}

				Node noeudMemeAnnee = nouvelArbre.getNodeById(prefixeId+annee);

				// si la région existe déjà

					if(noeudMemeAnnee != null)

					{

						// on teste si la localité existe

						Node noeudMemeMois = nouvelArbre.getNodeById(prefixeId+(annee+mois));

						if(noeudMemeMois != null)

						{

							// enfin on teste si le lieu dit existe

							Node noeudMemeJour = nouvelArbre.getNodeById(prefixeId+(annee+mois+jour));

							if(noeudMemeJour != null)

							{

								// tous les noeuds existent déjà, normalement ça ne devrait pas arriver

							}

							else

							{

								// enfin on ne crée que le noeud du lieu dit

								TreeNode node_jour = new TreeNode();

								node_jour.setId(prefixeId+(annee+mois+jour));

								node_jour.setText(jour);

								noeudMemeMois.appendChild(node_jour) ;

								String[] usObj = {jour,jour,annee+mois+jour};

								node_jour.setUserObject(usObj);

							}

						}

						else

						{

							TreeNode node_mois = new TreeNode();

							node_mois.setId(prefixeId+(annee+mois));

							node_mois.setText(moisLettre);

							noeudMemeAnnee.appendChild(node_mois) ;

							String[] usObj = {moisLettre,mois,annee+mois};

							node_mois.setUserObject(usObj);

							TreeNode node_jour = new TreeNode();

							node_jour.setId(prefixeId+(annee+mois+jour));

							node_jour.setText(jour);

							node_mois.appendChild(node_jour) ;

							String[] usObj2 = {jour,jour,annee+mois+jour};

							node_jour.setUserObject(usObj2);

						}

					}

					else

					{

						TreeNode node_annee = new TreeNode();

						node_annee.setId(prefixeId+annee);

						node_annee.setText(annee);

						root.appendChild(node_annee) ;

						String[] usObj = {annee, annee, annee};

						node_annee.setUserObject(usObj);

						TreeNode node_mois = new TreeNode();

						node_mois.setId(prefixeId+(annee+mois));

						node_mois.setText(moisLettre);

						node_annee.appendChild(node_mois) ;

						String[] usObj2 = {moisLettre,mois,annee+mois};

						node_mois.setUserObject(usObj2);

						TreeNode node_jour = new TreeNode();

						node_jour.setId(prefixeId+(annee+mois+jour));

						node_jour.setText(jour);

						node_mois.appendChild(node_jour) ;

						String[] usObj3 = {jour,jour,annee+mois+jour};

						node_jour.setUserObject(usObj3);

					}

				}

				// on trie

				root.sort(comparerNoeuds()) ;

				// on vide tous les noeuds

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

					@Override

					public boolean execute(Node node) {

						node.remove();

						return true;

					}

				});

				// et on recopie le nouvel arbre

				copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates

						.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 arbreDonneesDates;

	}

	/**

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

	 */

	@Override

	public String renvoyerNomFiltre() {

		return "Dates";

	}

	/**

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

	 *

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

	 */

	@Override

	public String[] renvoyerValeursAFiltrer() {

		valider();

		String[] valeursFiltrees = new String[0];

		if(!nomFiltre.trim().equals("") && !donneesDateEnCours.trim().equals("")) {

			valeursFiltrees = new String[2];

			valeursFiltrees[0] = nomFiltre;

			valeursFiltrees[1] = donneesDateEnCours;

		}

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

				child.setId(prefixeId+usObj[2]);

				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)

	 */

	@Override

	public boolean renvoyerEtatFiltre() {

		return filtreModifie;

	}

	@Override

	public void valider() {

		if (estInstancie) {

		}

	}

	public Comparator<TreeNode> comparerNoeuds()

	{

		return new Comparator<TreeNode>() {

			@Override

			public int compare(TreeNode o1, TreeNode o2) {

				String n1 = ((String[])o1.getUserObject())[1] ;

				String n2 = ((String[])o2.getUserObject())[1] ;

				return n1.compareTo(n2) ;

			}

		} ;

	}

	public void raz() {

		arbreCharge = false ;

		arbreDonneesDates.collapseAll();

		arbreDonneesDates.clear();

		TreeNode root = new TreeNode("Dates");

		root.setId("racine_date");

		String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };

		root.setUserObject(usObject);

		arbreDonneesDates.setRootNode(root);

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

			@Override

			public void onExpand(Node node) {

				if(!arbreCharge)

				{

					obtenirDatesImages() ;

					arbreCharge = true ;

				}

			}

		}) ;

		this.doLayout() ;

		donneesDateEnCours = "";

	}

	public void obtenirDatesImages() {

		imageMediateur.obtenirDatesImages(this);

	}

	@Override

	public void viderFiltre() {

		donneesDateEnCours = "";

		arbreDonneesDates.getSelectionModel().clearSelections();

	}

	public void viderFiltre(String nom) {

		final int profondeur = calculerProfondeurPourNomFiltre(nom);

		// on vide tous les noeuds

		arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() {

			@Override

			public boolean execute(Node node) {

				boolean continuer = true;

				TreeNode noeudArbreEncours = (TreeNode)node;

				if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) {

					int profondeurDepart = noeudArbreEncours.getDepth();

					for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) {

						noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode();

					}

					arbreDonneesDates.getSelectionModel().select(noeudArbreEncours);

					mettreAJourValeurEnCours(noeudArbreEncours);

					continuer = false;

				}

				return continuer;

			}

		});

	}

	private int calculerProfondeurPourNomFiltre(String nom) {

		int profondeur = 0;

		if(nom.equals("annee")) {

			profondeur = 1;

		}

		if(nom.equals("mois")) {

			profondeur = 2;

		}

		if(nom.equals("jour")) {

			profondeur = 3;

		}

		return profondeur;

	}

}