Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues;



import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;

import com.google.gwt.user.client.Window;
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.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.VerticalLayout;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;

/**
 * Arbre des mots clés, qui est une vue rafraichissable,
 * qui contient des mots clés cochables et réorganisables à volonté
 * @author aurelien
 *
 */
public class ArbreMotsClesVue extends Panel implements Rafraichissable {

        /**
         * Le médiateur associé à la vue
         */
        private ImageMediateur iMediateur = null ;
        
        /**
         * Le treepanel qui affiche l'arbre
         */
        private TreePanel arbreMotsCles = null ;
        /**
         * L'éditeur qui permet de modifier les mots clés dans l'arbre
         */
        private TreeEditor te = null ;
        /**
         * Le textfield associé à l'éditeur
         */
        private TextField tfEdit = null ;
        /**
         * Bouton de validation
         */
        private Button valider = null ;
        /**
         * Une string permettant connaitre les mots clés cochés en cours séparés par des virgules
         */
        private String motsClesEnCours = "" ;
        /**
         * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre 
         * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu du conteneur n'ai été effectué)
         */
        private String[] motsClesEnAttente ; 
        /**
         * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un noeud
         */
        private boolean ajoutNoeud = false ;
        /**
         * Booléen d'évènement qui sert à savoir si on est en train de modifier un noeud
         */
        private boolean modifNoeud = false ;
        /**
         * Booléen d'instanciation du conteneur
         */
        private boolean estInstancie = false ;
        /**
         * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
         */
        private boolean motsCleInitialises ;
        
        /**
         * Constructeur sans paramètre (privé car interdit d'utilisation)
         */
        @SuppressWarnings("unused")
        private ArbreMotsClesVue()
        {
                super() ;
        }
        
        /**
         * Constructeur avec paramètre
         * @param im le médiateur à associer
         */
        public ArbreMotsClesVue(ImageMediateur im)
        {
                // on crée le panel
                super("Mots clés") ;
                this.setLayout(new VerticalLayout());
                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-keyword") ;
                
                // on crée une racine pour l'arbre
                TreeNode root = new TreeNode("Tags") ;
                root.setId("racine") ;
                String[] usObject = {"Mots clés" , "racine" } ;
                root.setUserObject(usObject) ;
                arbreMotsCles.setRootNode(root) ;
                arbreMotsCles.setRootVisible(false) ;
                arbreMotsCles.setBorder(false) ;
                arbreMotsCles.setWidth(500) ;
                
                // on crée l'éditeur pour l'arbre
                tfEdit = new TextField() ;
                tfEdit.setAutoWidth(true) ;
                te = new TreeEditor(arbreMotsCles,tfEdit) ;
                valider = new Button("Appliquer") ;
                arbreMotsCles.add(te) ;
                
                // on met en forme le layout
                this.add(arbreMotsCles) ;
                this.add(valider) ;
                
                this.setBorder(false) ;
                this.setCollapsible(true) ;
                this.setTitleCollapse(true) ;
                
                // on ajoute les listeners
                ajouterListeners() ;
                
        }
        
        /**
         * Acesseur pour le médiateur
         * @return le médiateur associé à la vue
         */
        private ImageMediateur GetIMediateur() {
                
                return iMediateur ;
                
        }
        
        /**
         * Acesseur pour l'arbre des mots clés
         * @return le panel contenant l'arbre
         */
        public TreePanel getArbreMotsCles() {
                return arbreMotsCles;
        }

        /**
         * Accesseur pour l'éditeur
         * @return l'éditeur associé à l'arbre
         */
        public TreeEditor getTe() {
                return te;
        }

        /**
         * Acesseur pour le TextField associé à l'éditeur
         * @return le champ texte associé à l'éditeur
         */
        public TextField getTfEdit() {
                return tfEdit;
        }
        
