WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java


package org.tela_botanica.client.vues.observation.filtres;
 
import java.util.Comparator;
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.DateObservation;
import org.tela_botanica.client.modeles.ListeDateObservation;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.core.client.GWT;
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.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 ArbreDateObservationFiltreVue extends Panel implements Rafraichissable,
		Filtrable {
 
	/**
	 * Le médiateur associé à la vue
	 */
	private ObservationMediateur	observationMediateur		= 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
	 */
	
	private Tree donneesDates = new Tree();
	
	/**
	 * booléen d'initialisation
	 */
	private boolean estInstancie = false;
 
	/**
	 * booléen d'etat
	 */
	private boolean filtreModifie = false;
	
	private boolean arbreCharge = false ;
 
	private String nomFiltre = "" ;
	
	/**
	 * Constructeur sans argument (privé car ne doit pas être utilisé)
	 */
	@SuppressWarnings("unused")
	private ArbreDateObservationFiltreVue() {
		super();
	}
 
	/**
	 * Constructeur avec paramètres
	 * 
	 * @param im
	 *            le médiateur à associer
	 */
	public ArbreDateObservationFiltreVue(ObservationMediateur obs) {
 
		// on crée le panel
		super("Dates");
		
		this.observationMediateur = obs;
 
		arbreDonneesDates = new TreePanel();
 
		this.setPaddings(5);
 
		this.setCollapsible(true);
		this.setAutoScroll(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
				arbreDonneesDates.setEnableDD(false);
				arbreDonneesDates.setId("x-view-tree-filter-date");
				
				
				arbreDonneesDates.setBorder(false);
 
				// on crée une racine pour l'arbre
				TreeNode root = new TreeNode("Dates");
				root.setId("racine_date");
				String[] usObject = { "Dates", "Dates", "racine_date" };
				root.setUserObject(usObject);
 
				arbreDonneesDates.setRootNode(root);
				arbreDonneesDates.setRootVisible(true);
				arbreDonneesDates.setBorder(false);
				root.setExpandable(true) ;
 
				add(arbreDonneesDates);
 
				// 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() {
		
		arbreDonneesDates.addListener(new TreePanelListenerAdapter() {
			
			public void onClick(TreeNode node, EventObject e) {
				
				nomFiltre = "" ;
				donneesDateEnCours = "" ;
				String nomPere = "" ;
				String nomGrandPere = "" ;
				
				switch(node.getDepth()) 
				{
					case 0:
						if(!arbreCharge)
						{
						/*	arbreCharge = true ;
							observationMediateur.obtenirDatesObservation() ;*/
							arbreDonneesDates.getRootNode().expand();
						}
						else 
						{
							observationMediateur.obtenirNombreObservation() ;
						}
						return ;
					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 ;
				observationMediateur.obtenirNombreObservation() ;
				
			}
			
		}) ;
		
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
			
			public void onExpand(Node node) {
				if(!arbreCharge)
				{
					observationMediateur.obtenirDatesObservation() ;
					arbreCharge = 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() {
			
			public void onExpand(Node node) {
				if(!arbreCharge)
				{
					observationMediateur.obtenirDatesObservation() ;
					arbreCharge = true ;
				}
			}
			
		}) ;
	}
 
	/**
	 * Méthode héritée de l'interface rafraichissable
	 */
	public void rafraichir(Object nouvelleDonnees,
			boolean repandreRaffraichissement) {
		
		if (nouvelleDonnees instanceof ListeDateObservation) {
			
			String annee=null;
			String mois=null;
			String jour=null;
			
			ListeDateObservation data = (ListeDateObservation) nouvelleDonnees ;
			
				// on crée un arbre vide
				TreeNode root = new TreeNode();
				root.setId("racine_date");
				root.setText("Dates");
				String[] usObjRoot = { "Dates", "Dates", "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=(DateObservation) data.get(it.next());
				
				annee= ent.getAnnee() ;
				mois= ent.getMois() ;
				String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
				jour= ent.getJour() ;
				
				if(annee.contains("0000")) {
					annee="Inconnue" ;
				}
				
				if(jour.contains("00")) {
					jour="Inconnue" ;
				}
				
				Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee);
				// si la région existe déjà
					if(noeudMemeAnnee != null)
					{
						// on teste si la localité existe
						Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois));
						if(noeudMemeMois != null)
						{
							// enfin on teste si le lieu dit existe
							Node noeudMemeJour = nouvelArbre.getNodeById(""+(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(""+(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(""+(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(""+(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(""+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(""+(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(""+(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() {
	
					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();
 
			}
		
		if(nouvelleDonnees instanceof Observation)
		{
			// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout
			// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement
			// de l'arbre
			if(!arbreCharge) {
				return;
			}
			
			Observation ent = (Observation)nouvelleDonnees ;
			String dateSpl[] = ent.getDate().split("/") ;
			
			String annee= dateSpl[2];
			String mois= dateSpl[1];
			String jour= dateSpl[0];
			
			String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
			
			Node root = arbreDonneesDates.getRootNode() ;
			
			if(annee.contains("0000") || annee.equals(null)) {
				annee="Inconnue" ;
			}
			
			if(jour.contains("00") || jour.equals(null)) {
				jour="Inconnue" ;
			}
			
			Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee);
			// si la région existe déjà
				if(noeudMemeAnnee != null)
				{	
					// on teste si la localité existe
					Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois));
					if(noeudMemeMois != null)
					{
						// enfin on teste si le lieu dit existe
						Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(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(""+(annee+mois+jour));
							node_jour.setText(jour);
							String[] usObj = {jour,jour,annee+mois+jour};
							node_jour.setUserObject(usObj);
							noeudMemeMois.appendChild(node_jour) ;
							
							root.sort(comparerNoeuds()) ;
						}
					}
					else
					{
						TreeNode node_mois = new TreeNode();
						node_mois.setId(""+(annee+mois));
						node_mois.setText(moisLettre);
						String[] usObj = {moisLettre,mois,annee+mois};
						node_mois.setUserObject(usObj);
						noeudMemeAnnee.appendChild(node_mois) ;
						
						TreeNode node_jour = new TreeNode();
						node_jour.setId(""+(annee+mois+jour));
						node_jour.setText(jour);
						String[] usObj2 = {jour,jour,annee+mois+jour};
						node_jour.setUserObject(usObj2);
						node_mois.appendChild(node_jour) ;
						
						root.sort(comparerNoeuds()) ;
					}
			}
			else
			{
				
				TreeNode node_annee = new TreeNode();
				node_annee.setId(""+annee);
				node_annee.setText(annee);
				String[] usObj = {annee,annee,annee};
				node_annee.setUserObject(usObj);
				root.appendChild(node_annee) ;
				
				TreeNode node_mois = new TreeNode();
				node_mois.setId(""+(annee+mois));
				node_mois.setText(moisLettre);
				String[] usObj2 = {moisLettre,mois,annee+mois};
				node_mois.setUserObject(usObj2);
				node_annee.appendChild(node_mois) ;
				
				TreeNode node_jour = new TreeNode();
				node_jour.setId(""+(annee+mois+jour));
				node_jour.setText(jour);
				String[] usObj3 = {jour,jour,annee+mois+jour};
				node_jour.setUserObject(usObj3);
				node_mois.appendChild(node_jour) ;
				
				// TODO : améliorer la compararaison des noeuds
				root.sort(comparerNoeuds()) ;
			}
				
				arbreDonneesDates.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
	 */
	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
	 */
	public String[] renvoyerValeursAFiltrer() {
 
		valider();
		
		String valeursFiltrees[] = {nomFiltre, 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(""+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)
	 */
	public boolean renvoyerEtatFiltre() {
 
		return filtreModifie;
	}
 
	public void valider() {
		
		if (estInstancie) {
			
		}
	}
	
	public Comparator<TreeNode> comparerNoeuds()
	{
		return new Comparator<TreeNode>() {
 
			public int compare(TreeNode o1, TreeNode o2) {
				
				String n1 = ((String[])o1.getUserObject())[1] ;
				String n2 = ((String[])o2.getUserObject())[1] ;
				
				return n1.compareTo(n2) ;
			}
			
		} ;
	}
	
	public String renvoyerMois(int numMois) {
		
		switch (numMois) {
		case 1:
			return "janvier" ;
		case 2:
			return "fevrier" ;
		case 3:
			return "mars" ;
		case 4:
			return "avril" ;
		case 5:
			return "mai" ;
		case 6:
			return "juin" ;
		case 7:
			return "juillet" ;
		case 8:
			return "août" ;
		case 9:
			return "septembre" ;
		case 10:
			return "octobre" ;
		case 11:
			return "novembre" ;
		case 12:
			return "décembre" ;
		default:
			return "Inconnue" ;
		}
		
	}
 
	public void raz() {
				
		arbreCharge = false ;
		arbreDonneesDates.collapseAll();
		arbreDonneesDates.clear();
 
		
		TreeNode root = new TreeNode("Dates");
		root.setId("racine_date");
		String[] usObject = { "Dates", "Dates", "racine_date" };
		root.setUserObject(usObject);
 
		arbreDonneesDates.setRootNode(root);
		
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
			
			public void onExpand(Node node) {
				if(!arbreCharge)
				{
					observationMediateur.obtenirDatesObservation() ;
					arbreCharge = true ;
				}
			}
			
		}) ;
		
		this.doLayout() ;
		
		donneesDateEnCours = "";
		
	}
 
 
}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java – Rev 202 → 263

Rev 202		Rev 263
1	`package org.tela_botanica.client.vues.observation.filtres;`	1	`package org.tela_botanica.client.vues.observation.filtres;`
2		2
3	`import java.util.Comparator;`	3	`import java.util.Comparator;`
4	`import java.util.Iterator;`	4	`import java.util.Iterator;`
5		5
6	`import org.tela_botanica.client.interfaces.Filtrable;`	6	`import org.tela_botanica.client.interfaces.Filtrable;`
7	`import org.tela_botanica.client.interfaces.Rafraichissable;`	7	`import org.tela_botanica.client.interfaces.Rafraichissable;`
8	`import org.tela_botanica.client.modeles.DateObservation;`	8	`import org.tela_botanica.client.modeles.DateObservation;`
9	`import org.tela_botanica.client.modeles.ListeDateObservation;`	9	`import org.tela_botanica.client.modeles.ListeDateObservation;`
10	`import org.tela_botanica.client.modeles.Observation;`	10	`import org.tela_botanica.client.modeles.Observation;`
11	`import org.tela_botanica.client.observation.ObservationMediateur;`	11	`import org.tela_botanica.client.observation.ObservationMediateur;`
12		12
13	`import com.google.gwt.core.client.GWT;`	13	`import com.google.gwt.core.client.GWT;`
14	`import com.gwtext.client.data.Node;`	14	`import com.gwtext.client.data.Node;`
15	`import com.gwtext.client.data.NodeTraversalCallback;`	15	`import com.gwtext.client.data.NodeTraversalCallback;`
16	`import com.gwtext.client.data.Tree;`	16	`import com.gwtext.client.data.Tree;`
17	`import com.gwtext.client.widgets.Component;`	17	`import com.gwtext.client.widgets.Component;`
18	`import com.gwtext.client.widgets.Panel;`	18	`import com.gwtext.client.widgets.Panel;`
19	`import com.gwtext.client.widgets.event.PanelListenerAdapter;`	19	`import com.gwtext.client.widgets.event.PanelListenerAdapter;`
20	`import com.gwtext.client.widgets.tree.TreeNode;`	20	`import com.gwtext.client.widgets.tree.TreeNode;`
21	`import com.gwtext.client.widgets.tree.TreePanel;`	21	`import com.gwtext.client.widgets.tree.TreePanel;`
22	`import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;`	22	`import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;`
23	`import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;`	23	`import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;`
24	`import com.gwtext.client.core.EventObject;`	24	`import com.gwtext.client.core.EventObject;`
25		25
26	`/**`	26	`/**`
27	`* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton`	27	`* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton`
28	`* cliquable`	28	`* cliquable`
29	`*`	29	`*`
30	`* @author aurelien`	30	`* @author aurelien`
31	`*`	31	`*`
32	`*/`	32	`*/`
33	`public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable,`	33	`public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable,`
34	`Filtrable {`	34	`Filtrable {`
35		35
36	`/**`	36	`/**`
37	`* Le médiateur associé à la vue`	37	`* Le médiateur associé à la vue`
38	`*/`	38	`*/`
39	`private ObservationMediateur observationMediateur = null;`	39	`private ObservationMediateur observationMediateur = null;`
40		40