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

 package org.tela_botanica.client.vues;
 import org.tela_botanica.client.image.ImageMediateur;
 import org.tela_botanica.client.interfaces.Filtrable;
 import org.tela_botanica.client.interfaces.Rafraichissable;
 import com.google.gwt.user.client.ui.Label;
 import com.gwtext.client.data.Node;
 import com.gwtext.client.data.NodeTraversalCallback;
 import com.gwtext.client.data.Tree;
 import com.gwtext.client.widgets.Component;
 import com.gwtext.client.widgets.Panel;
 import com.gwtext.client.widgets.event.PanelListenerAdapter;
 import com.gwtext.client.widgets.tree.TreeNode;
 import com.gwtext.client.widgets.tree.TreePanel;
 /**
  * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
  * cliquable
+ *
  * @author aurelien
  *
  */
-public class ArbreMotsClesFiltreVue extends Panel implements Rafraichissable, Filtrable {
+public class ArbreMotsClesFiltreVue extends Panel implements Rafraichissable,
+		Filtrable {
 	/**
 	 * Le médiateur associé à la vue
 	 */
-	private ImageMediateur iMediateur = null ;
+	private ImageMediateur iMediateur = null;
 	/**
 	 * Les mots clés en cours
 	 */
-	private String motsClesEncours = "" ;
+	private String motsClesEncours = "";
 	/**
 	 * Le treepanel qui affiche l'arbre
 	 */
-	private TreePanel arbreMotsCles = null ;
+	private TreePanel arbreMotsCles = null;
 	/**
 	 * booléen d'initialisation
 	 */
-	private boolean estInstancie = false ;
+	private boolean estInstancie = false;
 	/**
 	 * booléen d'etat
 	 */
-	private boolean filtreModifie = false ;
+	private boolean filtreModifie = false;
 	/**
 	 * Constructeur sans argument (privé car ne doit pas être utilisé)
 	 */
 	@SuppressWarnings("unused")
-	private ArbreMotsClesFiltreVue()
+	private ArbreMotsClesFiltreVue() {
-	{
-		super() ;
+		super();
+	}
 	/**
 	 * Constructeur avec paramètres
+	 *
+	 * @param im
-	 * @param im le médiateur à associer
+	 *            le médiateur à associer
 	 */
-	public ArbreMotsClesFiltreVue(ImageMediateur im)
+	public ArbreMotsClesFiltreVue(ImageMediateur im) {
-	{
 		// on crée le panel
-		super() ;
+		super();
-		//this.setLayout(new VerticalLayout());
+		// this.setLayout(new VerticalLayout());
-		iMediateur = im ;
+		iMediateur = im;
 		// on crée le conteneur de l'arbre
-		Label labelRecherche = new Label("Mots clés :") ;
+		Label labelRecherche = new Label("Mots clés :");
-		arbreMotsCles = new TreePanel() ;
+		arbreMotsCles = new TreePanel();
-		this.setPaddings(5) ;
+		this.setPaddings(5);
-		this.setBorder(false) ;
+		this.setBorder(false);
-		this.setCollapsible(true) ;
+		this.setCollapsible(true);
-		this.setAutoWidth(true) ;
+		this.setAutoWidth(true);
-		add(labelRecherche) ;
+		add(labelRecherche);
 		// on ajoute les listeners
-		ajouterListenersPanel() ;
+		ajouterListenersPanel();
-		estInstancie = false ;
+		estInstancie = false;
+	}
 	/**
 	 * Ajoute les listeners pour le rendu du panel
 	 */
-	private void ajouterListenersPanel()
+	private void ajouterListenersPanel() {
-	{
 		this.addListener(new PanelListenerAdapter() {
+			// on instancie réellement les composants au moment du rendu pour
-			// on instancie réellement les composants au moment du rendu pour accélérer l'affichage
+			// accélérer l'affichage
 			// et éviter des bugs
 			public void onRender(Component component) {
 				// on interdit le drag and drop dans l'arbre
-				arbreMotsCles.setEnableDD(false) ;
+				arbreMotsCles.setEnableDD(false);
-				arbreMotsCles.setId("x-view-tree-filter") ;
+				arbreMotsCles.setId("x-view-tree-filter");
-				arbreMotsCles.setAutoWidth(false) ;
+				arbreMotsCles.setAutoWidth(false);
-				arbreMotsCles.setAutoScroll(true) ;
+				arbreMotsCles.setAutoScroll(true);
-				arbreMotsCles.setBorder(false) ;
+				arbreMotsCles.setBorder(false);
 				// on crée une racine pour l'arbre
-				TreeNode root = new TreeNode("Tags") ;
+				TreeNode root = new TreeNode("Tags");
-				root.setId("racine_filtre") ;
+				root.setId("racine_filtre");
-				String[] usObject = {"Mots clés" , "racine" } ;
+				String[] usObject = { "Mots clés", "racine" };
-				root.setUserObject(usObject) ;
+				root.setUserObject(usObject);
-				arbreMotsCles.setRootNode(root) ;
+				arbreMotsCles.setRootNode(root);
-				arbreMotsCles.setRootVisible(true) ;
+				arbreMotsCles.setRootVisible(true);
-				arbreMotsCles.setBorder(false) ;
+				arbreMotsCles.setBorder(false);
 				// on met en forme le layout
-				((Panel)component).add(arbreMotsCles) ;
+				((Panel) component).add(arbreMotsCles);
 				// on ajoute les listeners d'évenements
-				ajouterListeners() ;
+				ajouterListeners();
+				// et on demande l'arbre des mots clés
+				getIMediateur()
-				// et on demande l'arbre des mots clés
+						.obtenirArbreMotsCles(
+								getIMediateur().getPanneauFiltres()
-				getIMediateur().obtenirArbreMotsCles(getIMediateur().getPanneauFiltres().getMotsClesFiltre()) ;
+										.getMotsClesFiltre());
 				// enfin on considère le composant comme instancié
-				estInstancie = true ;
+				estInstancie = true;
 			}
-		}) ;
+		});
 	}
 	/**
 	 * ajoute les listeners pour les boutons et le cochage des mots clés
 	 */
-	private void ajouterListeners()
 	private void ajouterListeners() {
+	}
 	/**
 	 * Méthode héritée de l'interface rafraichissable
 	 */
 	public void rafraichir(Object nouvelleDonnees,
 			boolean repandreRaffraichissement) {
 		// si on a reçu un arbre
-		if(nouvelleDonnees instanceof Tree)
+		if (nouvelleDonnees instanceof Tree) {
-		{
-				Tree nouvelArbre = (Tree)nouvelleDonnees ;
+			Tree nouvelArbre = (Tree) nouvelleDonnees;
-				// on vide tous les noeuds
+			// on vide tous les noeuds
-				arbreMotsCles.getRootNode().eachChild(new NodeTraversalCallback() {
+			arbreMotsCles.getRootNode().eachChild(new NodeTraversalCallback() {
-					public boolean execute(Node node) {
+				public boolean execute(Node node) {
-						node.remove() ;
+					node.remove();
-						return true ;
+					return true;
-					}
+				}
-				}) ;
+			});
-				// et on recopie le nouvel arbre
+			// et on recopie le nouvel arbre
-				copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles.getRootNode()) ;
+			copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles
+					.getRootNode());
-					// si l'arbre n'était pas encore considéré comme instancié
+			// si l'arbre n'était pas encore considéré comme instancié
-					if(!estInstancie)
+			if (!estInstancie) {
-					{
-						// on signale que oui
+				// on signale que oui
-						estInstancie = true ;
+				estInstancie = true;
-					}
+			}
-					// l'état du filtre est réinitialisé
+			// l'état du filtre est réinitialisé
-					filtreModifie = false ;
+			filtreModifie = false;
-					show() ;
+			show();
+		}
-		if(nouvelleDonnees instanceof TreeNode)
+		if (nouvelleDonnees instanceof TreeNode) {
-		{
-			TreeNode nd = (TreeNode)nouvelleDonnees ;
+			TreeNode nd = (TreeNode) nouvelleDonnees;
 			// si le noeud n'existe pas déjà c'est un ajout
-			if(arbreMotsCles.getTree().getNodeById(nd.getId()+"_filtre") == null)
+			if (arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre") == null) {
-			{
 				// donc on ne fait rien de spécial
+			}
 			// si le noeud existe déjà c'est un déplacement
-			else
+			else {
-			{
 				// alors on supprime d'abord le noeud concerné
-				arbreMotsCles.getTree().getNodeById(nd.getId()+"_filtre").remove() ;
+				arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre")
+						.remove();
+			}
 			// on cherche le père du nouveau noeud
-			Node ndPereOriginal = nd.getParentNode() ;
+			Node ndPereOriginal = nd.getParentNode();
-			String idPereFiltre = ndPereOriginal.getId()+"_filtre" ;
+			String idPereFiltre = ndPereOriginal.getId() + "_filtre";
-			String[] usObj = (String[])nd.getUserObject() ;
+			String[] usObj = (String[]) nd.getUserObject();
-			TreeNode child = new TreeNode(usObj[0]) ;
+			TreeNode child = new TreeNode(usObj[0]);
-			child.setId(usObj[1]+"_filtre") ;
+			child.setId(usObj[1] + "_filtre");
 			child.setChecked(false);
-			child.setUserObject(usObj) ;
+			child.setUserObject(usObj);
-			arbreMotsCles.getNodeById(idPereFiltre).appendChild(child) ;
+			arbreMotsCles.getNodeById(idPereFiltre).appendChild(child);
 			// et on ajoute le nouveau noeud à son père
-			copierFilsNoeud(nd, child) ;
+			copierFilsNoeud(nd, child);
+		}
 		// si on reçoit une string
-		if(nouvelleDonnees instanceof String)
+		if (nouvelleDonnees instanceof String) {
-		{
-			String idSupp = (String)nouvelleDonnees+"_filtre" ;
+			String idSupp = (String) nouvelleDonnees + "_filtre";
 			// c'est une suppression et si le noeud existe bien
-			if(arbreMotsCles.getTree().getNodeById(idSupp) != null)
+			if (arbreMotsCles.getTree().getNodeById(idSupp) != null) {
-			{
 				// on le supprime
-				arbreMotsCles.getTree().getNodeById(idSupp).remove() ;
+				arbreMotsCles.getTree().getNodeById(idSupp).remove();
+			}
+		}
+	}
 	/**
 	 * Accesseur pour le médiateur
+	 *
 	 * @return le médiateur associé
 	 */
-	public ImageMediateur getIMediateur()
+	public ImageMediateur getIMediateur() {
-	{
-		return iMediateur ;
+		return iMediateur;
+	}
 	/**
 	 * Accesseur pour le panneau contenant l'arbre
+	 *
 	 * @return le panneau de l'arbre des mots clés
 	 */
-	public TreePanel getArbreMotsCles()
+	public TreePanel getArbreMotsCles() {
-	{
-		return arbreMotsCles ;
+		return arbreMotsCles;
+	}
 	/**
-	 * Méthode héritée de Filtrable
+	 * Méthode héritée de Filtrable renvoie le nom du filtre
-	 * renvoie le nom du filtre
 	 */
 	public String renvoyerNomFiltre() {
-		return "mots clés" ;
+		return "mots clé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() ;
+		valider();
-		String[] valeursFiltrees = {"ci_meta_mots_cles",motsClesEncours} ;
+		String[] valeursFiltrees = { "ci_meta_mots_cles", motsClesEncours };
-		return valeursFiltrees ;
+		return valeursFiltrees;
 	}
 	/**
-	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un copie du sous arbre du premier
+	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
-	 * noeud, qu'elle concatène au deuxième
+	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
+	 *
+	 * @param ndPereOriginal
-	 * @param ndPereOriginal le père des noeuds de l'arbre original
+	 *            le père des noeuds de l'arbre original
+	 * @param ndPereCopie
-	 * @param ndPereCopie le père qui va recevoir les copies
+	 *            le père qui va recevoir les copies
 	 */
-	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie)
+	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
-	{
-		if(ndPereCopie != null && ndPereOriginal != null)
+		if (ndPereCopie != null && ndPereOriginal != null) {
-		{
-			Node[] ndNodeFils = ndPereOriginal.getChildNodes() ;
+			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 			for (int i = 0; i < ndNodeFils.length; i++) {
-				String[] usObj = (String[])ndNodeFils[i].getUserObject() ;
+				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
-				TreeNode child = new TreeNode(usObj[0]) ;
+				TreeNode child = new TreeNode(usObj[0]);
-				child.setId(usObj[1]+"_filtre") ;
+				child.setId(usObj[1] + "_filtre");
 				child.setChecked(false);
-				child.setUserObject(usObj) ;
+				child.setUserObject(usObj);
-				ndPereCopie.appendChild(child) ;
+				ndPereCopie.appendChild(child);
-				if(! ndNodeFils[i].isLeaf())
+				if (!ndNodeFils[i].isLeaf()) {
-				{
-					copierFilsNoeud(ndNodeFils[i],child) ;
+					copierFilsNoeud(ndNodeFils[i], child);
+				}
+			}
+		}
+	}
 	/**
-	 * Méthode héritée de Filtrable
-	 * Renvoie l'état du filtre (modifié ou non)
+	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
 	 */
 	public boolean renvoyerEtatFiltre() {
-		return filtreModifie ;
+		return filtreModifie;
+	}
-	public void valider()
+	public void valider() {
-	{
-		if(estInstancie)
+		if (estInstancie) {
-		{
 			// on vide les mots clés en cours
-			motsClesEncours = "" ;
+			motsClesEncours = "";
 			// pour chaque noeud à partir de la racine
-			getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
+			getArbreMotsCles().getRootNode().cascade(
+					new NodeTraversalCallback() {
-			// on éxécute une fonction
+						// on éxécute une fonction
-			public boolean execute(Node node) {
+						public boolean execute(Node node) {
-					// on récupère le mot clé associé au noeud et ses infos
+							// on récupère le mot clé associé au noeud et ses
+							// infos
-					TreeNode tn = getArbreMotsCles().getNodeById(node.getId()) ;
+							TreeNode tn = getArbreMotsCles().getNodeById(
+									node.getId());
-						String[] usObject =  (String[])tn.getUserObject() ;
+							String[] usObject = (String[]) tn.getUserObject();
-						getIMediateur().mettreAjourMotsClesId(usObject[0],usObject[1]) ;
+							getIMediateur().mettreAjourMotsClesId(usObject[0],
+									usObject[1]);
-							if(tn.getUI().isChecked())
+							if (tn.getUI().isChecked()) {
-							{
-								// et les concatène à la string des mots clés en cours
+								// et les concatène à la string des mots clés en
+								// cours
-								motsClesEncours += usObject[1]+"," ;
+								motsClesEncours += usObject[1] + ",";
+							}
-					return true ;
+							return true;
-				}
+						}
-			});
+					});
 			// on suppose que le filtre a change
-			filtreModifie = true ;
+			filtreModifie = true;
+		}
+	}
+}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java @ 34 – Rev 2 → 5