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.objets.DateObservation;
import org.tela_botanica.client.modeles.objets.ListeDate;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.observation.ObservationMediateur;
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.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
	 */
 
 
	
	/**
	 * 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
			@Override
			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() {
			
			@Override
			public void onClick(TreeNode node, EventObject e) {
				gererClicNoeud(node);
			}
			
		}) ;
		
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
			
			@Override
			public void onExpand(Node node) {
				if(!arbreCharge)
				{
					observationMediateur.obtenirDatesObservation() ;
					arbreCharge = true ;
				}
			}
			
		}) ;
	}
	
	private void gererClicNoeud(TreeNode node) {
		
		mettreAJourValeurEnCours(node);
		observationMediateur.obtenirNombreObservation() ;		
	}
	
	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)
				{
					observationMediateur.obtenirDatesObservation() ;
					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", "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(""+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() {
	
					@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();
 
			}
		
		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 = Util.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
	 */
	@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[] = {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)
	 */
	@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", "racine_date" };
		root.setUserObject(usObject);
 
		arbreDonneesDates.setRootNode(root);
		
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
			
			@Override
			public void onExpand(Node node) {
				if(!arbreCharge)
				{
					observationMediateur.obtenirDatesObservation() ;
					arbreCharge = true ;
				}
			}
			
		}) ;
		
		this.doLayout() ;
		
		donneesDateEnCours = "";
		
	}
 
	@Override
	public void viderFiltre() {
		arbreDonneesDates.getSelectionModel().clearSelections();
		donneesDateEnCours = "";		
	}
 
	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;
	}
}

