Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues.image;

import org.tela_botanica.client.i18n.Msg;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.util.MotsClesUtilitaire;

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.dd.DragData;
import com.gwtext.client.dd.DragDrop;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.WindowListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.layout.HorizontalLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.gwtext.client.widgets.tree.MultiSelectionModel;
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.TreeNodeListenerAdapter;
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 abstract class FenetreGestionMotsCles extends com.gwtext.client.widgets.Window implements Rafraichissable {

        /**
         * 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;
        
        /**
         * Bouton d'annulation
         */
        private Button annuler = null;
        
        /**
         * Bouton d'ajout de tag
         */
        private ToolbarButton ajouterTag = null;
        
        /**
         * Bouton de suppression de tag
         */
        private ToolbarButton supprimerTag = null;
        
        /**
         * Bouton de renommage de tag
         */
        private ToolbarButton renommerTag = null;
        
        /**
         * Une string permettant connaitre les mots clés cochés en cours séparés par
         * des virgules
         */
        private String motsClesEnCours = "";
        
        private String[] tableauMotsClesEnCours = new String[0];
        /**
         * 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 = new String[0];
        /**
         * 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 arbreCharge = false;
        /**
         * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
         */
        private boolean motsCleInitialises;
        
        /**
         * panneau intermédiaire contenant l'arbre
         */
        private Panel panelIntermediaire;
        private String cheminTemporaireAjout;

        /**
         * Constructeur avec paramètre
         * 
         * @param im
         *            le médiateur à associer
         */
        public FenetreGestionMotsCles() {
                                
                // on crée le panel
                setTitle("Mots clés");
                this.setLayoutData(new RowLayout());

                // 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-imgs");

                arbreMotsCles.setSelectionModel(new MultiSelectionModel());

                // on crée une racine pour l'arbre
                TreeNode root = new TreeNode("Tags");
                root.setId("racine");
                String[] usObject = {Msg.get("mots-cles-maj"), "racine" };
                root.setExpandable(true);
                arbreMotsCles.setRootNode(root);
                arbreMotsCles.setRootVisible(true);
                arbreMotsCles.setBorder(false);
                arbreMotsCles.setWidth(500);
                
                root.setUserObject(usObject);
                
                arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {

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

                        @Override
                        public void onExpand(Node node) {
                                if(!arbreCharge) {
                                        obtenirArbreMotsCles();
                                        arbreCharge = true;
                                }
                        }

                });

                // on crée l'éditeur pour l'arbre
                tfEdit = new TextField();
                tfEdit.setAutoWidth(true);
                te = new TreeEditor(arbreMotsCles, tfEdit);
                valider = new Button(Msg.get("appliquer"));
                annuler = new Button(Msg.get("annuler"));
                arbreMotsCles.add(te);
                
                panelIntermediaire = new Panel();
                panelIntermediaire.setLayout(new FitLayout());
                panelIntermediaire.setAutoScroll(true);
                panelIntermediaire.setWidth("100%");
                arbreMotsCles.setWidth("100%");
                arbreMotsCles.setHeight("100%");
                
                Panel panelBoutons = new Panel();
                panelBoutons.setLayout(new HorizontalLayout(130));
                panelBoutons.setWidth("100%");

                // on met en forme le layout
                panelIntermediaire.add(arbreMotsCles);
                panelBoutons.add(annuler);
                panelBoutons.add(valider);
                
                this.add(panelIntermediaire, new RowLayoutData());
                this.add(panelBoutons, new RowLayoutData(30));
                arbreMotsCles.setHeight("100%");
                arbreMotsCles.setAutoScroll(true);
                
                Toolbar barreBouton = new Toolbar();
                ajouterTag = new ToolbarButton(Msg.get("nouveau-tag"));
                ajouterTag.setIcon("mot_cle_ajouter.png");
                renommerTag = new ToolbarButton(Msg.get("renommer"));
                renommerTag.setIcon("mot_cle_editer.png");
                renommerTag.disable();
                supprimerTag = new ToolbarButton(Msg.get("supprimer"));
                supprimerTag.setIcon("mot_cle_supprimer.png");
                supprimerTag.disable();
                barreBouton.addButton(ajouterTag);
                barreBouton.addSeparator();
                barreBouton.addButton(renommerTag);
                barreBouton.addSeparator();
                barreBouton.addButton(supprimerTag);
                this.setTopToolbar(barreBouton);
                
                setCloseAction(com.gwtext.client.widgets.Window.HIDE);          
                // on ajoute les listeners
                ajouterListeners();

        }


        /**
         * 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;
        }
        
        protected abstract void surAffichageMenuContextuel(TreeNode node, EventObject e, TreeEditor te);
        protected abstract void surAjoutMotCle(TreeNode node, Tree arbre);
        protected abstract void surSuppressionMotCle(TreeNode node, Tree arbre);
        protected abstract void surDeplacementMotCle(TreeNode node, Tree arbre);
        protected abstract void surChangementTexte(TreeNode node, Tree arbre);
        protected abstract void surClicValider(String chaineMotsCles, Tree arbre);
        protected abstract void demanderArbreMotsCles(Rafraichissable r);
        protected abstract void surRetourWebService(Tree arbre);

        /**
         * Ajoute les listeners nécessaires pour la gestion des évènements
         */
        private void ajouterListeners() {
                
                this.addListener(new WindowListenerAdapter() {                  
                        @Override
                        public void onResize(com.gwtext.client.widgets.Window source, int width,
                                        int height) {
                                        panelIntermediaire.setHeight(getHeight() - 80);         
                        }
                });
                                                
                arbreMotsCles.addListener(new TreePanelListenerAdapter() {
                        @Override
                        public void onAfterLayout(Container self) {
                                panelIntermediaire.setHeight(getHeight() - 80);         
                        }
                        
                        @Override
                        public void onExpandNode(TreeNode node) {               
                                cocherMotsCles(tableauMotsClesEnCours);
                        }

                        // gestion du clic sur un noeud
                        @Override
                        public void onClick(TreeNode node, EventObject e) {

                                e.stopEvent();
                                gererClicNoeud(node);
                                if(!node.equals(arbreMotsCles.getRootNode())) {
                                        supprimerTag.enable();
                                        renommerTag.enable();
                                }
                        }

                        // gestion du clic droit sur un noeud
                        @Override
                        public void onContextMenu(TreeNode node, EventObject e) {

                                e.stopEvent();
                                surAffichageMenuContextuel(node, e, getTe());
                                if(!node.equals(arbreMotsCles.getRootNode())) {
                                        supprimerTag.enable();
                                        renommerTag.enable();
                                }
                        }

                        // gestion de la modification du texte d'un noeud
                        @Override
                        public void onTextChange(TreeNode node, String text, String oldText) {
                                
                                if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) {
                                        te.startEdit(node);
                                        Window.alert("Un mot clé ne peut pas être vide ou contenir les caractères suivants : "+MotsClesUtilitaire.getChaineCaracteresInterdits());
                                        return;
                                }
                                
                                if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
                                        te.startEdit(node);
                                        Window.alert("Un mot clé de même nom existe déjà à cette position");
                                        return;
                                }

                                if(node.equals(arbreMotsCles.getRootNode())) {
                                        return;
                                }

                                // 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 considère l'ajout achevé
                                        ajoutNoeud = false;
                                        // et on notifie le médiateur de l'ajout et on lui passe
                                        // l'arbre
                                        surAjoutMotCle(nd, getArbreMotsCles().getTree());
                                        arbreMotsCles.disable();
                                }
                                // si c'est noeud déjà existant
                                else {
                                        // on considère la modification achevée
                                        modifNoeud = false;
                                        
                                        if(!text.equals(oldText)) {
                                                // et on notifie le médiateur de la modification et on lui
                                                // passe l'arbre
                                                surChangementTexte(nd, getArbreMotsCles().getTree());
                                                arbreMotsCles.disable();
                                        }
                                }
                        }
                        
                        @Override
                        public boolean doBeforeMoveNode(Tree tree, TreeNode node,
                                        TreeNode oldParent, TreeNode newParent, int index) {
                                boolean ok = true;
                                if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
                                        ok = false;
                                        Window.alert("Un mot clé de même nom existe déjà à cette position");
                                }
                                return ok;
                        }
                        
                        @Override
                        public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
                                        DragData dragData, String point, DragDrop source,
                                        TreeNode dropNode) {
                                return MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
                        }

                        // gestion du déplacement d'un noeud
                        @Override
                        public void onMoveNode(Tree tree, TreeNode node,
                                        TreeNode oldParent, TreeNode newParent, int index) {
                                // on notifie le médiateur et on lui passe l'arbre
                                surDeplacementMotCle(node, getArbreMotsCles().getTree());
                        }

                });

                // gestion de la validation
                valider.addListener(new ButtonListenerAdapter() {

                        // lors du clic
                        @Override
                        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
                                                        @Override
                                                        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
                                surClicValider(motsClesEnCours, arbreMotsCles.getTree());
                        }
                });
                
                annuler.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button button, EventObject e) {
                                hide();
                        }
                });
                
                renommerTag.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button button, EventObject e) {
                                TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
                                TreeNode noeudRenommage;
                                if(noeuds.length > 0) {
                                        noeudRenommage = noeuds[noeuds.length - 1];
                                } else {
                                        noeudRenommage = arbreMotsCles.getRootNode();
                                }
                                renommerNoeud(noeudRenommage);
                        }
                });
                
                ajouterTag.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button button, EventObject e) {
                                
                                TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
                                TreeNode noeudAjout;
                                if(noeuds.length > 0) {
                                        noeudAjout = noeuds[noeuds.length - 1];
                                } else {
                                        noeudAjout = arbreMotsCles.getRootNode();
                                }

                                ajouterNoeud(noeudAjout);
                        }
                });
                
                supprimerTag.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button button, EventObject e) {
                                
                                TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
                                for (int i = 0; i < noeuds.length; i++) {
                                        supprimerNoeud(noeuds[i]);
                                }
                        }
                });
        }

        /**
         * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
         */
        public void obtenirArbreMotsCles() {
                demanderArbreMotsCles(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())) {
                        if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) {
                                // 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
                                surSuppressionMotCle(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) {
                ajoutNoeud = true;              
                TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, true);
                // on le concatène au parent et on étend ses enfants
                parent.appendChild(nd);
                parent.expand();
                cheminTemporaireAjout = nd.getId();
                te.startEdit(nd);
        }

        /**
         * Renomme le noeud passé en paramètre
         */
        public void renommerNoeud(TreeNode n) {
                // TODO Auto-generated method stub
                te.startEdit(n);
        }

        /**
         * 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
                                        @Override
                                        public boolean execute(Node node) {

                                                String usObject[] = (String[]) node
                                                                .getUserObject();
                                                String nodeId = usObject[1];
                                                
                                                TreeNode tn = getArbreMotsCles().getNodeById(node.getId());
                                                if(tn != null) {
                                                        tn.getUI().toggleCheck(false);
                                                        // 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

                                                                if (nodeId.equals(motsClesIds[i])) {
                                                                        tn.getUI().toggleCheck(true);
                                                                        tn.ensureVisible();
                                                                        return true;
                                                                }
                                                        }
                                                        // 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
         */
        @Override
        public void rafraichir(Object nouvelleDonnees,
                        boolean repandreRafraichissement) {
                
                if(nouvelleDonnees instanceof Tree) {

                        Tree nouvelArbre = (Tree)nouvelleDonnees ;

                        // 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();
                        }
                        
                        copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());

                        // si l'arbre n'était pas encore considéré comme instancié
                        if (!arbreCharge) {
                                // on signale que oui
                                arbreCharge = true;
                        }
                }

                // Si on reçoit un tableau de String (cas ou l'on séléectionne une
                // nouvelle image)
                if (nouvelleDonnees instanceof String[]) {

                        // 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
                        tableauMotsClesEnCours = (String[]) nouvelleDonnees;
                        if(this.isVisible()) {
                                cocherMotsCles(tableauMotsClesEnCours);
                        } else {
                                addListener(new WindowListenerAdapter() {
                                        
                                        @Override
                                        public void onShow(Component component) {
                                                cocherMotsCles(tableauMotsClesEnCours);
                                        }
                                });
                        }
                }
                
                // reception d'un nouvel identifiant de mot clé
                if(nouvelleDonnees instanceof Integer) {
                        if(cheminTemporaireAjout != null) {
                                String id = ((Integer)(nouvelleDonnees)).toString();
                                TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
                                String[] userObj = {noeudEnAjout.getText(), id};
                                noeudEnAjout.setUserObject(userObj);
                                cheminTemporaireAjout = null;
                        }
                }
                surRetourWebService(arbreMotsCles.getTree());
                arbreMotsCles.enable();
        }
        
        /**
         * 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]);
                                child.setChecked(false);
                                child.setUserObject(usObj);
                                ndPereCopie.appendChild(child);

                                if (!ndNodeFils[i].isLeaf()) {
                                        copierFilsNoeud(ndNodeFils[i], child);
                                }

                        }
                }
        }


        public void activerBoutonValider(boolean activer) {
                valider.setVisible(activer);
        }
}