        /**
         * Ajoute les listeners nécessaires pour la gestion des évènements
         */
        private void ajouterListeners()
        {
                arbreMotsCles.addListener(new TreePanelListenerAdapter() {
                        
                        // gestion du clic sur un noeud
                        public void onClick(TreeNode node, EventObject e) {
                                
                                e.stopEvent() ;
                                gererClicNoeud(node);
                        }

                        // gestion du clic droit sur un noeud
                        public void onContextMenu(TreeNode node, EventObject e) {
                                
                                        e.stopEvent() ;
                                        GetIMediateur().montrerContextMenuArbre(node, e , getTe()) ;
                                
                        }
                
                        // gestion du double clic sur un noeud
                        public void onDblClick(TreeNode node, EventObject e) {
                                
                                modifNoeud = true ;
                                if(! node.getId().equals("racine"))
                                {
                                        te.startEdit(node);
                                }
                        }
                        
                        // gestion de la modification du texte d'un noeud 
                        public void onTextChange(TreeNode node, String text, String oldText) {

                                // on récupère les informations associées au noeud
                                TreeNode nd = node ;
                                String[] usObject = new String[2] ;
                                usObject[0] = text ;
                                usObject[1] = ((String[])nd.getUserObject())[1] ;
                                nd.setUserObject(usObject) ;
                                
                                // si c'est un nouveau noeud
                                if(ajoutNoeud)
                                {
                                        // on notifie le médiateur de l'ajout et on lui passe l'arbre
                                        GetIMediateur().ajouterMotCleDansArbre(nd,getArbreMotsCles().getTree()) ;
                                        // et considière l'ajout achevé
                                        ajoutNoeud = false ;
                                }
                                // si c'est noeud déjà existant
                                else
                                {
                                        if(modifNoeud)
                                        {
                                                // on notifie le médiateur de la modification et on lui passe l'arbre
                                                GetIMediateur().modifierMotCleDansArbre(nd,getArbreMotsCles().getTree()) ;
                                                // et on considère la modification achevée
                                                modifNoeud = false ;
                                        }
                                }
                                
                        }
                        
                        // gestion du déplacement d'un noeud
                        public void onMoveNode(Tree tree, TreeNode node, TreeNode oldParent, TreeNode newParent,int index)
                        {
                                // on notifie le médiateur et on lui passe l'arbre
                                GetIMediateur().deplacerMotCleDansArbre(node, getArbreMotsCles().getTree()) ;
                        } 
                        
                }) ;
                
                // gestion de la validation
                valider.addListener(new ButtonListenerAdapter() {
                        
                        // lors du clic
                        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 ;
                                        }
                                        
                                });
                                