Rev 1292	Rev 2042
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.objets.DateObservation;`	8	`import org.tela_botanica.client.modeles.objets.DateObservation;`
9	`import org.tela_botanica.client.modeles.objets.ListeDate;`	9	`import org.tela_botanica.client.modeles.objets.ListeDate;`
10	`import org.tela_botanica.client.modeles.objets.Observation;`	10	`import org.tela_botanica.client.modeles.objets.Observation;`
11	`import org.tela_botanica.client.observation.ObservationMediateur;`	11	`import org.tela_botanica.client.observation.ObservationMediateur;`
12	`import org.tela_botanica.client.util.Util;`	12	`import org.tela_botanica.client.util.Util;`
13		13
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
41	`/**`	41	`/**`
42	`* Les localites en cours`	42	`* Les localites en cours`
43	`*/`	43	`*/`
44	`private String donneesDateEnCours = "";`	44	`private String donneesDateEnCours = "";`
45		45
46	`/**`	46	`/**`
47	`* Le treepanel qui affiche l'arbre`	47	`* Le treepanel qui affiche l'arbre`
48	`*/`	48	`*/`
49	`private TreePanel arbreDonneesDates = null;`	49	`private TreePanel arbreDonneesDates = null;`
50		50
51	`/**`	51	`/**`
52	`* La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue`	52	`* La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue`
53	`*/`	53	`*/`
54		-
55	`private Tree donneesDates = new Tree();`	-
56		54
57	`/**`	55	`/**`
58	`* booléen d'initialisation`	56	`* booléen d'initialisation`
59	`*/`	57	`*/`
60	`private boolean estInstancie = false;`	58	`private boolean estInstancie = false;`
61		59
62	`/**`	60	`/**`
63	`* booléen d'etat`	61	`* booléen d'etat`
64	`*/`	62	`*/`
65	`private boolean filtreModifie = false;`	63	`private boolean filtreModifie = false;`
66		64
67	`private boolean arbreCharge = false ;`	65	`private boolean arbreCharge = false ;`
68		66
69	`private String nomFiltre = "" ;`	67	`private String nomFiltre = "" ;`
70		68
71	`/**`	69	`/**`
72	`* Constructeur sans argument (privé car ne doit pas être utilisé)`	70	`* Constructeur sans argument (privé car ne doit pas être utilisé)`
73	`*/`	71	`*/`
74	`@SuppressWarnings("unused")`	72	`@SuppressWarnings("unused")`
75	`private ArbreDateObservationFiltreVue() {`	73	`private ArbreDateObservationFiltreVue() {`
76	`super();`	74	`super();`
77	`}`	75	`}`
78		76
79	`/**`	77	`/**`
80	`* Constructeur avec paramètres`	78	`* Constructeur avec paramètres`
81	`*`	79	`*`
82	`* @param im`	80	`* @param im`
83	`* le médiateur à associer`	81	`* le médiateur à associer`
84	`*/`	82	`*/`
85	`public ArbreDateObservationFiltreVue(ObservationMediateur obs) {`	83	`public ArbreDateObservationFiltreVue(ObservationMediateur obs) {`
86		84
87	`// on crée le panel`	85	`// on crée le panel`
88	`super("Dates");`	86	`super("Dates");`
89		87
90	`this.observationMediateur = obs;`	88	`this.observationMediateur = obs;`
91		89
92	`arbreDonneesDates = new TreePanel();`	90	`arbreDonneesDates = new TreePanel();`
93		91
94	`this.setPaddings(5);`	92	`this.setPaddings(5);`
95		93
96	`this.setCollapsible(true);`	94	`this.setCollapsible(true);`
97	`this.setAutoScroll(true);`	95	`this.setAutoScroll(true);`
98		96
99	`// on ajoute les listeners`	97	`// on ajoute les listeners`
100	`ajouterListenersPanel();`	98	`ajouterListenersPanel();`
101	`estInstancie = false;`	99	`estInstancie = false;`
102	`}`	100	`}`
103		101
104	`/**`	102	`/**`
105	`* Ajoute les listeners pour le rendu du panel`	103	`* Ajoute les listeners pour le rendu du panel`
106	`*/`	104	`*/`
107	`private void ajouterListenersPanel() {`	105	`private void ajouterListenersPanel() {`
108	`this.addListener(new PanelListenerAdapter() {`	106	`this.addListener(new PanelListenerAdapter() {`
109		107
110	`// on instancie réellement les composants au moment du rendu pour`	108	`// on instancie réellement les composants au moment du rendu pour`
111	`// accélérer l'affichage`	109	`// accélérer l'affichage`
112	`// et éviter des bugs`	110	`// et éviter des bugs`
113	`@Override`	111	`@Override`
114	`public void onRender(Component component) {`	112	`public void onRender(Component component) {`
115		113
116	`// on interdit le drag and drop dans l'arbre`	114	`// on interdit le drag and drop dans l'arbre`
117	`arbreDonneesDates.setEnableDD(false);`	115	`arbreDonneesDates.setEnableDD(false);`
118	`arbreDonneesDates.setId("x-view-tree-filter-date");`	116	`arbreDonneesDates.setId("x-view-tree-filter-date");`
119		117
120		118
121	`arbreDonneesDates.setBorder(false);`	119	`arbreDonneesDates.setBorder(false);`
122		120
123	`// on crée une racine pour l'arbre`	121	`// on crée une racine pour l'arbre`
124	`TreeNode root = new TreeNode("Dates");`	122	`TreeNode root = new TreeNode("Dates");`
125	`root.setId("racine_date");`	123	`root.setId("racine_date");`
126	`String[] usObject = { "Dates", "Dates", "racine_date" };`	124	`String[] usObject = { "Dates", "Dates", "racine_date" };`
127	`root.setUserObject(usObject);`	125	`root.setUserObject(usObject);`
128		126
129	`arbreDonneesDates.setRootNode(root);`	127	`arbreDonneesDates.setRootNode(root);`
130	`arbreDonneesDates.setRootVisible(true);`	128	`arbreDonneesDates.setRootVisible(true);`
131	`arbreDonneesDates.setBorder(false);`	129	`arbreDonneesDates.setBorder(false);`
132	`root.setExpandable(true) ;`	130	`root.setExpandable(true) ;`
133		131
134	`add(arbreDonneesDates);`	132	`add(arbreDonneesDates);`
135		133
136	`// on ajoute les listeners d'évenements`	134	`// on ajoute les listeners d'évenements`
137	`ajouterListeners();`	135	`ajouterListeners();`
138		136
139		137
140	`// enfin on considère le composant comme instancié`	138	`// enfin on considère le composant comme instancié`
141	`estInstancie = true;`	139	`estInstancie = true;`
142		140
143		141
144	`}`	142	`}`
145		143
146	`});`	144	`});`
147	`}`	145	`}`
148		146
149		147
150		148
151	`/**`	149	`/**`
152	`* ajoute les listeners pour les boutons et le cochage des entites`	150	`* ajoute les listeners pour les boutons et le cochage des entites`
153	`*/`	151	`*/`
154	`private void ajouterListeners() {`	152	`private void ajouterListeners() {`
155		153
156	`arbreDonneesDates.addListener(new TreePanelListenerAdapter() {`	154	`arbreDonneesDates.addListener(new TreePanelListenerAdapter() {`
157		155
158	`@Override`	156	`@Override`
159	`public void onClick(TreeNode node, EventObject e) {`	157	`public void onClick(TreeNode node, EventObject e) {`
160	`gererClicNoeud(node);`	158	`gererClicNoeud(node);`
161	`}`	159	`}`
162		160
163	`}) ;`	161	`}) ;`
164		162
165	`arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {`	163	`arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {`
166		164
167	`@Override`	165	`@Override`
168	`public void onExpand(Node node) {`	166	`public void onExpand(Node node) {`
169	`if(!arbreCharge)`	167	`if(!arbreCharge)`
170	`{`	168	`{`
171	`observationMediateur.obtenirDatesObservation() ;`	169	`observationMediateur.obtenirDatesObservation() ;`
172	`arbreCharge = true ;`	170	`arbreCharge = true ;`
173	`}`	171	`}`
174	`}`	172	`}`
175		173
176	`}) ;`	174	`}) ;`
177	`}`	175	`}`
178		176
179	`private void gererClicNoeud(TreeNode node) {`	177	`private void gererClicNoeud(TreeNode node) {`
180		178
181	`mettreAJourValeurEnCours(node);`	179	`mettreAJourValeurEnCours(node);`
182	`observationMediateur.obtenirNombreObservation() ;`	180	`observationMediateur.obtenirNombreObservation() ;`
183	`}`	181	`}`
184		182
185	`private void mettreAJourValeurEnCours(TreeNode node) {`	183	`private void mettreAJourValeurEnCours(TreeNode node) {`
186		184
187	`nomFiltre = "" ;`	185	`nomFiltre = "" ;`
188	`donneesDateEnCours = "" ;`	186	`donneesDateEnCours = "" ;`
189	`String nomPere = "" ;`	187	`String nomPere = "" ;`
190	`String nomGrandPere = "" ;`	188	`String nomGrandPere = "" ;`
191		189
192	`switch(node.getDepth())`	190	`switch(node.getDepth())`
193	`{`	191	`{`
194	`case 0:`	192	`case 0:`
195	`if(arbreCharge) {`	193	`if(arbreCharge) {`
196	`nomFiltre = "";`	194	`nomFiltre = "";`
197	`donneesDateEnCours = "";`	195	`donneesDateEnCours = "";`
198	`}`	196	`}`
199	`break;`	197	`break;`
200	`case 3: nomFiltre += "annee,mois,jour";`	198	`case 3: nomFiltre += "annee,mois,jour";`
201	`nomPere = ((String[])node.getParentNode().getUserObject())[1] ;`	199	`nomPere = ((String[])node.getParentNode().getUserObject())[1] ;`
202	`nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;`	200	`nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;`
203	`donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;`	201	`donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;`
204	`break;`	202	`break;`
205	`case 2: nomFiltre += "annee,mois";`	203	`case 2: nomFiltre += "annee,mois";`
206	`nomPere = ((String[])node.getParentNode().getUserObject())[1] ;`	204	`nomPere = ((String[])node.getParentNode().getUserObject())[1] ;`
207	`donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;`	205	`donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;`
208	`break;`	206	`break;`
209	`case 1: nomFiltre += "annee";`	207	`case 1: nomFiltre += "annee";`
210	`donneesDateEnCours += ((String[])node.getUserObject())[1] ;`	208	`donneesDateEnCours += ((String[])node.getUserObject())[1] ;`
211	`break;`	209	`break;`
212	`default:`	210	`default:`
213	`break;`	211	`break;`
214	`}`	212	`}`
215		213
216	`filtreModifie = true ;`	214	`filtreModifie = true ;`
217	`}`	215	`}`
218		216
219	`public void initialiser() {`	217	`public void initialiser() {`
220		218
221	`arbreCharge = false ;`	219	`arbreCharge = false ;`
222	`donneesDateEnCours = "";`	220	`donneesDateEnCours = "";`
223	`arbreDonneesDates.collapseAll();`	221	`arbreDonneesDates.collapseAll();`
224		222
225	`// on vide l'ancien arbre`	223	`// on vide l'ancien arbre`
226	`Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes();`	224	`Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes();`
227	`for (int i = 0; i < rootChild.length; i++) {`	225	`for (int i = 0; i < rootChild.length; i++) {`
228		226
229	`rootChild[i].remove();`	227	`rootChild[i].remove();`
230	`}`	228	`}`
231		229
232	`arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {`	230	`arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {`
233		231
234	`@Override`	232	`@Override`
235	`public void onExpand(Node node) {`	233	`public void onExpand(Node node) {`
236	`if(!arbreCharge)`	234	`if(!arbreCharge)`
237	`{`	235	`{`
238	`observationMediateur.obtenirDatesObservation() ;`	236	`observationMediateur.obtenirDatesObservation() ;`
239	`arbreCharge = true ;`	237	`arbreCharge = true ;`
240	`}`	238	`}`
241	`}`	239	`}`
242		240
243	`}) ;`	241	`}) ;`
244	`}`	242	`}`
245		243
246	`/**`	244	`/**`
247	`* Méthode héritée de l'interface rafraichissable`	245	`* Méthode héritée de l'interface rafraichissable`
248	`*/`	246	`*/`
249	`@Override`	247	`@Override`
250	`public void rafraichir(Object nouvelleDonnees,`	248	`public void rafraichir(Object nouvelleDonnees,`
251	`boolean repandreRaffraichissement) {`	249	`boolean repandreRaffraichissement) {`
252		250
253	`if (nouvelleDonnees instanceof ListeDate) {`	251	`if (nouvelleDonnees instanceof ListeDate) {`
254		252
255	`String annee=null;`	253	`String annee=null;`
256	`String mois=null;`	254	`String mois=null;`
257	`String jour=null;`	255	`String jour=null;`
258		256
259	`ListeDate data = (ListeDate) nouvelleDonnees ;`	257	`ListeDate data = (ListeDate) nouvelleDonnees ;`
260		258
261	`// on crée un arbre vide`	259	`// on crée un arbre vide`
262	`TreeNode root = new TreeNode();`	260	`TreeNode root = new TreeNode();`
263	`root.setId("racine_date");`	261	`root.setId("racine_date");`
264	`root.setText("Dates");`	262	`root.setText("Dates");`
265	`String[] usObjRoot = { "Dates", "Dates", "racine_date"};`	263	`String[] usObjRoot = { "Dates", "Dates", "racine_date"};`
266	`root.setUserObject(usObjRoot);`	264	`root.setUserObject(usObjRoot);`
267	`Tree nouvelArbre = new Tree();`	265	`Tree nouvelArbre = new Tree();`
268	`nouvelArbre.setRootNode(root);`	266	`nouvelArbre.setRootNode(root);`
269		267
270	`// on la parse et on récupère les informations qui nous interessent`	268	`// on la parse et on récupère les informations qui nous interessent`
271	`for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {`	269	`for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {`
272		270
273	`DateObservation ent=data.get(it.next());`	271	`DateObservation ent=data.get(it.next());`
274		272
275	`annee= ent.getAnnee() ;`	273	`annee= ent.getAnnee() ;`
276	`mois= ent.getMois() ;`	274	`mois= ent.getMois() ;`
277	`String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;`	275	`String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;`
278	`jour= ent.getJour() ;`	276	`jour= ent.getJour() ;`
279		277
280	`if(annee.contains("0000")) {`	278	`if(annee.contains("0000")) {`
281	`annee="Inconnue" ;`	279	`annee="Inconnue" ;`
282	`}`	280	`}`
283		281
284	`if(jour.contains("00")) {`	282	`if(jour.contains("00")) {`
285	`jour="Inconnue" ;`	283	`jour="Inconnue" ;`
286	`}`	284	`}`
287		285
288	`Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee);`	286	`Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee);`
289	`// si la région existe déjà`	287	`// si la région existe déjà`
290	`if(noeudMemeAnnee != null)`	288	`if(noeudMemeAnnee != null)`
291	`{`	289	`{`
292	`// on teste si la localité existe`	290	`// on teste si la localité existe`
293	`Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois));`	291	`Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois));`
294	`if(noeudMemeMois != null)`	292	`if(noeudMemeMois != null)`
295	`{`	293	`{`
296	`// enfin on teste si le lieu dit existe`	294	`// enfin on teste si le lieu dit existe`
297	`Node noeudMemeJour = nouvelArbre.getNodeById(""+(annee+mois+jour));`	295	`Node noeudMemeJour = nouvelArbre.getNodeById(""+(annee+mois+jour));`
298	`if(noeudMemeJour != null)`	296	`if(noeudMemeJour != null)`
299	`{`	297	`{`
300	`// tous les noeuds existent déjà, normalement ça ne devrait pas arriver`	298	`// tous les noeuds existent déjà, normalement ça ne devrait pas arriver`
301	`}`	299	`}`
302	`else`	300	`else`
303	`{`	301	`{`
304	`// enfin on ne crée que le noeud du lieu dit`	302	`// enfin on ne crée que le noeud du lieu dit`
305	`TreeNode node_jour = new TreeNode();`	303	`TreeNode node_jour = new TreeNode();`
306	`node_jour.setId(""+(annee+mois+jour));`	304	`node_jour.setId(""+(annee+mois+jour));`
307	`node_jour.setText(jour);`	305	`node_jour.setText(jour);`
308	`noeudMemeMois.appendChild(node_jour) ;`	306	`noeudMemeMois.appendChild(node_jour) ;`
309	`String[] usObj = {jour,jour,annee+mois+jour};`	307	`String[] usObj = {jour,jour,annee+mois+jour};`
310	`node_jour.setUserObject(usObj);`	308	`node_jour.setUserObject(usObj);`
311	`}`	309	`}`
312	`}`	310	`}`
313	`else`	311	`else`
314	`{`	312	`{`
315	`TreeNode node_mois = new TreeNode();`	313	`TreeNode node_mois = new TreeNode();`
316	`node_mois.setId(""+(annee+mois));`	314	`node_mois.setId(""+(annee+mois));`
317	`node_mois.setText(moisLettre);`	315	`node_mois.setText(moisLettre);`
318	`noeudMemeAnnee.appendChild(node_mois) ;`	316	`noeudMemeAnnee.appendChild(node_mois) ;`
319	`String[] usObj = {moisLettre,mois,annee+mois};`	317	`String[] usObj = {moisLettre,mois,annee+mois};`
320	`node_mois.setUserObject(usObj);`	318	`node_mois.setUserObject(usObj);`
321		319
322	`TreeNode node_jour = new TreeNode();`	320	`TreeNode node_jour = new TreeNode();`
323	`node_jour.setId(""+(annee+mois+jour));`	321	`node_jour.setId(""+(annee+mois+jour));`
324	`node_jour.setText(jour);`	322	`node_jour.setText(jour);`
325	`node_mois.appendChild(node_jour) ;`	323	`node_mois.appendChild(node_jour) ;`
326	`String[] usObj2 = {jour,jour,annee+mois+jour};`	324	`String[] usObj2 = {jour,jour,annee+mois+jour};`
327	`node_jour.setUserObject(usObj2);`	325	`node_jour.setUserObject(usObj2);`
328		326
329	`}`	327	`}`
330	`}`	328	`}`
331	`else`	329	`else`
332	`{`	330	`{`
333	`TreeNode node_annee = new TreeNode();`	331	`TreeNode node_annee = new TreeNode();`
334	`node_annee.setId(""+annee);`	332	`node_annee.setId(""+annee);`
335	`node_annee.setText(annee);`	333	`node_annee.setText(annee);`
336	`root.appendChild(node_annee) ;`	334	`root.appendChild(node_annee) ;`
337	`String[] usObj = {annee, annee, annee};`	335	`String[] usObj = {annee, annee, annee};`
338	`node_annee.setUserObject(usObj);`	336	`node_annee.setUserObject(usObj);`
339		337
340	`TreeNode node_mois = new TreeNode();`	338	`TreeNode node_mois = new TreeNode();`
341	`node_mois.setId(""+(annee+mois));`	339	`node_mois.setId(""+(annee+mois));`
342	`node_mois.setText(moisLettre);`	340	`node_mois.setText(moisLettre);`
343	`node_annee.appendChild(node_mois) ;`	341	`node_annee.appendChild(node_mois) ;`
344	`String[] usObj2 = {moisLettre,mois,annee+mois};`	342	`String[] usObj2 = {moisLettre,mois,annee+mois};`
345	`node_mois.setUserObject(usObj2);`	343	`node_mois.setUserObject(usObj2);`
346		344
347	`TreeNode node_jour = new TreeNode();`	345	`TreeNode node_jour = new TreeNode();`
348	`node_jour.setId(""+(annee+mois+jour));`	346	`node_jour.setId(""+(annee+mois+jour));`
349	`node_jour.setText(jour);`	347	`node_jour.setText(jour);`
350	`node_mois.appendChild(node_jour) ;`	348	`node_mois.appendChild(node_jour) ;`
351	`String[] usObj3 = {jour,jour,annee+mois+jour};`	349	`String[] usObj3 = {jour,jour,annee+mois+jour};`
352	`node_jour.setUserObject(usObj3);`	350	`node_jour.setUserObject(usObj3);`
353	`}`	351	`}`
354		352
355	`}`	353	`}`
356		354
357		355
358	`// on trie`	356	`// on trie`
359	`root.sort(comparerNoeuds()) ;`	357	`root.sort(comparerNoeuds()) ;`
360		358
361	`// on vide tous les noeuds`	359	`// on vide tous les noeuds`
362	`arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {`	360	`arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {`
363		361
364	`@Override`	362	`@Override`
365	`public boolean execute(Node node) {`	363	`public boolean execute(Node node) {`
366		364
367	`node.remove();`	365	`node.remove();`
368	`return true;`	366	`return true;`
369	`}`	367	`}`
370		368
371	`});`	369	`});`
372		370
373	`// et on recopie le nouvel arbre`	371	`// et on recopie le nouvel arbre`
374	`copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates`	372	`copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates`
375	`.getRootNode());`	373	`.getRootNode());`
376		374
377	`// si l'arbre n'était pas encore considéré comme instancié`	375	`// si l'arbre n'était pas encore considéré comme instancié`
378	`if (!estInstancie) {`	376	`if (!estInstancie) {`
379	`// on signale que oui`	377	`// on signale que oui`
380	`estInstancie = true;`	378	`estInstancie = true;`
381	`}`	379	`}`
382		380
383		381
384	`// l'état du filtre est réinitialisé`	382	`// l'état du filtre est réinitialisé`
385	`filtreModifie = false;`	383	`filtreModifie = false;`
386	`//show() ;`	384	`//show() ;`
387	`doLayout();`	385	`doLayout();`
388		386
389	`}`	387	`}`
390		388
391	`if(nouvelleDonnees instanceof Observation)`	389	`if(nouvelleDonnees instanceof Observation)`
392	`{`	390	`{`
393	`// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout`	391	`// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout`
394	`// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement`	392	`// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement`
395	`// de l'arbre`	393	`// de l'arbre`
396	`if(!arbreCharge) {`	394	`if(!arbreCharge) {`
397	`return;`	395	`return;`
398	`}`	396	`}`
399		397
400	`Observation ent = (Observation)nouvelleDonnees ;`	398	`Observation ent = (Observation)nouvelleDonnees ;`
401	`String dateSpl[] = ent.getDate().split("/") ;`	399	`String dateSpl[] = ent.getDate().split("/") ;`
402		400
403	`String annee= dateSpl[2];`	401	`String annee= dateSpl[2];`
404	`String mois= dateSpl[1];`	402	`String mois= dateSpl[1];`
405	`String jour= dateSpl[0];`	403	`String jour= dateSpl[0];`
406		404
407	`String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;`	405	`String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;`
408		406
409	`Node root = arbreDonneesDates.getRootNode() ;`	407	`Node root = arbreDonneesDates.getRootNode() ;`
410		408
411	`if(annee.contains("0000") \|\| annee.equals(null)) {`	409	`if(annee.contains("0000") \|\| annee.equals(null)) {`
412	`annee="Inconnue" ;`	410	`annee="Inconnue" ;`
413	`}`	411	`}`
414		412
415	`if(jour.contains("00") \|\| jour.equals(null)) {`	413	`if(jour.contains("00") \|\| jour.equals(null)) {`
416	`jour="Inconnue" ;`	414	`jour="Inconnue" ;`
417	`}`	415	`}`
418		416
419	`Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee);`	417	`Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee);`
420	`// si la région existe déjà`	418	`// si la région existe déjà`
421	`if(noeudMemeAnnee != null)`	419	`if(noeudMemeAnnee != null)`
422	`{`	420	`{`
423	`// on teste si la localité existe`	421	`// on teste si la localité existe`
424	`Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois));`	422	`Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois));`
425	`if(noeudMemeMois != null)`	423	`if(noeudMemeMois != null)`
426	`{`	424	`{`
427	`// enfin on teste si le lieu dit existe`	425	`// enfin on teste si le lieu dit existe`
428	`Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(annee+mois+jour));`	426	`Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(annee+mois+jour));`
429	`if(noeudMemeJour != null)`	427	`if(noeudMemeJour != null)`
430	`{`	428	`{`
431	`// tous les noeuds existent déjà, normalement ça ne devrait pas arriver`	429	`// tous les noeuds existent déjà, normalement ça ne devrait pas arriver`
432	`}`	430	`}`
433	`else`	431	`else`
434	`{`	432	`{`
435	`// enfin on ne crée que le noeud du lieu dit`	433	`// enfin on ne crée que le noeud du lieu dit`
436	`TreeNode node_jour = new TreeNode();`	434	`TreeNode node_jour = new TreeNode();`
437	`node_jour.setId(""+(annee+mois+jour));`	435	`node_jour.setId(""+(annee+mois+jour));`
438	`node_jour.setText(jour);`	436	`node_jour.setText(jour);`
439	`String[] usObj = {jour,jour,annee+mois+jour};`	437	`String[] usObj = {jour,jour,annee+mois+jour};`
440	`node_jour.setUserObject(usObj);`	438	`node_jour.setUserObject(usObj);`
441	`noeudMemeMois.appendChild(node_jour) ;`	439	`noeudMemeMois.appendChild(node_jour) ;`
442		440
443	`root.sort(comparerNoeuds()) ;`	441	`root.sort(comparerNoeuds()) ;`
444	`}`	442	`}`
445	`}`	443	`}`
446	`else`	444	`else`
447	`{`	445	`{`
448	`TreeNode node_mois = new TreeNode();`	446	`TreeNode node_mois = new TreeNode();`
449	`node_mois.setId(""+(annee+mois));`	447	`node_mois.setId(""+(annee+mois));`
450	`node_mois.setText(moisLettre);`	448	`node_mois.setText(moisLettre);`
451	`String[] usObj = {moisLettre,mois,annee+mois};`	449	`String[] usObj = {moisLettre,mois,annee+mois};`
452	`node_mois.setUserObject(usObj);`	450	`node_mois.setUserObject(usObj);`
453	`noeudMemeAnnee.appendChild(node_mois) ;`	451	`noeudMemeAnnee.appendChild(node_mois) ;`
454		452
455	`TreeNode node_jour = new TreeNode();`	453	`TreeNode node_jour = new TreeNode();`
456	`node_jour.setId(""+(annee+mois+jour));`	454	`node_jour.setId(""+(annee+mois+jour));`
457	`node_jour.setText(jour);`	455	`node_jour.setText(jour);`
458	`String[] usObj2 = {jour,jour,annee+mois+jour};`	456	`String[] usObj2 = {jour,jour,annee+mois+jour};`
459	`node_jour.setUserObject(usObj2);`	457	`node_jour.setUserObject(usObj2);`
460	`node_mois.appendChild(node_jour) ;`	458	`node_mois.appendChild(node_jour) ;`
461		459
462	`root.sort(comparerNoeuds()) ;`	460	`root.sort(comparerNoeuds()) ;`
463	`}`	461	`}`
464	`}`	462	`}`
465	`else`	463	`else`
466	`{`	464	`{`
467		465
468	`TreeNode node_annee = new TreeNode();`	466	`TreeNode node_annee = new TreeNode();`
469	`node_annee.setId(""+annee);`	467	`node_annee.setId(""+annee);`
470	`node_annee.setText(annee);`	468	`node_annee.setText(annee);`
471	`String[] usObj = {annee,annee,annee};`	469	`String[] usObj = {annee,annee,annee};`
472	`node_annee.setUserObject(usObj);`	470	`node_annee.setUserObject(usObj);`
473	`root.appendChild(node_annee) ;`	471	`root.appendChild(node_annee) ;`
474		472
475	`TreeNode node_mois = new TreeNode();`	473	`TreeNode node_mois = new TreeNode();`
476	`node_mois.setId(""+(annee+mois));`	474	`node_mois.setId(""+(annee+mois));`
477	`node_mois.setText(moisLettre);`	475	`node_mois.setText(moisLettre);`
478	`String[] usObj2 = {moisLettre,mois,annee+mois};`	476	`String[] usObj2 = {moisLettre,mois,annee+mois};`
479	`node_mois.setUserObject(usObj2);`	477	`node_mois.setUserObject(usObj2);`
480	`node_annee.appendChild(node_mois) ;`	478	`node_annee.appendChild(node_mois) ;`
481		479
482	`TreeNode node_jour = new TreeNode();`	480	`TreeNode node_jour = new TreeNode();`
483	`node_jour.setId(""+(annee+mois+jour));`	481	`node_jour.setId(""+(annee+mois+jour));`
484	`node_jour.setText(jour);`	482	`node_jour.setText(jour);`
485	`String[] usObj3 = {jour,jour,annee+mois+jour};`	483	`String[] usObj3 = {jour,jour,annee+mois+jour};`
486	`node_jour.setUserObject(usObj3);`	484	`node_jour.setUserObject(usObj3);`
487	`node_mois.appendChild(node_jour) ;`	485	`node_mois.appendChild(node_jour) ;`
488		486
489	`// TODO : améliorer la compararaison des noeuds`	487	`// TODO : améliorer la compararaison des noeuds`
490	`root.sort(comparerNoeuds()) ;`	488	`root.sort(comparerNoeuds()) ;`
491	`}`	489	`}`
492		490
493	`arbreDonneesDates.doLayout() ;`	491	`arbreDonneesDates.doLayout() ;`
494	`}`	492	`}`
495	`}`	493	`}`
496		494
497		495
498	`/**`	496	`/**`
499	`* Accesseur pour le panneau contenant l'arbre`	497	`* Accesseur pour le panneau contenant l'arbre`
500	`*`	498	`*`

Subversion Repositories eFlore/Applications.cel

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