| New file |
|---|
| 0,0 → 1,480 |
|---|
| 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() { |
| |
| if(arbreInitialise) { |
| // 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; |
| } |
| } |
| }); |
| } |
| } |
| |
| } |