                                // enfin on notifie le médiateur et on lui passe l'arbre et la liste des mots clés ainsi obtenue
                                GetIMediateur().mettreAjourMotsCles(motsClesEnCours,arbreMotsCles.getTree()) ;
                        }
                }) ;
                
        }
        
        /**
         * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
         */
        public void obtenirArbreMotsCles() {
                
                GetIMediateur().obtenirArbreMotsCles(this) ;
                
        }

        /**
         * Supprime un noeud de l'arbre
         * @param n le noeud à supprimer
         */
        public void supprimerNoeud(TreeNode n)
        {
                // si ça n'est pas la racine (qu'on ne peut pas supprimer)
                if(!n.getId().equals(getArbreMotsCles().getRootNode().getId()))
                {
                        // on détache le noeud et on le détruit
                        n.getParentNode().removeChild(n);
                        n.destroy() ;
                        // puis on en notifie le médiateur en lui passant le noeud supprimé et l'arbre
                        GetIMediateur().supprimerMotCleDansArbre(n, arbreMotsCles.getTree()) ;
                }
                else
                {
                        // si l'utilisateur tente de supprimer la racine, on l'avertit de son erreur
                        Window.alert("Impossible de supprimer la racine de l'arbre") ;
                }
        }
        
        /**
         * Ajoute un noeud dans l'arbre au parent donné
         * @param parent le futur parent du noeud à ajouter
         */
        public void ajouterNoeud(TreeNode parent)
        {
                
                        // on met l'ajout du noeud à vrai
                        ajoutNoeud = true ;
                        // on crée un nouveau noeud vide
                        TreeNode nd = new TreeNode("");
                        nd.setCls("x-view-treenode-keyword") ;
                        nd.setChecked(true);
                        // on associe un objet au noeud qui contient des infos
                        String[] usObject = new String[2] ;
                        // l'objet contient le nom du noeud
                        usObject[0] = "" ;
                        usObject[1] = genererIdMotCle(nd) ;
                        nd.setId(usObject[1]) ;
                        nd.setUserObject(usObject) ;
                        // l'identifiant d'un noeud c'est son hashcode
                        // l'objet associé au noeud contient aussi son identifiant
                        
                        // on le concatène au parent et on étend ses enfants
                        parent.appendChild(nd);
                        parent.expand() ;
                        // enfin on place le curseur et on fait apparaitre le champ d'édition pour que l'utilisateur nomme son mot clé
                        te.startEdit(nd);

                
        }
        
        /**
         * Coche le noeud s'il est décoché, le décoche sinon
         * @param node
         */
        public void gererClicNoeud(TreeNode node)
        {
                if(node.getUI().isChecked())
                {
                        node.getUI().toggleCheck(false) ;
                }
                else
                {
                        node.getUI().toggleCheck(true) ;
                }
        }
        
        /**
         * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots clés à cocher 
         * @param motsClesIds un tableau contenant les identifiants des mots clés à cocher
         */
        public void cocherMotsCles(final String[] motsClesIds)
        {
                if(getArbreMotsCles() != null && getArbreMotsCles().getRootNode() != null)
                {
                        // à partir de la racine
                        getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
        
                                // pour chaque noeud
                                public boolean execute(Node node) {
                                        
                                                // on parcourt le tableau des mots clés
                                                for(int i = 0 ; i < motsClesIds.length ; i++)
                                                {
                                                        // si le mot clé fait partie des id à cocher on le coche
                                                        String usObject[] = (String[])node.getUserObject() ;
                                                        String nodeId = usObject[1] ;
                                                                                
                                                        if(nodeId.equals(motsClesIds[i]))
                                                        {
                                                                getArbreMotsCles().getNodeById(nodeId).getUI().toggleCheck(true) ;
                                                                return true ;
                                                        }
                                                        
                                                        getArbreMotsCles().getNodeById(node.getId()).getUI().toggleCheck(false) ;
                                                }
                                                // et on passe au suivant
                                                return true;
                                }
                                
                        }) ;
                }
        }
        
        /**
         * Méthode héritée de l'interface rafraichissable
         * @param nouvelleDonnees les nouvelles données pour l'objet
         * @param repandreRafraichissement booleen qui dit si on doit répandre l'évenement
         */
        public void rafraichir(Object nouvelleDonnees,
                        boolean repandreRafraichissement) {
                // si on a reçu un arbre
                if(nouvelleDonnees instanceof Tree)
                {
                                Tree nouvelArbre = (Tree)nouvelleDonnees ;
                                
                                if(nouvelArbre.getRootNode().getChildNodes().length <= 0)
                                {
                                        // on crée une racine pour l'arbre
                                        TreeNode root = new TreeNode("Tags") ;
                                        root.setId("racine") ;
                                        String[] usObject = {"Mots clés" , "racine" } ;
                                        root.setUserObject(usObject) ;
                                }
                                
                                        // on prend sa racine et on l'attache à l'arbre des mots clés
                                        Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes() ;
                                        for (int i = 0; i < rootChild.length; i++) {
                                                
                                                rootChild[i].remove() ;
                                        }
                                        
                                        getArbreMotsCles().getRootNode().appendChild(nouvelArbre.getRootNode()) ;
                                                
                                        // si l'arbre n'était pas encore considéré comme instancié
                                        if(!estInstancie)
                                        {
                                                // on signale que oui
                                                estInstancie = true ;
                                        }
                                        
                                        // s'il y a des mots clés en attente (lors du premier rendering)
                                        if(motsCleInitialises == false && motsClesEnAttente != null)
                                        {
                                                // on les coche
                                                //cocherMotsCles(motsClesEnAttente) ;
                                                motsCleInitialises = true ; 
                                        }
                }
                
                
                // Si on reçoit un tableau de String (cas ou l'on séléectionne une nouvelle image)
                if(nouvelleDonnees instanceof String[])
                {
                        // et que l'arbre est instancié
                        if(estInstancie && nouvelleDonnees != null)
                        {
                                // le tableau de String contient les id des mots clés associés à l'image
                                // on coche les mots clés contenu dans le tableau
                                String[] motsClesIds = (String[])nouvelleDonnees ;              
                                cocherMotsCles(motsClesIds) ;           
                        }
                        // si l'arbre n'est pas encore instancié on met les mots clés en attente
                        else
                        {
                                motsClesEnAttente = (String[])nouvelleDonnees ;
                        }
                }
        }
        
        private String genererIdMotCle(TreeNode nd)
        {
                return  ""+(nd.hashCode()+(Math.random()*10000)) ;
        }

}