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 org.tela_botanica.client.observation.ObservationMediateur;

import com.google.gwt.user.client.ui.Label;
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.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
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;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;

/**
 * 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;
        
        /**
         * Le médiateur associé à la vue
         */
        private ObservationMediateur oMediateur = null;
        
        /**
         * Les mots clés en cours
         */
        private String motsClesEncours = "";

        /**
         * Le treepanel qui affiche l'arbre
         */
        private static TreePanel arbreMotsCles = null;

        /**
         * booléen d'initialisation
         */
        private boolean estInstancie = false;
        
        private boolean arbreInitialise = false;

        /**
         * booléen d'etat
         */
        private boolean filtreModifie = false;
        
        /**
         * prefixe pour générer des ids adaptées
         */
        private String prefixe = "_filtre" ;
        
        private final String prefixeImg = "_images" ;
        
        private final String prefixeObs = "_obs" ;

        /**
         * 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();
                iMediateur = im;
                this.prefixe += prefixeImg;
                Label labelRecherche = new Label("Par mots clés :");
                add(labelRecherche);
                initialiserPanel();
        }
        
        /**
         * Constructeur avec paramètres
         * 
         * @param im
         *            le médiateur à associer
         */
        public ArbreMotsClesFiltreVue(ObservationMediateur om) {

                // on crée le panel
                super();
                oMediateur = om;
                this.prefixe += prefixeObs;
                initialiserPanel();
                
                this.setLayout(new RowLayout());

        }
        
        public void initialiserPanel() {
                // on crée le conteneur de l'arbre
                arbreMotsCles = new TreePanel();
                arbreMotsCles.setId("x-view-tree-filter"+prefixe);

                // on crée une racine pour l'arbre
                TreeNode root = new TreeNode("Tags");
                root.setId("racine"+prefixe);
                String[] usObject = { "Mots clés", "racine" };
                root.setUserObject(usObject);
                
                root.setExpandable(true);
                
                arbreMotsCles.setRootNode(root);
                
                arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {

                        public void onClick(Node node, EventObject e) {
                                if(!arbreInitialise) {
                                        expand();
                                }
                        }

                        public void onExpand(Node node) {
                                if(!arbreInitialise) {
                                        obtenirArbreMotsCles();
                                        arbreInitialise = true;
                                }
                        }

                });
                
                this.setPaddings(5);

                this.setBorder(false);
                this.setCollapsible(true);
                this.setAutoWidth(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
                                arbreMotsCles.setEnableDD(false);
                                arbreMotsCles.setAutoWidth(false);
                                arbreMotsCles.setAutoScroll(true);
                                arbreMotsCles.setBorder(false);

                                // on met en forme le layout
                                ((Panel) component).add(arbreMotsCles,new RowLayoutData("80%"));
                                
                                if(iMediateur == null) {
                                        Panel p = new Panel();
                                        p.setBorder(false);
                                        Button valider = new Button("Rechercher") ; 
                                        valider.addListener(new ButtonListenerAdapter() {

                                                public void onClick(Button button, EventObject e) {
                                                        getOMediateur().obtenirNombreObservation();
                                                }
                                                
                                        });
                                        p.add(valider,new RowLayoutData());
                                        add(p);
                                }

                                // on ajoute les listeners d'évenements
                                ajouterListeners();
                                //obtenirArbreMotsCles();
                        }
                        
                });
        }

        /**
         * 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 de l'ancien arbre
                        Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
                        for (int i = 0; i < rootChild.length; i++) {
                                
                                rootChild[i].remove();
                        }

                        // 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;
                        }
                        
                        if(!arbreInitialise) {
                                arbreInitialise = true;
                        }
                        
                        arbreMotsCles.setRootNode(arbreMotsCles.getRootNode());

                        // l'état du filtre est réinitialisé
                        filtreModifie = false;
                        doLayout() ;
                }

                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() +prefixe) == 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() +prefixe)
                                                .remove();
                        }

                        // on chercher le père du nouveau noeud
                        Node ndPereOriginal = nd.getParentNode();

                        
                        String idPereFiltre = ndPereOriginal.getId() +prefixe;

                        String[] usObj = (String[]) nd.getUserObject();
                        TreeNode child = new TreeNode(usObj[0]);
                        child.setId(usObj[1] +prefixe);
                        child.setChecked(false);
                        child.setUserObject(usObj);
                        arbreMotsCles.getNodeById(idPereFiltre).appendChild(child);

                        // et on ajoute le nouveau noeud à son père
                        copierFilsNoeud(nd, child);
                        this.doLayout();
                }

                // si on reçoit une string
                if (nouvelleDonnees instanceof String) {
                        String idSupp = (String) nouvelleDonnees +prefixe;
                        // 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;
        }
        
        public ObservationMediateur getOMediateur() {
                return oMediateur ;
        }

        /**
         * 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 = new String[2] ;
                valeursFiltrees[1] = motsClesEncours;
                
                if(iMediateur != null) {
                        valeursFiltrees[0] = "ci_meta_mots_cles";
                }
                else
                {
                        valeursFiltrees[0] = "mots_cles";
                }

                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] +prefixe);
                                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 mettreAJourMotsCles(String valeur, String id) {
                if(getIMediateur() != null) {
                        getIMediateur().mettreAjourMotsClesId(valeur,
                                id);
                }
                else
                {
                        getOMediateur().mettreAjourMotsClesId(valeur, id);
                }
        }
        
        public void obtenirArbreMotsCles() {
                if(getIMediateur() != null) {
                        getIMediateur().obtenirArbreMotsCles(this);
                }
                else
                {
                        getOMediateur().obtenirArbreMotsCles(this);
                }
        }

        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();
                                                        mettreAJourMotsCles(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;
                }
        }

        public void raz() {
                
                // on vide tous les noeuds de l'ancien arbre
                Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
                for (int i = 0; i < rootChild.length; i++) {
                        
                        rootChild[i].remove();
                }
                
                arbreInitialise = false ;
                
                // on crée une racine pour l'arbre
                TreeNode root = new TreeNode("Tags");
                root.setId("racine"+prefixe);
                String[] usObject = { "Mots clés", "racine" };
                root.setUserObject(usObject);
                
                root.setExpandable(true);
                
                arbreMotsCles.setRootNode(root);
                
                arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {

                        public void onClick(Node node, EventObject e) {
                                if(!arbreInitialise) {
                                        expand();
                                }
                        }

                        public void onExpand(Node node) {
                                if(!arbreInitialise) {
                                        obtenirArbreMotsCles();
                                        arbreInitialise = true;
                                }
                        }
                });
        }

}