Subversion Repositories eFlore/Archives.cel-v2

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.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.WindowListenerAdapter;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
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 Window implements Rafraichissable, Filtrable {

        /**
         * Le médiateur associé à la vue
         */
        private ImageMediateur iMediateur = null ;
        /**
         * Les mots clés en cours
         */
        private String motsClesEncours = "" ;
        
        /**
         * Le treepanel qui affiche l'arbre
         */
        private TreePanel arbreMotsCles = null ;
        
        /**
         * Bouton rechercher
         */
        private Button rechercher = null ;
        
        /**
         * booléen d'initialisation
         */
        private boolean estInstancie = false ;
        
        /**
         * booléen d'etat
         */
        private boolean filtreModifie = false ;
        
        /**
         * Constructeur sans argument (privé car ne doit pas être utilisé)
         */
        private ArbreMotsClesFiltreVue()
        {
                super() ;
        }
        
        /**
         * Constructeur avec paramètres
         * @param im le médiateur à associer
         */
        public ArbreMotsClesFiltreVue(ImageMediateur im)
        {
                
                // on crée le panel
                super("Mots clés") ;
                this.setLayout(new RowLayout());
                iMediateur = im ;
                
                // on crée le conteneur de l'arbre
                arbreMotsCles = new TreePanel() ;
                // on permet le drag and drop dans l'arbre
                arbreMotsCles.setEnableDD(true) ;
                arbreMotsCles.setId("x-view-tree-filter") ;
                arbreMotsCles.setAutoWidth(true) ;
                //arbreMotsCles.setAutoScroll(true) ;
                arbreMotsCles.setBorder(false) ;
                
                // on crée une racine pour l'arbre
                TreeNode root = new TreeNode("Tags") ;
                root.setId("racine_filtre") ;
                String[] usObject = {"Mots clés" , "racine" } ;
                root.setUserObject(usObject) ;
                
                arbreMotsCles.setRootNode(root) ;
                arbreMotsCles.setRootVisible(false) ;
                arbreMotsCles.getRootNode().setIcon("tela.png") ;
                arbreMotsCles.setBorder(false) ;
                
                rechercher = new Button("Rechercher") ;
                
                // on met en forme le layout
                this.add(arbreMotsCles,new RowLayoutData("90%")) ;
                this.add(rechercher,new RowLayoutData("10%")) ;
                
                this.setBorder(false) ;
                this.setCollapsible(true) ;
                this.setCloseAction(HIDE) ;
                
                // on ajoute les listeners
                ajouterListeners() ;
                estInstancie = true ;
        }
        
        /**
         * Ajoute les listeners
         */
        private void ajouterListeners()
        {
                // gestion de la validation
                rechercher.addListener(new ButtonListenerAdapter() {

                        
                        public void onClick(Button button, EventObject e) {
                                
                                // on vide les mots clés en cours
                                motsClesEncours = "" ;
                                // pour chaque noeud à partir de la racine
                                getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
                                
                                // on éxécute une fonction
                                public boolean execute(Node node) {
                                
                                                // on récupère le mot clé associé au noeud et ses infos
                                                TreeNode tn = getArbreMotsCles().getNodeById(node.getId()) ;

                                                        String[] usObject =  (String[])tn.getUserObject() ;
                                                        getIMediateur().mettreAjourMotsClesId(usObject[0],usObject[1]) ;
                                                                
                                                                if(tn.getUI().isChecked())
                                                                {
                                                                        // et les concatène à la string des mots clés en cours
                                                                        motsClesEncours += usObject[1]+"," ;
                                                                }
                                                
                                                return true ;
                                        }
                                                
                                });
                                
                                // on suppose que le filtre a change
                                filtreModifie = true ;
                                // enfin on notifie le médiateur et on lui passe l'arbre et la liste des mots clés ainsi obtenue
                                getIMediateur().obtenirPhotoGalerie(getIMediateur().getFiltreMotsCles()) ;      
                        }

                }) ;
                
                // gestion de la fermeture du panneau
                this.addListener(new WindowListenerAdapter() {
                        
                        
                        public void onClose(Panel panel) {
                                
                                arbreMotsCles.getRootNode().destroy() ;
                                
                                // on crée une racine pour l'arbre
                                TreeNode root = new TreeNode("Tags") ;
                                root.setId("racine_filtre") ;
                                String[] usObject = {"Mots clés" , "racine" } ;
                                root.setUserObject(usObject) ;
                                arbreMotsCles.setRootNode(root) ;
                        }
                }) ;
        }
        
        /**
         * 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)
                {
                                Tree nouvelArbre = (Tree)nouvelleDonnees ;
                                
                                arbreMotsCles.getRootNode().eachChild(new NodeTraversalCallback() {


                                        public boolean execute(Node node) {
                                                
                                                node.remove() ;
                                                return true ;
                                        }
                                        
                                        
                                }) ;
                                
                                copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles.getRootNode()) ;
                                
                                        getArbreMotsCles().expandAll() ;
                                        
                                        // si l'arbre n'était pas encore considéré comme instancié
                                        if(!estInstancie)
                                        {
                                                // on signale que oui
                                                estInstancie = true ;
                                        }
                                        
                                        filtreModifie = false ;
                                        
                                        setSize(200, 300) ;
                                        show() ;
                }
                
        }
        
        /**
         * Accesseur pour le médiateur
         * @return le médiateur associé
         */
        public ImageMediateur getIMediateur()
        {
                return iMediateur ;
        }
        
        /**
         * Accesseur pour le panneau contenant l'arbre
         * @return le panneau de l'arbre des mots clés
         */
        public TreePanel getArbreMotsCles()
        {
                return arbreMotsCles ;
        }
        
        /**
         * Méthode héritée de Filtrable
         * renvoie le nom du filtre
         */
        public String renvoyerNomFiltre() {
                
                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() {
                
                String[] valeursFiltrees = {"ci_meta_mots_cles",motsClesEncours} ;
                
                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)
        {
                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.setIcon("tela.png") ;
                        child.setChecked(false);
                        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 nom)
         */
        public boolean renvoyerEtatFiltre() {
                
                return filtreModifie ;
        }

}