WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/vues/ArbreEntiteGeographiqueObservationFiltreVue.java


package org.tela_botanica.client.vues;
 
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.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.Observation;
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.data.event.NodeListenerAdapter;
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;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
 
/**
 * 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 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.setCollapsible(true);
		this.setAutoWidth(true);
		
		if (GWT.isScript()) {
			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
				arbreEntitesGeographiques.setEnableDD(false);
				arbreEntitesGeographiques.setId("x-view-tree-filter-entity");
				arbreEntitesGeographiques.setAutoWidth(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 = "" ;
				entitesGeographiquesEncours = "" ;
				String nomPere = "" ;
				String nomGrandPere = "" ;
				
				switch(node.getDepth()) 
				{
					case 0:
						if(!arbreCharge)
						{
 
 
							/*observationMediateur.obtenirListeEntiteGeographique() ;
							arbreCharge = true ;*/
							arbreEntitesGeographiques.getRootNode().expand();
						}
						else 
						{
							observationMediateur.obtenirNombreObservation() ;
						}
						return ;
					case 3: nomFiltre += "lieudit,location,id_location";
						nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
						nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
						entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ;
						break;
					case 2: nomFiltre += "location,id_location"; 
						nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
						entitesGeographiquesEncours += node.getText()+","+nomPere ;
						break;
					case 1: nomFiltre += "id_location"; 
						entitesGeographiquesEncours += node.getText() ;
						break;
					default: 
						break;
				}
				
				filtreModifie = true ;
				observationMediateur.obtenirNombreObservation() ;
				
			}
			
		}) ;
		
		arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
			
			public void onExpand(Node node) {
				if(!arbreCharge)
				{
 
 
					observationMediateur.obtenirListeEntiteGeographique() ;
					arbreCharge = true ;
				}
			}
			
		}) ;
	}
 
	/**
	 * Méthode héritée de l'interface rafraichissable
	 */
	public void rafraichir(Object nouvelleDonnees,
			boolean repandreRaffraichissement) {
 
		
		if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) {
		
			String id_location=null;
			String location=null;
			String lieuDit=null;
			
			ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ;
		
				// on crée un arbre vide
				TreeNode root = new TreeNode();
				root.setId("racine_entite");
				root.setText("Localités");
				String[] usObjRoot = { "Localités"};
				root.setUserObject(usObjRoot);
				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());
				
				id_location=ent.getIdLocation();
				id_location = id_location.replaceAll("\"", "");
				location=ent.getLocation();
				lieuDit=ent.getLieuDit();
				
				if(id_location.contains("000null") || id_location.equals(null) || (id_location.trim()).equals("")) {
					id_location="Inconnue" ;
				}
				
				if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) {
					location="Inconnue" ;
				}
				
				if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
					lieuDit="Inconnue" ;
				}
				
				Node noeudMemeId = donneeEntitesGeographiques.getNodeById(""+id_location);
				// si la région existe déjà
					if(noeudMemeId != null)
					{
						// on teste si la localité existe
						Node noeudMemeLoc = donneeEntitesGeographiques.getNodeById(""+(id_location+location));
						if(noeudMemeLoc != null)
						{
							// enfin on teste si le lieu dit existe
							Node noeudMemeLieu = donneeEntitesGeographiques.getNodeById(""+(id_location+location+lieuDit));
							if(noeudMemeLieu != 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_lieu = new TreeNode();
								node_lieu.setId(""+(id_location+location+lieuDit));
								node_lieu.setText(lieuDit);
								noeudMemeLoc.appendChild(node_lieu) ;
								String[] usObj = {lieuDit};
								node_lieu.setUserObject(usObj);
							}
						}
						else
						{
							TreeNode node_loc = new TreeNode();
							node_loc.setId(""+(id_location+location));
							node_loc.setText(location);
							noeudMemeId.appendChild(node_loc) ;
							String[] usObj = {location};
							node_loc.setUserObject(usObj);
							
							TreeNode node_lieu = new TreeNode();
							node_lieu.setId(""+(id_location+location+lieuDit));
							node_lieu.setText(lieuDit);
							node_loc.appendChild(node_lieu) ;
							String[] usObj2 = {lieuDit};
							node_lieu.setUserObject(usObj2);
							
						}
					}
					else
					{
						TreeNode node_id_loc = new TreeNode();
						node_id_loc.setId(""+id_location);
						node_id_loc.setText(id_location);
						root.appendChild(node_id_loc) ;
						String[] usObj = {id_location};
						node_id_loc.setUserObject(usObj);
						
						TreeNode node_loc = new TreeNode();
						node_loc.setId(""+(id_location+location));
						node_loc.setText(location);
						node_id_loc.appendChild(node_loc) ;
						String[] usObj2 = {location};
						node_loc.setUserObject(usObj2);
						
						TreeNode node_lieu = new TreeNode();
						node_lieu.setId(""+(id_location+location+lieuDit));
						node_lieu.setText(lieuDit);
						node_loc.appendChild(node_lieu) ;
						String[] usObj3 = {lieuDit};
						node_lieu.setUserObject(usObj3);
					}
					
					root.sort(comparerNoeuds()) ;
					doLayout();
 
				}
			
				// 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();
 
			}
		
		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 obs = (Observation)nouvelleDonnees ;
			
			String id_location= obs.getIdentifiantLocalite();
			id_location = id_location.replaceAll("\"", "");
			String location=obs.getLocalite();
			String lieuDit=obs.getLieudit();
			
			Node root = arbreEntitesGeographiques.getRootNode() ;
			
			if(id_location.contains("000null") || id_location.equals(null) || (id_location.trim()).equals("")) {
				id_location="Inconnue" ;
			}
			
			if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) {
				location="Inconnue" ;
			}
			
			if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
				lieuDit="Inconnue" ;
			}
			
			Node noeudMemeId = donneeEntitesGeographiques.getNodeById(""+id_location);
			// si la région existe déjà
				if(noeudMemeId != null)
				{
					// on teste si la localité existe
					Node noeudMemeLoc = donneeEntitesGeographiques.getNodeById(""+(id_location+location));
					if(noeudMemeLoc != null)
					{
						// enfin on teste si le lieu dit existe
						Node noeudMemeLieu = donneeEntitesGeographiques.getNodeById(""+(id_location+location+lieuDit));
						if(noeudMemeLieu != 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_lieu = new TreeNode();
							node_lieu.setId(""+(id_location+location+lieuDit));
							node_lieu.setText(lieuDit);
							String[] usObj = {lieuDit};
							node_lieu.setUserObject(usObj);
							noeudMemeLoc.appendChild(node_lieu) ;
							
							root.sort(comparerNoeuds()) ;
						}
					}
					else
					{
						TreeNode node_loc = new TreeNode();
						node_loc.setId(""+(id_location+location));
						node_loc.setText(location);
						String[] usObj = {location};
						node_loc.setUserObject(usObj);
						noeudMemeId.appendChild(node_loc) ;
						
						TreeNode node_lieu = new TreeNode();
						node_lieu.setId(""+(id_location+location+lieuDit));
						node_lieu.setText(lieuDit);
						String[] usObj2 = {lieuDit};
						node_lieu.setUserObject(usObj2);
						node_loc.appendChild(node_lieu) ;
						
						root.sort(comparerNoeuds()) ;
						
					}
			}
			else
			{
				// TODO: Pourquoi l'ajout ne marche que sur la racine ?
				
				TreeNode node_id_loc = new TreeNode();
				node_id_loc.setId(""+id_location);
				node_id_loc.setText(id_location);
				String[] usObj = {id_location};
				node_id_loc.setUserObject(usObj);
				root.appendChild(node_id_loc) ;
				
				TreeNode node_loc = new TreeNode();
				node_loc.setId(""+(id_location+location));
				node_loc.setText(location);
				String[] usObj2 = {location};
				node_loc.setUserObject(usObj2);
				node_id_loc.appendChild(node_loc) ;
				
				TreeNode node_lieu = new TreeNode();
				node_lieu.setId(""+(id_location+location+lieuDit));
				node_lieu.setText(lieuDit);
				String[] usObj3 = {lieuDit};
				node_lieu.setUserObject(usObj3);
				node_loc.appendChild(node_lieu) ;
				
				root.sort(comparerNoeuds()) ;
				
			}	
				arbreEntitesGeographiques.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) {
			
		}
	}
	
	public Comparator<TreeNode> comparerNoeuds()
	{
		return new Comparator<TreeNode>() {
 
			public int compare(TreeNode o1, TreeNode o2) {
				
				if(o1.getText().equals("Inconnue")) {
					return -1 ;
				}
				
				if(o2.getText().equals("Inconnue")) {
					return 1 ;
				}
				
				if(o1.getDepth() == 1 && o2.getDepth() == 1)
				{
					String l1 = o1.getText() ;
					String l2 = o2.getText() ;
					if(l1.length() == 1) {
						l1 = "0"+l1;
					}
					
					if(l2.length() == 1) {
						l2 = "0"+l2;
					}
					
					Integer n1 = 0;
					Integer n2 = 0;
					
					try{
						n1 = Integer.parseInt(l1) ;
						n2 = Integer.parseInt(l2) ;
					} catch(NumberFormatException ne)  {
						n1 = 0;
						n2 = 0;
					}
					
					return n1.compareTo(n2) ;
				}
				else
				{	
					String n1 = o1.getText() ;
					String n2 = o2.getText() ;
				
					return n1.compareTo(n2) ;
				}
			}
		} ;
	}
 
	public void raz() {
			
		arbreCharge = false ;
		arbreEntitesGeographiques.clear() ;
		
		// 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.getRootNode().addListener(new TreeNodeListenerAdapter() {
			
			public void onExpand(Node node) {
				if(!arbreCharge)
				{
					observationMediateur.obtenirDatesObservation() ;
					arbreCharge = true ;
				}
			}
			
		}) ;
		
		arbreCharge = false ;
		
		this.doLayout() ;
		
	}
	
}

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

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/ArbreEntiteGeographiqueObservationFiltreVue.java @ 130 – Rev 109 → 128