Subversion Repositories eFlore/Applications.cel

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 {

        /**
         * 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 ;
        
        /**
         * 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é)
         */
        @SuppressWarnings("unused")
        private ArbreMotsClesFiltreVue()
        {
                super() ;
        }
        
        /**
         * Constructeur avec paramètres
         * @param im le médiateur à associer
         */
        public ArbreMotsClesFiltreVue(ImageMediateur im)
        {
                
                // on crée le panel
                super() ;
                //this.setLayout(new VerticalLayout());
                iMediateur = im ;
                
                // on crée le conteneur de l'arbre
                Label labelRecherche = new Label("Mots clés :") ;
                arbreMotsCles = new TreePanel() ;
                
                this.setPaddings(5) ;
                
                this.setBorder(false) ;
                this.setCollapsible(true) ;
                this.setAutoWidth(true) ;
                
                add(labelRecherche) ;
                
                // 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
                                arbreMotsCles.setEnableDD(false) ;
                                arbreMotsCles.setId("x-view-tree-filter") ;
                                arbreMotsCles.setAutoWidth(false) ;
                                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(true) ;
                                arbreMotsCles.setBorder(false) ;
                                
                                
                                // on met en forme le layout
                                ((Panel)component).add(arbreMotsCles) ;
                                
                                // on ajoute les listeners d'évenements
                                ajouterListeners() ;
                                
                                // et on demande l'arbre des mots clés
                                getIMediateur().obtenirArbreMotsCles(getIMediateur().getPanneauFiltres().getMotsClesFiltre()) ;
                                
                                // enfin on considère le composant comme instancié
                                estInstancie = true ;
                                
                        }
                        
                }) ;
        }
                
        /**
         * ajoute les listeners pour les boutons et le cochage des mots clés
         */  
        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)
                {
                                Tree nouvelArbre = (Tree)nouvelleDonnees ;
                                
                                // on vide tous les noeuds
                                arbreMotsCles.getRootNode().eachChild(new NodeTraversalCallback() {
                                        
                                        public boolean execute(Node node) {
                                                
                                                node.remove() ;
                                                return true ;
                                        }
                                        
                                        
                                }) ;
                                
                                // et on recopie le nouvel arbre
                                copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles.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() ;
                }
                
                if(nouvelleDonnees instanceof TreeNode)
                {
                        TreeNode nd = (TreeNode)nouvelleDonnees ;
                        
                        // si le noeud n'existe pas déjà c'est un ajout
                        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
                        {
                                // alors on supprime d'abord le noeud concerné
                                arbreMotsCles.getTree().getNodeById(nd.getId()+"_filtre").remove() ;
                        }
                        
                        // on cherche le père du nouveau noeud
                        Node ndPereOriginal = nd.getParentNode() ;
                        String idPereFiltre = ndPereOriginal.getId()+"_filtre" ;
                        
                        String[] usObj = (String[])nd.getUserObject() ;
                        TreeNode child = new TreeNode(usObj[0]) ;
                        child.setId(usObj[1]+"_filtre") ;
                        child.setChecked(false);
                        child.setUserObject(usObj) ;
                        arbreMotsCles.getNodeById(idPereFiltre).appendChild(child) ;
                        
                        // et on ajoute le nouveau noeud à son père
                        copierFilsNoeud(nd, child) ;
                }
                
                // si on reçoit une string
                if(nouvelleDonnees instanceof String)
                {
                        String idSupp = (String)nouvelleDonnees+"_filtre" ;
                        // c'est une suppression et si le noeud existe bien
                        if(arbreMotsCles.getTree().getNodeById(idSupp) != null)
                        {
                                // on le supprime
                                arbreMotsCles.getTree().getNodeById(idSupp).remove() ;
                        }
                }
                
        }
        
        /**
         * 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() {
                
                valider() ;
                
                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)
        {
                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.setId(usObj[1]+"_filtre") ;
                                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 non)
         */
        public boolean renvoyerEtatFiltre() {
                
                return filtreModifie ;
        }
        
        public void valider()
        {
                if(estInstancie)
                {
                        // 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 ;
                }
        }

}