| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/MenuAideVue.java |
|---|
| New file |
| 0,0 → 1,93 |
| package org.tela_botanica.client.vues; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| public class MenuAideVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour l'aide |
| */ |
| private Item aide = null; |
| private Item bugRemarque = null ; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuAideVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuAideVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| // on construit le menu |
| aide = new Item("Aide"); |
| bugRemarque = new Item("Bugs, remarques") ; |
| addItem(aide); |
| addItem(bugRemarque) ; |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'aide |
| if (item.equals(aide)) { |
| // on notifie le médiateur |
| getIMediateur().afficherAide(); |
| } |
| // si c'est la soumission de bug ou de remarques |
| if (item.equals(bugRemarque)) { |
| getIMediateur().soumettreBugRemarque() ; |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java |
|---|
| New file |
| 0,0 → 1,478 |
| 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; |
| } |
| } |
| }); |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,207 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextArea; |
| public class SaisieMotsClesVue extends Window implements Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| private Object[][] listeMotsPesee = null; |
| private String motsAAjouter = "" ; |
| private int nbMotsClesMax = 1 ; |
| private TextArea motsClesAjout = null; |
| private Button validerAjout = null ; |
| private Button voirCacherNuage = null; |
| private boolean nuageVisible = false ; |
| private Panel contenuNuage = null ; |
| public SaisieMotsClesVue(ObservationMediateur om) { |
| super("Entrez vos mots clés"); |
| setCls("fenmotcles"); |
| oMediateur = om ; |
| //setWidth(300); |
| motsClesAjout = new TextArea(); |
| //motsClesAjout.setWidth(300); |
| validerAjout = new Button("Valider"); |
| voirCacherNuage= new Button("Afficher les mots clés"); |
| final Rafraichissable r = this ; |
| this.setCloseAction(CLOSE); |
| validerAjout.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| motsAAjouter = motsClesAjout.getText(); |
| //oMediateur.AjouterMotsClesEnMasse(motsAAjouter); |
| } |
| }); |
| voirCacherNuage.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| if(nuageVisible) { |
| if(contenuNuage != null) { |
| contenuNuage.clear(); |
| } |
| voirCacherNuage.setText("Afficher les mots clés"); |
| nuageVisible = false; |
| } |
| else { |
| // oMediateur.obtenirNuageMotsCles(r); |
| voirCacherNuage.setText("Cacher les mots clés"); |
| nuageVisible = true; |
| } |
| } |
| }); |
| add(motsClesAjout); |
| add(validerAjout); |
| add(voirCacherNuage); |
| contenuNuage = new Panel(); |
| contenuNuage.setBorder(false); |
| add(contenuNuage); |
| } |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof Integer) { |
| nbMotsClesMax = (Integer)nouvelleDonnees; |
| demasquerChargement(); |
| } |
| if(nouvelleDonnees instanceof Object[][]) { |
| listeMotsPesee = (Object[][])nouvelleDonnees ; |
| construireNuage(); |
| demasquerChargement(); |
| } |
| if(nouvelleDonnees instanceof String) { |
| String res = (String)nouvelleDonnees; |
| if(res.equals("OK")) { |
| masquerChargement(); |
| oMediateur.obtenirListeObservation(); |
| //oMediateur.obtenirNuageMotsCles(this); |
| } |
| } |
| } |
| private void construireNuage() { |
| contenuNuage.clear(); |
| String contenu = "<ul class=\"nuagetag\">" ; |
| for(int i = 0; i<listeMotsPesee.length; i++) { |
| String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ; |
| contenu += "<li class=\""+classeMotCle+"\">"; |
| contenu += (String)listeMotsPesee[i][0]; |
| contenu += "</li>"; |
| } |
| contenu += "</ul>" ; |
| HTML contenuHTML = new HTML(contenu) { |
| public void onBrowserEvent(Event e) { |
| motsAAjouter += " "+e.getTarget().getInnerHTML(); |
| motsClesAjout.setValue(motsAAjouter); |
| } |
| }; |
| contenuHTML.sinkEvents(Event.ONCLICK); |
| contenuNuage.add(contenuHTML); |
| contenuNuage.doLayout(); |
| doLayout(); |
| } |
| private int calculerPoids(int poidMot) { |
| int poids = (poidMot*10)/nbMotsClesMax; |
| if(poids < 1) { |
| return 1; |
| } |
| return poids; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
| */ |
| public void demasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.unmask() ; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java |
|---|
| New file |
| 0,0 → 1,520 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| 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.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur = null; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private static 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 = 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; |
| /** |
| * Constructeur sans paramètre (privé car interdit d'utilisation) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreMotsClesObservationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreMotsClesObservationVue(ObservationMediateur om) { |
| // on crée le panel |
| super("Mots clés"); |
| this.setLayout(new VerticalLayout()); |
| oMediateur = om; |
| // 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-obs"); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Tags"); |
| root.setId("racine_obs"); |
| String[] usObject = { "Mots clés", "racine" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.setRootVisible(true); |
| arbreMotsCles.setBorder(false); |
| // arbreMotsCles.setWidth(500); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onClick(Node node, EventObject e) { |
| if(!arbreCharge) { |
| expand(); |
| } |
| } |
| public void onExpand(Node node) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| arbreCharge = true; |
| } |
| } |
| }); |
| // on crée l'éditeur pour l'arbre |
| tfEdit = new TextField(); |
| 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 ObservationMediateur getOMediateur() { |
| return oMediateur; |
| } |
| /** |
| * 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(); |
| getOMediateur().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_obs")) { |
| 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 |
| getOMediateur().ajouterMotCleDansArbre(nd, |
| getArbreMotsCles().getTree()); |
| // et considè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 |
| getOMediateur().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 |
| getOMediateur().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(); |
| getOMediateur().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 |
| getOMediateur().mettreAjourMotsCles(motsClesEnCours, |
| arbreMotsCles.getTree()); |
| } |
| }); |
| } |
| /** |
| * Envoie une demande au médiateur pour obtenir l'arbre des mots clés |
| */ |
| public void obtenirArbreMotsCles() { |
| getOMediateur().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 |
| getOMediateur() |
| .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) { |
| getArbreMotsCles().getNodeById(node.getId()) |
| .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 |
| String usObject[] = (String[]) node |
| .getUserObject(); |
| String nodeId = usObject[1]; |
| if (nodeId.equals(motsClesIds[i])) { |
| getArbreMotsCles().getNodeById(nodeId+"_obs") |
| .getUI().toggleCheck(true); |
| return true; |
| } |
| } |
| // et on passe au suivant |
| return true; |
| } |
| }); |
| } |
| else { |
| motsClesEnAttente = motsClesIds ; |
| } |
| } |
| /** |
| * 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) { |
| 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; |
| } |
| // 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; |
| } |
| if(motsClesEnAttente.length > 0) { |
| cocherMotsCles(motsClesEnAttente); |
| } |
| } |
| // 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 (arbreCharge) { |
| // 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)); |
| } |
| /** |
| * 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] +"_obs"); |
| child.setChecked(false); |
| child.setUserObject(usObj); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,661 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.core.client.GWT; |
| 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; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| import com.gwtext.client.core.EventObject; |
| /** |
| * Arbre Filtrant sur les entites geographiques |
| * |
| * |
| * @author aurelien + david |
| * |
| */ |
| public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * Les localites en cours |
| */ |
| private String entitesGeographiquesEncours = ""; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreEntitesGeographiques = null; |
| /** |
| * booléen d'initialisation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * booléen d'etat |
| */ |
| private boolean filtreModifie = false; |
| private boolean arbreCharge = false ; |
| private String nomFiltre = "" ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreEntiteGeographiqueObservationFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) { |
| // on crée le panel |
| super("Localités"); |
| this.observationMediateur = obs; |
| arbreEntitesGeographiques = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(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 |
| arbreEntitesGeographiques.setEnableDD(false); |
| arbreEntitesGeographiques.setId("x-view-tree-filter-entity"); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Localités"); |
| root.setId("racine_entite"); |
| String[] usObject = { "Localités" }; |
| root.setUserObject(usObject); |
| arbreEntitesGeographiques.setRootNode(root); |
| arbreEntitesGeographiques.setRootVisible(true); |
| arbreEntitesGeographiques.setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreEntitesGeographiques); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| }); |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| private void ajouterListeners() { |
| arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() { |
| public void onClick(TreeNode node, EventObject e) { |
| nomFiltre = "" ; |
| entitesGeographiquesEncours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(!arbreCharge) |
| { |
| arbreEntitesGeographiques.getRootNode().expand(); |
| } |
| else |
| { |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| return ; |
| case 3: nomFiltre += "lieudit,location,id_location"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ; |
| break; |
| case 2: nomFiltre += "location,id_location"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere ; |
| break; |
| case 1: nomFiltre += "id_location"; |
| entitesGeographiquesEncours += node.getText() ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = true ; |
| // Le filtre est modifie : on lance un rafraaaichissement de la liste des observations affichees |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| }) ; |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| arbreEntitesGeographiques.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreEntitesGeographiques.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) { |
| String id_location=null; |
| String location=null; |
| String lieuDit=null; |
| ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ; |
| // on crée un arbre vide |
| Tree nouvelArbre = new Tree() ; |
| TreeNode root = new TreeNode(); |
| root.setId("racine_entite"); |
| root.setText("Localités"); |
| String[] usObjRoot = { "Localités"}; |
| root.setUserObject(usObjRoot); |
| nouvelArbre.setRootNode(root); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| EntiteGeographiqueObservation ent=(EntiteGeographiqueObservation) data.get(it.next()); |
| id_location=ent.getIdLocation(); |
| id_location = id_location.replaceAll("\"", ""); |
| id_location = id_location.replace('\\',' '); |
| id_location = id_location.trim(); |
| location=ent.getLocation(); |
| lieuDit=ent.getLieuDit(); |
| if(id_location.contains("000null") || id_location.equals(null) || (id_location.trim()).equals("")) { |
| id_location="Inconnue" ; |
| } |
| if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) { |
| location="Inconnue" ; |
| } |
| if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) { |
| lieuDit="Inconnue" ; |
| } |
| Node noeudMemeId = nouvelArbre.getNodeById(""+id_location); |
| // si la région existe déjà |
| if(noeudMemeId != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeLoc = nouvelArbre.getNodeById(""+(id_location+location)); |
| if(noeudMemeLoc != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeLieu = nouvelArbre.getNodeById(""+(id_location+location+lieuDit)); |
| if(noeudMemeLieu != null) |
| { |
| // tous les noeuds existent déjà, normalement ça ne devrait pas arriver |
| } |
| else |
| { |
| // enfin on ne crée que le noeud du lieu dit |
| TreeNode node_lieu = new TreeNode(); |
| node_lieu.setId(""+(id_location+location+lieuDit)); |
| node_lieu.setText(lieuDit); |
| noeudMemeLoc.appendChild(node_lieu) ; |
| String[] usObj = {lieuDit,id_location+location+lieuDit}; |
| node_lieu.setUserObject(usObj); |
| } |
| } |
| else |
| { |
| // on crée le noeud de la location |
| TreeNode node_loc = new TreeNode(); |
| node_loc.setId(""+(id_location+location)); |
| node_loc.setText(location); |
| noeudMemeId.appendChild(node_loc) ; |
| String[] usObj = {location,id_location+location}; |
| node_loc.setUserObject(usObj); |
| TreeNode node_lieu = new TreeNode(); |
| node_lieu.setId(""+(id_location+location+lieuDit)); |
| node_lieu.setText(lieuDit); |
| node_loc.appendChild(node_lieu) ; |
| String[] usObj2 = {lieuDit,id_location+location+lieuDit}; |
| node_lieu.setUserObject(usObj2); |
| } |
| } |
| else |
| { |
| // on crée le noeud de l'identifiant location |
| TreeNode node_id_loc = new TreeNode(); |
| node_id_loc.setId(""+id_location); |
| node_id_loc.setText(id_location); |
| root.appendChild(node_id_loc) ; |
| String[] usObj = {id_location,id_location}; |
| node_id_loc.setUserObject(usObj); |
| TreeNode node_loc = new TreeNode(); |
| node_loc.setId(""+(id_location+location)); |
| node_loc.setText(location); |
| node_id_loc.appendChild(node_loc) ; |
| String[] usObj2 = {location,id_location+location}; |
| node_loc.setUserObject(usObj2); |
| TreeNode node_lieu = new TreeNode(); |
| node_lieu.setId(""+(id_location+location+lieuDit)); |
| node_lieu.setText(lieuDit); |
| node_loc.appendChild(node_lieu) ; |
| String[] usObj3 = {lieuDit,id_location+location+lieuDit}; |
| node_lieu.setUserObject(usObj3); |
| } |
| root.sort(comparerNoeuds()) ; |
| doLayout(); |
| } |
| // on vide tous les noeuds |
| arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() { |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| copierFilsNoeud(root, arbreEntitesGeographiques.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() ; |
| arbreEntitesGeographiques.doLayout(); |
| } |
| if(nouvelleDonnees instanceof Observation) |
| { |
| // Cas d'ajout unitaire d'une observation |
| // si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout |
| // l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement |
| // de l'arbre |
| if(!arbreCharge) { |
| return; |
| } |
| Observation obs = (Observation)nouvelleDonnees ; |
| String id_location= obs.getIdentifiantLocalite(); |
| id_location = id_location.replaceAll("\"", ""); |
| id_location = id_location.replace('\\',' '); |
| id_location = id_location.trim(); |
| String location=obs.getLocalite(); |
| String lieuDit=obs.getLieudit(); |
| Node root = arbreEntitesGeographiques.getRootNode() ; |
| if(id_location.contains("000null") || id_location.equals(null) || (id_location.trim()).equals("")) { |
| id_location="Inconnue" ; |
| } |
| if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) { |
| location="Inconnue" ; |
| } |
| if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) { |
| lieuDit="Inconnue" ; |
| } |
| Node noeudMemeId = arbreEntitesGeographiques.getNodeById(""+id_location); |
| // si la région existe déjà |
| if(noeudMemeId != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeLoc = arbreEntitesGeographiques.getNodeById(""+(id_location+location)); |
| if(noeudMemeLoc != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeLieu = arbreEntitesGeographiques.getNodeById(""+(id_location+location+lieuDit)); |
| if(noeudMemeLieu != null) |
| { |
| // tous les noeuds existent déjà, normalement ça ne devrait pas arriver |
| } |
| else |
| { |
| // enfin on ne crée que le noeud du lieu dit |
| TreeNode node_lieu = new TreeNode(); |
| node_lieu.setId(""+(id_location+location+lieuDit)); |
| node_lieu.setText(lieuDit); |
| String[] usObj = {lieuDit,id_location+location+lieuDit}; |
| node_lieu.setUserObject(usObj); |
| noeudMemeLoc.appendChild(node_lieu) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| // on crée le noeud de la location |
| TreeNode node_loc = new TreeNode(); |
| node_loc.setId(""+(id_location+location)); |
| node_loc.setText(location); |
| String[] usObj = {location,id_location+location}; |
| node_loc.setUserObject(usObj); |
| noeudMemeId.appendChild(node_loc) ; |
| TreeNode node_lieu = new TreeNode(); |
| node_lieu.setId(""+(id_location+location+lieuDit)); |
| node_lieu.setText(lieuDit); |
| String[] usObj2 = {lieuDit,id_location+location+lieuDit}; |
| node_lieu.setUserObject(usObj2); |
| node_loc.appendChild(node_lieu) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| // TODO: Pourquoi l'ajout ne marche que sur la racine ? |
| // on crée le noeud de l'id location |
| TreeNode node_id_loc = new TreeNode(); |
| node_id_loc.setId(""+id_location); |
| node_id_loc.setText(id_location); |
| String[] usObj = {id_location,id_location}; |
| node_id_loc.setUserObject(usObj); |
| root.appendChild(node_id_loc) ; |
| TreeNode node_loc = new TreeNode(); |
| node_loc.setId(""+(id_location+location)); |
| node_loc.setText(location); |
| String[] usObj2 = {location,id_location+location}; |
| node_loc.setUserObject(usObj2); |
| node_id_loc.appendChild(node_loc) ; |
| TreeNode node_lieu = new TreeNode(); |
| node_lieu.setId(""+(id_location+location+lieuDit)); |
| node_lieu.setText(lieuDit); |
| String[] usObj3 = {lieuDit,id_location+location+lieuDit}; |
| node_lieu.setUserObject(usObj3); |
| node_loc.appendChild(node_lieu) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| arbreEntitesGeographiques.doLayout() ; |
| } |
| } |
| /** |
| * Accesseur pour le panneau contenant l'arbre |
| * |
| * @return le panneau de l'arbre des mots clés |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreEntitesGeographiques; |
| } |
| /** |
| * Méthode héritée de Filtrable renvoie le nom du filtre |
| */ |
| public String renvoyerNomFiltre() { |
| return "Localité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[] = {nomFiltre, entitesGeographiquesEncours } ; |
| 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.setUserObject(usObj); |
| child.setId(""+usObj[1]); |
| 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) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| public int compare(TreeNode o1, TreeNode o2) { |
| if(o1.getText().equals("Inconnue")) { |
| return -1 ; |
| } |
| if(o2.getText().equals("Inconnue")) { |
| return 1 ; |
| } |
| if(o1.getDepth() == 1 && o2.getDepth() == 1) |
| { |
| String l1 = o1.getText() ; |
| String l2 = o2.getText() ; |
| if(l1.length() == 1) { |
| l1 = "0"+l1; |
| } |
| if(l2.length() == 1) { |
| l2 = "0"+l2; |
| } |
| Integer n1 = 0; |
| Integer n2 = 0; |
| try{ |
| n1 = Integer.parseInt(l1) ; |
| n2 = Integer.parseInt(l2) ; |
| } catch(NumberFormatException ne) { |
| n1 = 0; |
| n2 = 0; |
| } |
| return n1.compareTo(n2) ; |
| } |
| else |
| { |
| String n1 = o1.getText() ; |
| String n2 = o2.getText() ; |
| return n1.compareTo(n2) ; |
| } |
| } |
| } ; |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreEntitesGeographiques.collapseAll(); |
| arbreEntitesGeographiques.clear() ; |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Localités"); |
| root.setId("racine_entite"); |
| String[] usObject = { "Localités" }; |
| root.setUserObject(usObject); |
| arbreEntitesGeographiques.setRootNode(root); |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| arbreCharge = false ; |
| this.doLayout() ; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,642 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.DateObservation; |
| import org.tela_botanica.client.modeles.ListeDateObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.core.client.GWT; |
| 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; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| import com.gwtext.client.core.EventObject; |
| /** |
| * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton |
| * cliquable |
| * |
| * @author aurelien |
| * |
| */ |
| public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * Les localites en cours |
| */ |
| private String donneesDateEnCours = ""; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreDonneesDates = null; |
| /** |
| * La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue |
| */ |
| private Tree donneesDates = new Tree(); |
| /** |
| * booléen d'initialisation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * booléen d'etat |
| */ |
| private boolean filtreModifie = false; |
| private boolean arbreCharge = false ; |
| private String nomFiltre = "" ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreDateObservationFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreDateObservationFiltreVue(ObservationMediateur obs) { |
| // on crée le panel |
| super("Dates"); |
| this.observationMediateur = obs; |
| arbreDonneesDates = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(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 |
| arbreDonneesDates.setEnableDD(false); |
| arbreDonneesDates.setId("x-view-tree-filter-date"); |
| arbreDonneesDates.setBorder(false); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Dates"); |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", "racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.setRootVisible(true); |
| arbreDonneesDates.setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreDonneesDates); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| }); |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| private void ajouterListeners() { |
| arbreDonneesDates.addListener(new TreePanelListenerAdapter() { |
| public void onClick(TreeNode node, EventObject e) { |
| nomFiltre = "" ; |
| donneesDateEnCours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(!arbreCharge) |
| { |
| /* arbreCharge = true ; |
| observationMediateur.obtenirDatesObservation() ;*/ |
| arbreDonneesDates.getRootNode().expand(); |
| } |
| else |
| { |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| return ; |
| case 3: nomFiltre += "annee,mois,jour"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 2: nomFiltre += "annee,mois"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 1: nomFiltre += "annee"; |
| donneesDateEnCours += ((String[])node.getUserObject())[1] ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = true ; |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| arbreDonneesDates.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeDateObservation) { |
| String annee=null; |
| String mois=null; |
| String jour=null; |
| ListeDateObservation data = (ListeDateObservation) nouvelleDonnees ; |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine_date"); |
| root.setText("Dates"); |
| String[] usObjRoot = { "Dates", "Dates", "racine_date"}; |
| root.setUserObject(usObjRoot); |
| Tree nouvelArbre = new Tree(); |
| nouvelArbre.setRootNode(root); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| DateObservation ent=(DateObservation) data.get(it.next()); |
| annee= ent.getAnnee() ; |
| mois= ent.getMois() ; |
| String moisLettre = renvoyerMois(Integer.parseInt(mois)) ; |
| jour= ent.getJour() ; |
| if(annee.contains("0000")) { |
| annee="Inconnue" ; |
| } |
| if(jour.contains("00")) { |
| jour="Inconnue" ; |
| } |
| Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = nouvelArbre.getNodeById(""+(annee+mois+jour)); |
| if(noeudMemeJour != null) |
| { |
| // tous les noeuds existent déjà, normalement ça ne devrait pas arriver |
| } |
| else |
| { |
| // enfin on ne crée que le noeud du lieu dit |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| noeudMemeMois.appendChild(node_jour) ; |
| String[] usObj = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj); |
| } |
| } |
| else |
| { |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| noeudMemeAnnee.appendChild(node_mois) ; |
| String[] usObj = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj); |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| node_mois.appendChild(node_jour) ; |
| String[] usObj2 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj2); |
| } |
| } |
| else |
| { |
| TreeNode node_annee = new TreeNode(); |
| node_annee.setId(""+annee); |
| node_annee.setText(annee); |
| root.appendChild(node_annee) ; |
| String[] usObj = {annee, annee, annee}; |
| node_annee.setUserObject(usObj); |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| node_annee.appendChild(node_mois) ; |
| String[] usObj2 = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj2); |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| node_mois.appendChild(node_jour) ; |
| String[] usObj3 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj3); |
| } |
| } |
| // on trie |
| root.sort(comparerNoeuds()) ; |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() { |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| // et on recopie le nouvel arbre |
| copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates |
| .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() ; |
| doLayout(); |
| } |
| if(nouvelleDonnees instanceof Observation) |
| { |
| // si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout |
| // l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement |
| // de l'arbre |
| if(!arbreCharge) { |
| return; |
| } |
| Observation ent = (Observation)nouvelleDonnees ; |
| String dateSpl[] = ent.getDate().split("/") ; |
| String annee= dateSpl[2]; |
| String mois= dateSpl[1]; |
| String jour= dateSpl[0]; |
| String moisLettre = renvoyerMois(Integer.parseInt(mois)) ; |
| Node root = arbreDonneesDates.getRootNode() ; |
| if(annee.contains("0000") || annee.equals(null)) { |
| annee="Inconnue" ; |
| } |
| if(jour.contains("00") || jour.equals(null)) { |
| jour="Inconnue" ; |
| } |
| Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(annee+mois+jour)); |
| if(noeudMemeJour != null) |
| { |
| // tous les noeuds existent déjà, normalement ça ne devrait pas arriver |
| } |
| else |
| { |
| // enfin on ne crée que le noeud du lieu dit |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj); |
| noeudMemeMois.appendChild(node_jour) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| String[] usObj = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj); |
| noeudMemeAnnee.appendChild(node_mois) ; |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj2 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj2); |
| node_mois.appendChild(node_jour) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| TreeNode node_annee = new TreeNode(); |
| node_annee.setId(""+annee); |
| node_annee.setText(annee); |
| String[] usObj = {annee,annee,annee}; |
| node_annee.setUserObject(usObj); |
| root.appendChild(node_annee) ; |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| String[] usObj2 = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj2); |
| node_annee.appendChild(node_mois) ; |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj3 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj3); |
| node_mois.appendChild(node_jour) ; |
| // TODO : améliorer la compararaison des noeuds |
| root.sort(comparerNoeuds()) ; |
| } |
| arbreDonneesDates.doLayout() ; |
| } |
| } |
| /** |
| * Accesseur pour le panneau contenant l'arbre |
| * |
| * @return le panneau de l'arbre des mots clés |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreDonneesDates; |
| } |
| /** |
| * Méthode héritée de Filtrable renvoie le nom du filtre |
| */ |
| public String renvoyerNomFiltre() { |
| return "Dates"; |
| } |
| /** |
| * 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[] = {nomFiltre, donneesDateEnCours } ; |
| 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.setUserObject(usObj); |
| child.setId(""+usObj[2]); |
| 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) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| public int compare(TreeNode o1, TreeNode o2) { |
| String n1 = ((String[])o1.getUserObject())[1] ; |
| String n2 = ((String[])o2.getUserObject())[1] ; |
| return n1.compareTo(n2) ; |
| } |
| } ; |
| } |
| public String renvoyerMois(int numMois) { |
| switch (numMois) { |
| case 1: |
| return "janvier" ; |
| case 2: |
| return "fevrier" ; |
| case 3: |
| return "mars" ; |
| case 4: |
| return "avril" ; |
| case 5: |
| return "mai" ; |
| case 6: |
| return "juin" ; |
| case 7: |
| return "juillet" ; |
| case 8: |
| return "août" ; |
| case 9: |
| return "septembre" ; |
| case 10: |
| return "octobre" ; |
| case 11: |
| return "novembre" ; |
| case 12: |
| return "décembre" ; |
| default: |
| return "Inconnue" ; |
| } |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreDonneesDates.collapseAll(); |
| arbreDonneesDates.clear(); |
| TreeNode root = new TreeNode("Dates"); |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", "racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,584 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.Configuration; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Image; |
| import com.google.gwt.user.client.ui.LoadListener; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.core.AnimationConfig; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.core.RegionPosition; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.layout.BorderLayout; |
| import com.gwtext.client.widgets.layout.BorderLayoutData; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| /** |
| * Panneau d'affichage d'une image avec des boutons précdents et suivant |
| * |
| * @author aurelien |
| * |
| */ |
| public class MiniZoomImageVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur = null; |
| /** |
| * Panneau conteneur pour l'image |
| */ |
| private Panel imageConteneur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(""); |
| /** |
| * Bouton précédent |
| */ |
| private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Bouton suivant |
| */ |
| private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Taille originale Y de l'image |
| */ |
| private int imageHeight = 0; |
| /** |
| * Taille originale X de l'image |
| */ |
| private int imageWidth = 0; |
| /** |
| * Identifiant de l'image |
| */ |
| private String idImage = "0" ; |
| private String[] infosImages[] = null ; |
| private int index = 0 ; |
| /** |
| * true pour animer les transitions |
| */ |
| private boolean animerTransition = false; |
| /** |
| * Détermine la durée de la transition |
| */ |
| private float dureeAnimation = (float) 0.15; |
| /** |
| * Booleen d'initalisation général |
| */ |
| private boolean initialise = false; |
| /** |
| * Booleen d'initalisation du conteneur d'image |
| */ |
| private boolean conteneurInitialise = false; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| Image imgAgrandie = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MiniZoomImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| */ |
| public MiniZoomImageVue(ObservationMediateur im) { |
| super("Image liées"); |
| setId("x-view-mini-zoom-panel"); |
| // on associe le médiateur |
| oMediateur = im; |
| prev.setStylePrimaryName("x-view-zoom-button-p"); |
| suiv.setStylePrimaryName("x-view-zoom-button-s"); |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| // on crée une image qui gère le double clic et la roulette de la souris |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors d'un déplacement de la roulette |
| if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) { |
| // on simule un clic sur le bouton précédent |
| if (event.getMouseWheelVelocityY() >= 1) { |
| prev.click(); |
| } |
| // ou suivant |
| if (event.getMouseWheelVelocityY() <= -1) { |
| suiv.click(); |
| } |
| } |
| if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) { |
| event.preventDefault() ; |
| int[] xy = {event.getClientX(),event.getClientY()} ; |
| afficherMenu(xy) ; |
| } |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| afficherPanneauAgrandi(); |
| } |
| } |
| }; |
| image.setPixelSize(150, 150); |
| infosImages = new String[0][0] ; |
| this.setHeader(true); |
| imageConteneur = new Panel() ; |
| imageConteneur.setBorder(false); |
| imageConteneur.add(image); |
| imageConteneur.setId("x-view-mini-zoom-img"); |
| // il n'existe pas de méthode pour ajouter un listener pour le double |
| // clic sur une image |
| // alors on lui dit manuellement de capter l'évènement double clic |
| image.sinkEvents(Event.ONDBLCLICK); |
| image.sinkEvents(Event.ONMOUSEWHEEL); |
| image.sinkEvents(Event.ONCONTEXTMENU) ; |
| // l'image de base est vide |
| image.setUrl(""); |
| this.setLayout(new BorderLayout()); |
| prev.setWidth("15%"); |
| suiv.setWidth("15%"); |
| this.add(prev, new BorderLayoutData(RegionPosition.WEST)); |
| this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER)); |
| this.add(suiv, new BorderLayoutData(RegionPosition.EAST)); |
| imageConteneur.setMaskDisabled(true); |
| this.setBorder(false); |
| conteneurInitialise = true; |
| initialise = true; |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen qui dit si on doit répnadre l'évènement |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit une string |
| if (nouvelleDonnees instanceof String[][] && initialise |
| && conteneurInitialise && ((String[][])nouvelleDonnees).length != 0) { |
| infosImages = (String[][]) nouvelleDonnees; |
| index = 0 ; |
| afficherImage() ; |
| } else { |
| // sinon on met une image vide |
| infosImages = null ; |
| afficherImage(); |
| } |
| } |
| public void afficherImage() |
| { |
| // c'est l'url de l'image qu'on associe à la vue |
| if(infosImages != null && infosImages.length != 0) |
| { |
| activerPanneau() ; |
| getImage().setUrl(convertirIdEnUrl(infosImages[index][0])); |
| imageWidth = Integer.parseInt(infosImages[index][1]); |
| imageHeight = Integer.parseInt(infosImages[index][2]); |
| verifierEtRetaillerImage(); |
| } else { |
| getImage().setUrl("ill_liaison.png"); |
| imageWidth = getImage().getWidth(); |
| imageHeight = getImage().getHeight(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| prev.setEnabled(false); |
| suiv.setEnabled(false); |
| } |
| } |
| /** |
| * Active visuellement le panneau et les boutons |
| */ |
| public void activerPanneau() { |
| prev.setEnabled(true); |
| suiv.setEnabled(true); |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| // gestion du clic sur le bouton précedent |
| prev.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| if(infosImages.length != 0) { |
| if(index == 0) |
| { |
| index = infosImages.length - 1 ; |
| } |
| else |
| { |
| index-- ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| if(infosImages.length != 0) { |
| if(index == infosImages.length - 1) |
| { |
| index = 0 ; |
| } |
| else |
| { |
| index++ ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ObservationMediateur getIMediateur() { |
| return oMediateur; |
| } |
| /** |
| * Accesseur au conteneur de l'image |
| * |
| * @return le conteneur de l'image |
| */ |
| public Image getImage() { |
| return image; |
| } |
| /** |
| * Acesseurs pour l'identifiant de l'image |
| * @return l'id de l'image |
| */ |
| public String getIdImage() |
| { |
| return infosImages[index][0] ; |
| } |
| /** |
| * Accesseur pour le bouton précédent |
| * |
| * @return le bouton précédent |
| */ |
| public com.google.gwt.user.client.ui.Button getPrev() { |
| return prev; |
| } |
| /** |
| * Accesseur pour le bouton suivant |
| * |
| * @return le bouton suivant |
| */ |
| public com.google.gwt.user.client.ui.Button getSuiv() { |
| return suiv; |
| } |
| /** |
| * Setter pour la taille de l'image |
| * |
| * @param x |
| * la largeur en pixels |
| * @param y |
| * la hauteur en pixels |
| */ |
| public void setTailleImage(int x, int y) { |
| imageHeight = y; |
| imageWidth = x; |
| } |
| /** |
| * Setteur pour l'identifiant de l'image |
| * @param id le nouvel identifiant |
| */ |
| public void setIdImage(String id) |
| { |
| idImage = id ; |
| } |
| /** |
| * renvoie la taille originale de l'image |
| * |
| * @return un tableau de deux entiers contenant la largeur puis la hauteur |
| */ |
| public int[] getTailleImage() { |
| int[] taille = { imageHeight, imageWidth }; |
| return taille; |
| } |
| /** |
| * Accesseur pour le conteneur de l'image |
| * @return le conteur de l'image |
| */ |
| public Panel getImageConteneur() { |
| return imageConteneur; |
| } |
| public void raz() { |
| infosImages = new String[0][0] ; |
| getImage().setUrl(""); |
| } |
| public void supprimerLiaisonImage() { |
| if(infosImages.length > 0) { |
| getImage().setUrl("") ; |
| int nouvelleTaille = infosImages.length - 1 ; |
| int indexSupp = index ; |
| String[][] nouveauInfosImages = new String[nouvelleTaille][3] ; |
| int j = 0 ; |
| for(int i = 0 ; i < infosImages.length ; i++) { |
| if(i != indexSupp) { |
| nouveauInfosImages[j] = infosImages[i] ; |
| j++ ; |
| } |
| } |
| infosImages = nouveauInfosImages ; |
| index = 0 ; |
| afficherImage() ; |
| } |
| } |
| public void afficherMenu(int[] xy) { |
| Menu mn = new Menu() ; |
| final Item suppLiaison = new Item("Supprimer la liaison") ; |
| mn.addItem(suppLiaison) ; |
| mn.addListener(new MenuListenerAdapter() { |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'aide |
| if (item.equals(suppLiaison)) { |
| // on notifie le médiateur |
| getIMediateur().supprimerLiaisonObsImage() ; |
| } |
| } |
| }) ; |
| mn.showAt(xy) ; |
| } |
| public String convertirIdEnUrl(String idImg) |
| { |
| int maxZeros = 9 - idImg.length(); |
| for (int j = 0; j < maxZeros; j++) { |
| idImg = "0" + idImg; |
| } |
| String baseUrl = Configuration.getImageBaseUrl() ; |
| String dossierNv1 = idImg.substring(0, 3); |
| String dossierNv2 = idImg.substring(3, 6); |
| String fichierNv = idImg.substring(6, 9); |
| String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv; |
| String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 }; |
| String urlImg = baseUrl + infosFichier[1] + "/" + infosFichier[2] + "/M/" |
| + infosFichier[0] + "_M.jpg"; |
| return urlImg ; |
| } |
| /** |
| * Verifie si l'image est plus grande que le conteneur et la retaille le cas |
| * echeant |
| */ |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| int[] dim = calculerDimensions(getTailleImage(),300,imageConteneur.getWidth()); |
| getImage().setSize("" + dim[0] + "px", |
| "" + dim[1] + "px"); |
| doLayout(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| } |
| public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ; |
| float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ; |
| float[] XYresize = new float[2]; |
| if(maxTaille == tailleXY[0]) { |
| float rapport = tailleXYf[1]/tailleXYf[0] ; |
| XYresize[0] = tailleOr ; |
| XYresize[1] = tailleOr*rapport ; |
| }else { |
| float rapport = tailleXYf[0]/tailleXYf[1] ; |
| XYresize[1] = tailleOr ; |
| XYresize[0] = tailleOr*rapport ; |
| } |
| int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ; |
| return res; |
| } |
| protected void agrandirImage() { |
| String urlAgrandie = ""; |
| if(infosImages == null) { |
| urlAgrandie = "ill_liaison.png"; |
| setTailleImage(265, 270); |
| } else { |
| urlAgrandie = convertirIdEnUrl(infosImages[index][0]).replace("_M", "_L") ; |
| urlAgrandie = urlAgrandie.replace("/M/", "/L/") ; |
| } |
| if(imgAgrandie == null) { |
| imgAgrandie = new Image(urlAgrandie); |
| imgZoom.add(imgAgrandie); |
| imgAgrandie.addLoadListener(new LoadListener() { |
| public void onError(Widget sender) { |
| // TODO Auto-generated method stub |
| } |
| public void onLoad(Widget sender) { |
| int[] tailleImage = calculerDimensions(getTailleImage(),getTailleImage()[1],Window.getClientHeight()*0.75); |
| ExtElement imgElement = Ext.get(imgAgrandie.getElement()); |
| if(animerTransition) { |
| AnimationConfig a = new AnimationConfig() ; |
| a.setDuration((float) dureeAnimation); |
| imgElement.setHeight(tailleImage[1], a); |
| imgElement.setWidth(tailleImage[0], a); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], a); |
| winElement.setWidth(tailleImage[0], a); |
| } else { |
| imgElement.setHeight(tailleImage[1], false); |
| imgElement.setWidth(tailleImage[0], false); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], false); |
| winElement.setWidth(tailleImage[0], false); |
| } |
| } |
| }); |
| } else { |
| imgAgrandie.setUrl(urlAgrandie); |
| imgAgrandie.setVisible(true); |
| } |
| } |
| private void afficherPanneauAgrandi() { |
| imgZoom.show(this.getElement()); |
| agrandirImage(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java |
|---|
| New file |
| 0,0 → 1,203 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant la repartition d'une plante |
| * |
| * @author David Delon |
| * |
| */ |
| public class InformationRepartitionVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private InformationRepartitionVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public InformationRepartitionVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| image.sinkEvents(Event.ONDBLCLICK); |
| this.setCls("x-image-info-rep") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage carte de repartition |
| * |
| */ |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String) { |
| urlImage=(String) nouvelleDonnees; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) { |
| image.setUrl("ill_choro.png") ; |
| image.setPixelSize(150, 150); |
| } |
| else { |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| String urlAgrandie = urlImage.replace("min", "max") ; |
| imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| imgZoom.show(this.getElement()) ; |
| } |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java |
|---|
| New file |
| 0,0 → 1,202 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant une image generique provenant d eflore |
| * |
| * @author David Delon |
| * |
| */ |
| public class ImageGeneriqueVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ImageGeneriqueVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public ImageGeneriqueVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| this.setCls("x-image-gen") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| image.sinkEvents(Event.ONDBLCLICK); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage image generique |
| * |
| */ |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String) { |
| urlImage=(String) nouvelleDonnees; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) { |
| image.setUrl("ill_taxon.png") ; |
| image.setPixelSize(150, 150); |
| } |
| else { |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } |
| observationMediateur.deMasquerChargementInfosObservations() ; |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| String urlAgrandie = urlImage.replace("min", "max") ; |
| imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| imgZoom.show(this.getElement()) ; |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/NuageMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,166 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| 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.Event; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| public class NuageMotsClesVue extends Window implements Filtrable, Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| private Object[][] listeMotsPesee = null; |
| private String motsAChercher = "" ; |
| private int nbMotsClesMax = 1 ; |
| private boolean nuageCharge = false ; |
| public NuageMotsClesVue(ObservationMediateur om) { |
| super("Nuage de mots clés"); |
| setCls("fenmotcles"); |
| oMediateur = om ; |
| setWidth(200); |
| this.setCloseAction(CLOSE); |
| //oMediateur.obtenirNuageMotsCles(this); |
| this.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container self) { |
| if(!nuageCharge) { |
| masquerChargement(); |
| } |
| } |
| @Override |
| public void onRender(Component component) { |
| } |
| @Override |
| public void onShow(Component component) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof Integer) { |
| nbMotsClesMax = (Integer)nouvelleDonnees; |
| } |
| if(nouvelleDonnees instanceof Object[][]) { |
| listeMotsPesee = (Object[][])nouvelleDonnees ; |
| construireNuage(); |
| } |
| } |
| private void construireNuage() { |
| String contenu = "<ul class=\"nuagetag\">" ; |
| for(int i = 0; i<listeMotsPesee.length; i++) { |
| String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ; |
| contenu += "<li class=\""+classeMotCle+"\">"; |
| contenu += (String)listeMotsPesee[i][0]; |
| contenu += "</li>"; |
| } |
| contenu += "</ul>" ; |
| HTML contenuHTML = new HTML(contenu) { |
| public void onBrowserEvent(Event e) { |
| //oMediateur.ajouterMotCleRecherche(e.getTarget().getInnerHTML()); |
| } |
| }; |
| contenuHTML.sinkEvents(Event.ONCLICK); |
| this.clear(); |
| this.add(contenuHTML); |
| doLayout(); |
| nuageCharge = true; |
| demasquerChargement(); |
| } |
| private int calculerPoids(int poidMot) { |
| int poids = (poidMot*10)/nbMotsClesMax; |
| if(poids < 1) { |
| return 1; |
| } |
| return poids; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
| */ |
| public void demasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.unmask() ; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,806 |
| package org.tela_botanica.client.vues.observation; |
| import java.util.Iterator; |
| import org.tela_botanica.client.modeles.ListeObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.vues.BarrePaginationVue; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.interfaces.VueListable; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.data.ArrayReader; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.MemoryProxy; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Tool; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.ToolbarTextItem; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.grid.CellMetadata; |
| import com.gwtext.client.widgets.grid.ColumnConfig; |
| import com.gwtext.client.widgets.grid.ColumnModel; |
| import com.gwtext.client.widgets.grid.GridPanel; |
| import com.gwtext.client.widgets.grid.Renderer; |
| import com.gwtext.client.widgets.grid.event.GridListenerAdapter; |
| import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter; |
| /** |
| * Liste d'observation composée de ligne d'observation |
| * l'interface rafraichissable et l'interface vueListable |
| * |
| * @author David Delon 2008 |
| */ |
| public class ListeObservationVue extends GridPanel implements Rafraichissable, |
| VueListable, ListePaginable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig etatObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig nomSaisiObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig nomRetenuObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig lieuObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig dateObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig ordreObservation; |
| /** |
| * Modele de colonnes |
| */ |
| private ColumnModel modeleColonnes; |
| /** |
| * Store qui contient les données à afficher |
| */ |
| private Store st = null; |
| /** |
| * Barre de pagination |
| */ |
| private BarrePaginationVue bt = null ; |
| /** |
| * Numéro de page en cours |
| */ |
| private int pageEncours = 0 ; |
| /** |
| * Nombre de pages totales |
| */ |
| private int pageMax = 1 ; |
| /** |
| * Taille de page (par défaut 20) |
| */ |
| private int taillePage = 20 ; |
| /** |
| * Nombre d'éléments total correspondant à la requete |
| */ |
| private int nbElements = 0 ; |
| private ListeObservation cacheListeObservation = null; |
| private Tool exporterObservations = null ; |
| private final int KEY_ENTER = 13; |
| private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION"; |
| /** |
| * Constructeur sans arguments (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ListeObservationVue() |
| { |
| super() ; |
| } |
| /** |
| * Constructeur avec argument |
| * @param im le médiateur à associer |
| */ |
| public ListeObservationVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| setHeader(true); |
| // on place la barre de pagination |
| bt = new BarrePaginationVue(this); |
| bt.setLabelElement("Observations"); |
| bt.setTaillePageParDefaut(20); |
| bt.setIntervallesPages(new String[] {"400","200", "100" , "50" , "20", "10"}) ; |
| Toolbar barreActions = new Toolbar(); |
| ToolbarButton publier = new ToolbarButton("Rendre publiques"); |
| publier.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(true); |
| } |
| }); |
| ToolbarButton privatiser = new ToolbarButton("Rendre privées"); |
| privatiser.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(false); |
| } |
| }); |
| ToolbarButton supprimer = new ToolbarButton("Supprimer"); |
| supprimer.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.supprimerObservations(); |
| } |
| }); |
| ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>"); |
| barreActions.addButton(publier); |
| barreActions.addButton(privatiser); |
| barreActions.addSpacer(); |
| barreActions.addButton(supprimer); |
| barreActions.addSpacer(); |
| barreActions.addItem(exporter); |
| this.setTopToolbar(barreActions) ; |
| this.setBottomToolbar(bt); |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| this.setTitle("Observations") ; |
| // on construit le modèle de colonnes |
| // Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir) |
| Renderer colRend = new Renderer() { |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) { |
| return "" ; |
| } |
| else |
| { |
| } |
| return value.toString() ; |
| } |
| } ; |
| Renderer dateRend = new Renderer() { |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) { |
| return "" ; |
| } |
| else |
| { |
| String dateEntiere = value.toString() ; |
| String[] dateEtHeure = dateEntiere.split(" ", 2); |
| if(verifierFormatDate(dateEtHeure[0])) { |
| String[] dateFormateeTab = dateEtHeure[0].split("-",3); |
| return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ; |
| } |
| } |
| return value.toString() ; |
| } |
| } ; |
| etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, true, new Renderer() { |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value.equals("1")) |
| { |
| return "<img src=\"tela.png\"/></img>" ; |
| } |
| else |
| { |
| return "" ; |
| } |
| } |
| }); |
| nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200, true, colRend); |
| nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200, true, colRend); |
| lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200, true, colRend); |
| dateObservation = new ColumnConfig("Date", "date_observation", 120, true, dateRend); |
| ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50, true, colRend); |
| // on associe le modèle de colonnes |
| ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation}; |
| modeleColonnes = new ColumnModel(cm); |
| this.setColumnModel(modeleColonnes); |
| this.setAutoScroll(true); |
| this.setEnableColumnResize(true); |
| //temp dd viewport desactive ajout de ces 2 lignes |
| // this.setAutoWidth(true); |
| // temp |
| // creation du store |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
| FieldDef defDateObservation = new StringFieldDef("date_observation"); |
| FieldDef defOrdreObservation = new StringFieldDef("ordre_observation"); |
| FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
| defLieuObservation, defDateObservation, defOrdreObservation }; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| // on associe le store |
| this.setStore(st); |
| this.getView().setAutoFill(true); |
| this.getView().setForceFit(true) ; |
| // on crée un masque de chargement qui s'affichera lors des mises à jour |
| this.setLoadMask("Chargement"); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| this.addGridRowListener(new GridRowListenerAdapter() { |
| // gestion du clic sur une ligne |
| public void onRowClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur et on lui passe le numéro de ligne |
| Record rd = getStore().getAt(rowIndex); |
| String ordreObservation = rd.getAsString("ordre_observation") ; |
| observationMediateur.onClicListeObservation(rowIndex,ordreObservation); |
| } |
| // gestion du clic droit |
| public void onRowContextMenu(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu |
| e.stopEvent() ; |
| // on notifie le médiateur en lui passant l'évenement |
| observationMediateur.montrerContextMenu(e); |
| } |
| // gestion du double clic |
| public void onRowDblClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur en lui passant le numéro de ligne |
| observationMediateur.doubleClicListeObservation(rowIndex); |
| } |
| }); |
| this.addGridListener(new GridListenerAdapter() { |
| public void onKeyPress(EventObject e) { |
| if(e.getKey() == KEY_ENTER) { |
| Record rd = getSelectionModel().getSelected(); |
| int rowIndex = st.indexOf(rd); |
| String ordreObservation = rd.getAsString("ordre_observation") ; |
| observationMediateur.onClicListeObservation(rowIndex, ordreObservation); |
| } |
| } |
| }); |
| this.addListener(new PanelListenerAdapter() { |
| public void onRender(Component c) { |
| ExtElement lienExport = Ext.get("lienExport") ; |
| lienExport.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| observationMediateur.exporterObservations(); |
| } |
| }); |
| } |
| }); |
| } |
| /** |
| * Méthode héritée de l'interface VueListable |
| * Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres |
| */ |
| public String[] getIdSelectionnees() { |
| Record[] selection = this.getSelectionModel().getSelections(); |
| int taille = selection.length; |
| String id_selection[] = new String[taille]; |
| for (int i = 0; i < selection.length; i++) { |
| id_selection[i] = selection[i].getAsString("ordre_observation"); |
| } |
| return id_selection; |
| } |
| /** |
| * Sélectionne des enregistrements donné |
| * @param sel un tableau d'enregistrement à selectionner |
| */ |
| public void selectionnerEnregistrements(Record[] sel) { |
| getSelectionModel().clearSelections(); |
| getSelectionModel().selectRecords(sel); |
| } |
| /** |
| * Accesseur pour la toolbar de pagination |
| * @return la toolbar de pagination |
| */ |
| public BarrePaginationVue getToolBarVue() |
| { |
| return bt ; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
| */ |
| public void demasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| if(masked.isMasked()) |
| { |
| masked.unmask() ; |
| } |
| } |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * @param nouvelleDonnees les nouvelles données |
| * @param repandreRafraichissement le booleen de notification du rafraichissement |
| */ |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) { |
| // si l'on a reçu une liste d'observation |
| if(nouvelleDonnees instanceof ListeObservation) |
| { |
| ListeObservation data = (ListeObservation) nouvelleDonnees ; |
| Object[][] observationData = new Object[data.size()][7]; |
| int i = 0 ; |
| if(data.size() == 0) |
| { |
| pageEncours = 0 ; |
| } |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| Observation obs=(Observation) data.get(it.next()); |
| observationData[i][0] = obs.getTransmis(); |
| observationData[i][1] = obs.getNomSaisi(); |
| observationData[i][2] = obs.getNomRetenu(); |
| observationData[i][3] = fabriquerLieu(obs); |
| observationData[i][4] = obs.getDate(); |
| observationData[i][5] = obs.getNumeroOrdre(); |
| observationData[i][6] = obs.getNumeroNomenclaturalSaisi(); |
| i++ ; |
| } |
| // creation du store qui les contient |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
| FieldDef defDateObservation = new StringFieldDef("date_observation"); |
| FieldDef defOrdreObservation = new StringFieldDef("ordre_observation"); |
| // Non affiches : |
| FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation"); |
| // on associe le store |
| FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
| defLieuObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation }; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(observationData); |
| final ArrayReader reader = new ArrayReader(rd); |
| final Store observationStore = new Store(dataProxy, reader); |
| st = observationStore ; |
| st.load() ; |
| // et on reconfigure et rafraichit la vue |
| this.reconfigure(st, this.getColumnModel()); |
| demasquerChargement(); |
| cacheListeObservation=data; |
| observationMediateur.onRafraichissementListeObservations(); |
| } |
| // Si on reçoit un tableau d'entiers |
| // c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères |
| if(nouvelleDonnees instanceof int[]) |
| { |
| int[] pages = (int[])nouvelleDonnees ; |
| // on calcule le nombre de pages nécessaires et on les met à jour dans le modèle |
| pageMax = calculerNbPages(pages[0]) ; |
| nbElements = pages[0] ; |
| // et on notifie de le mediateur du changement des valeurs |
| changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ; |
| masquerChargement(); |
| observationMediateur.obtenirListeObservation(this); |
| } |
| // si l'on a reçu une Observation |
| if(nouvelleDonnees instanceof Observation) { |
| Observation obs= (Observation) nouvelleDonnees; |
| if (obs.getNumeroOrdre()==null) { // Nouvelle observation |
| // On affiche la dernière page |
| pageEncours = pageMax ; |
| masquerChargement(); |
| observationMediateur.obtenirNombreObservation(); |
| } |
| else { // Modification d'une observation |
| masquerChargement(); |
| observationMediateur.obtenirNombreObservation(); |
| } |
| } |
| // Si on a effectué une suppression |
| if(nouvelleDonnees instanceof String) |
| { |
| String str = (String)nouvelleDonnees ; |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| } |
| // GESTION DE LA PAGINATION |
| public ListeObservation getCacheListeObservation() { |
| return cacheListeObservation; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page |
| * en cours |
| * @param nbElements le nombre d'élements total |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages(int nbElements) |
| { |
| // A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division |
| // nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur |
| double nPage = (1.0*nbElements)/(1.0*taillePage) ; |
| double nPageRound = Math.ceil(nPage) ; |
| Double nPageInt = new Double(nPageRound) ; |
| // on convertit en entier |
| return nPageInt.intValue() ; |
| } |
| /** |
| * Recalcule la page en cours lors du changement du nombre d'élements |
| * @param nbElements le nombre d'élements total |
| * @return la nouvelle page encours |
| */ |
| public int calculerPageCourante(int nbElements) |
| { |
| // on calcule le nombre de page |
| int nouvelNbPages = calculerNbPages(nbElements) ; |
| // la nouvelle page en cours |
| double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ; |
| // on arrondit au supérieur |
| double nPageRound = Math.ceil(nPageCourante) ; |
| Double nPageInt = new Double(nPageRound) ; |
| // on convertit en entier |
| return Math.abs(nPageInt.intValue()) ; |
| } |
| /** |
| * Appelle le modèle pour lui demander les données d'une page à afficher |
| * @param pageCourante le numéro de page à affciher |
| */ |
| public void changerNumeroPage(int pageCourante) { |
| pageEncours = pageCourante ; |
| masquerChargement(); |
| // On lance le chargerment des observations |
| observationMediateur.obtenirNombreObservation(); |
| getToolBarVue().changerPageCourante(pageCourante); |
| } |
| /** |
| * Appelle le modèle pour qu'il change la taille de page utilisée |
| * @param nouvelleTaillePage la nouvelle taille de page |
| */ |
| public void changerTaillePage(int nouvelleTaillePage) |
| { |
| taillePage = nouvelleTaillePage ; |
| pageEncours = calculerPageCourante(nbElements) ; |
| masquerChargement(); |
| // On lance le chargement des observations |
| observationMediateur.obtenirNombreObservation(); |
| // et on met à jour la taille de page dans les barres d'outils |
| getToolBarVue().selectionnerTaillePage(nouvelleTaillePage); |
| } |
| /** |
| * Met à jour les barre d'outils avec des nouvelles valeurs |
| * @param pageMax le nombre de pages |
| * @param pageEncours la page en cours |
| * @param taillePage la taille de page |
| * @param nbElement le nombre d'élements par page |
| */ |
| public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement) |
| { |
| int[] pages = {pageMax,pageEncours, taillePage, nbElement} ; |
| getToolBarVue().rafraichir(pages, false) ; |
| } |
| /** |
| * Renvoie la taille de page en cours d'utilisation |
| * @return la taille de page |
| */ |
| public int getTaillePage() { |
| return taillePage; |
| } |
| /** |
| * Renvoie le numéro de la page encours (attention on commence à 0) |
| * @return le numéro de la page en cours |
| */ |
| public int getPageEncours() { |
| return pageEncours; |
| } |
| public void afficherFiltres(String nLieu, String nDate) |
| { |
| String titre = "Observations " ; |
| if(!nLieu.equals("")) |
| { |
| titre += " - Lieu : "+nLieu ; |
| } |
| if(!nDate .equals("")) |
| { |
| titre += " - Date : "+nDate ; |
| } |
| this.setTitle(titre) ; |
| } |
| public void raz() { |
| // creation du store qui les contient |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
| FieldDef defDateObservation = new StringFieldDef("date_observation"); |
| FieldDef defOrdreObservation = new StringFieldDef("ordre_observation"); |
| // Non affiches : |
| FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation"); |
| FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
| defLieuObservation, defDateObservation, defOrdreObservation }; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| // on associe le store |
| this.setStore(st); |
| } |
| public boolean verifierFormatDate(String date) { |
| String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ; |
| if(date.matches(regex) && !date.equals("0000-00-00")) { |
| return true ; |
| } |
| else { |
| return false; |
| } |
| } |
| private String fabriquerLieu(Observation obs) { |
| String lieuModele = modeleLieu; |
| String commune = obs.getLocalite(); |
| String lieuDit = obs.getLieudit(); |
| String station = obs.getStation(); |
| String lieuCommuneFormate = ""; |
| String lieuDitFormate = ""; |
| String stationFormatee = ""; |
| if(commune != null && !commune.contains("000null") && !commune.trim().equals("")) { |
| String idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/"); |
| if(idLoc != null && !idLoc.contains("000null") && !idLoc.trim().equals("")) { |
| idLoc = idLoc.replaceAll("%",""); |
| idLoc = idLoc.replaceAll("\"",""); |
| idLoc = idLoc.replace('\\',' '); |
| idLoc = idLoc.trim(); |
| lieuCommuneFormate += idLoc+" - "; |
| } |
| lieuCommuneFormate += commune; |
| lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE", lieuCommuneFormate); |
| } else { |
| lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE,", lieuCommuneFormate); |
| } |
| if(lieuDit != null && !lieuDit.contains("000null") && !lieuDit.trim().equals("")) { |
| lieuDitFormate += lieuDit; |
| lieuModele = lieuModele.replaceAll("LIEUDIT", lieuDitFormate); |
| } else { |
| lieuModele = lieuModele.replaceAll("LIEUDIT,", lieuDitFormate); |
| } |
| if(station != null && !station.contains("000null") && !station.trim().equals("")) { |
| stationFormatee += station; |
| lieuModele = lieuModele.replaceAll("STATION", stationFormatee); |
| } else { |
| lieuModele = lieuModele.replaceAll("STATION", stationFormatee); |
| } |
| return lieuModele; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java |
|---|
| New file |
| 0,0 → 1,182 |
| package org.tela_botanica.client.vues.observation; |
| 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.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.KeyListener; |
| import com.gwtext.client.widgets.form.TextField; |
| public class MotsClesObsVue extends Panel implements Filtrable, Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| /** |
| * Barre de recherche |
| * |
| */ |
| private TextField champRecherche = null; |
| /** |
| * Booleen d'etat du filtre |
| */ |
| private boolean filtreModifie = false; |
| /** |
| * mot(s) à chercher |
| */ |
| private String motsAChercher = ""; |
| /** |
| * bouton de validation |
| */ |
| private Button ok = null ; |
| private Button afficherNuage = null; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MotsClesObsVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec médiateur |
| * |
| * @param im |
| */ |
| public MotsClesObsVue(ObservationMediateur om) { |
| super(); |
| oMediateur = om; |
| Label labelRecherche = new Label("Mots clés :"); |
| champRecherche = new TextField(); |
| ok = new Button("Rechercher"); |
| afficherNuage = new Button("Voir les mots clés"); |
| add(labelRecherche); |
| add(champRecherche); |
| add(ok); |
| add(afficherNuage); |
| setPaddings(5); |
| setBorder(false); |
| setCollapsible(true); |
| ajouterListeners(); |
| } |
| /** |
| * ajoute des listeners |
| */ |
| private void ajouterListeners() { |
| // gestion de la touche entrée |
| champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() { |
| public void onKey(int key, EventObject e) { |
| valider(); |
| } |
| }); |
| ok.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| afficherNuage.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| // oMediateur.afficherNuageMotsCles(); |
| } |
| }); |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof String) { |
| champRecherche.setValue(champRecherche.getValueAsString()+" "+(String)nouvelleDonnees); |
| } |
| filtreModifie = false; |
| } |
| /** |
| * renvoie l'état du filtre (modifié ou non) |
| * |
| * @return l'état du filtre |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| public String renvoyerNomFiltre() { |
| return "Recherche 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() { |
| String[] valeurFiltre = new String[0]; |
| if(!motsAChercher.equals("")) { |
| valeurFiltre = new String[2]; |
| valeurFiltre[0] = "mots_cles"; |
| valeurFiltre[1] = motsAChercher; |
| } |
| return valeurFiltre; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ObservationMediateur getIMediateur() { |
| return oMediateur; |
| } |
| /** |
| * Effectue quelque opérations dans la classe et envoie une requête de |
| * données au médiateur |
| */ |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| oMediateur.obtenirNombreObservation(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java |
|---|
| New file |
| 0,0 → 1,1341 |
| package org.tela_botanica.client.vues.observation; |
| // TODO Detecter redim et supprimer ajuster |
| import java.util.Date; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.ListeObservation; |
| import org.tela_botanica.client.modeles.ListeReferentielCommune; |
| import org.tela_botanica.client.modeles.ListeReferentielNom; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.modeles.ReferentielCommune; |
| import org.tela_botanica.client.modeles.ReferentielNom; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ListenerConfig; |
| import com.gwtext.client.core.Position; |
| import com.gwtext.client.data.ArrayReader; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.MemoryProxy; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.SimpleStore; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.DatePicker; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.Viewport; |
| import com.gwtext.client.widgets.event.BoxComponentListenerAdapter; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.DatePickerListener; |
| import com.gwtext.client.widgets.event.DatePickerListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.DateField; |
| import com.gwtext.client.widgets.form.Field; |
| import com.gwtext.client.widgets.form.FormPanel; |
| import com.gwtext.client.widgets.form.TextArea; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.layout.AnchorLayoutData; |
| import com.gwtext.client.widgets.layout.ColumnLayout; |
| import com.gwtext.client.widgets.layout.ColumnLayoutData; |
| import com.gwtext.client.widgets.layout.FormLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.data.Record; |
| /** |
| * Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il implémente l'interface rafraichissable |
| * @author aurelien |
| * |
| */ |
| public class FormulaireSaisieObservationVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| FormPanel panneauFormulaire = null; |
| private DateField date = null; |
| private TextField lieudit = null; |
| private TextField station = null; |
| private TextField milieu = null; |
| private TextField comment = null; |
| private ComboBox commune = null; |
| private String departement = null; |
| private ComboBox espece = null; |
| private String numeroNom = null; |
| private String numeroOrdre = null; |
| // Pour remise a zero partielle lors d'une validation |
| private enum Champs { |
| DATE, LIEUDIT, STATION, MILIEU, COMMENT, COMMUNE, ESPECE, TOUT ; |
| public String toString() { |
| switch(this) { |
| case DATE: |
| return "date"; |
| case COMMUNE: |
| return "commune"; |
| case LIEUDIT: |
| return "lieu dit"; |
| case STATION: |
| return "station"; |
| case MILIEU: |
| return "milieu"; |
| case COMMENT: |
| return "commentaire"; |
| case ESPECE: |
| return "espèce"; |
| case TOUT: |
| return "date, commune, lieu dit, station, milieu, espèce, commentaire"; |
| } |
| return TOUT.toString(); |
| } |
| }; |
| private String formatDate = null ; |
| private Button boutonOK = new Button("Créer"); |
| private Button boutonAnnuler = new Button("Réinitialiser"); |
| private boolean selectionCommune=false; |
| private boolean selectionEspece=false; |
| private boolean modification = false ; |
| private Toolbar bt = null ; |
| private final String VALEURS_MULTIPLES = "(Valeurs multiples)"; |
| private final String modeleMessageModif = "commune:lieu-dit:station:milieu:date:espece:commentaire"; |
| private boolean communeModifiee = false; |
| private boolean lieuDitModifie = false; |
| private boolean stationModifiee = false; |
| private boolean milieuModifie = false; |
| private boolean dateModifiee = false; |
| private boolean especeModifiee = false; |
| private boolean commModifie = false; |
| private final int KEY_ALT = 18; |
| private final int KEY_BACKSPACE = 8; |
| private final int KEY_CTRL = 17; |
| private final int KEY_DELETE = 46; |
| private final int KEY_DOWN = 40; |
| private final int KEY_END = 35; |
| private final int KEY_ENTER = 13; |
| private final int KEY_ESCAPE = 27; |
| private final int KEY_HOME = 36; |
| private final int KEY_LEFT = 37; |
| private final int KEY_PAGEDOWN = 34; |
| private final int KEY_PAGEUP = 33; |
| private final int KEY_RIGHT = 39; |
| private final int KEY_SHIFT = 16; |
| private final int KEY_TAB = 9; |
| private final int KEY_UP = 38; |
| /** |
| * Combobox permettant de selectionner le mode |
| * modification ou bien création |
| */ |
| private ComboBox selecteurMode = new ComboBox(); |
| Store storeMode = null ; |
| /** |
| * Booleen d'instanciation |
| */ |
| boolean estInstancie = false ; |
| private Panel panneauIntermediaire; |
| private Panel panneauPremierColonne; |
| private Panel panneauSecondeColonne; |
| private boolean masseModification =false ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private FormulaireSaisieObservationVue() |
| { |
| super() ; |
| } |
| /** |
| * Constructeur avec argument |
| * @param im |
| */ |
| public FormulaireSaisieObservationVue(ObservationMediateur obs) |
| { |
| // on associe le médiateur |
| observationMediateur = obs ; |
| panneauFormulaire = new FormPanel(Position.RIGHT); |
| panneauFormulaire.setBorder(false); |
| // Panneau intermediaire qui contient deux colonnes de formulaire |
| panneauIntermediaire = new Panel(); |
| if (Window.getClientWidth()> Window.getClientHeight()) { |
| panneauIntermediaire.setLayout(new ColumnLayout()); |
| } |
| else { |
| panneauIntermediaire.setLayout(new RowLayout()); |
| } |
| panneauIntermediaire.setBorder(false); |
| if (Ext.isIE6()) { |
| panneauIntermediaire.setWidth(800); |
| } |
| //create first panel and add fields to it |
| panneauPremierColonne = new Panel(); |
| panneauPremierColonne.setLayout(new FormLayout()); |
| panneauPremierColonne.setBorder(false); |
| //create second panel and add fields to it |
| panneauSecondeColonne = new Panel(); |
| panneauSecondeColonne.setLayout(new FormLayout()); |
| panneauSecondeColonne.setBorder(false); |
| this.setPaddings(5) ; |
| // Accesskey pour debugging |
| commune=new ComboBox("Commune","commune\" accesskey=\"1"); |
| final String resultTplCommune = "<div class=\"search-item-commune\">{commune}</div>"; |
| commune.setTpl(resultTplCommune); |
| commune.setMode(ComboBox.REMOTE); |
| // commune.setPageSize(10); // Ne fonctionne pas |
| commune.setItemSelector("div.search-item-commune"); |
| commune.setTypeAhead(true); |
| commune.setLoadingText("Recherche..."); |
| commune.setHideTrigger(true); |
| commune.setTabIndex(1); |
| panneauPremierColonne.add(commune, new AnchorLayoutData("95%")); |
| station = new TextField("Station", "station"); |
| station.setAllowBlank(true); |
| station.setTabIndex(3); |
| panneauPremierColonne.add(station, new AnchorLayoutData("95%")); |
| date = new DateField("Date", "date", 100); |
| date.setAllowBlank(true); |
| formatDate = "d/m/Y"; |
| date.setFormat(formatDate) ; |
| date.setTabIndex(5); |
| panneauPremierColonne.add(date, new AnchorLayoutData("60%")); |
| espece=new ComboBox("Espèce","nom"); |
| final String resultTplEspece = "<div class=\"search-item-espece\">{nom}</div>"; |
| espece.setTpl(resultTplEspece); |
| espece.setMode(ComboBox.REMOTE); |
| // commune.setPageSize(10); // Ne fonctionne pas |
| espece.setItemSelector("div.search-item-espece"); |
| espece.setTypeAhead(true); |
| espece.setLoadingText("Recherche..."); |
| espece.setHideTrigger(true); |
| espece.setTabIndex(6); |
| panneauPremierColonne.add(espece, new AnchorLayoutData("95%")); |
| lieudit = new TextField("Lieu-dit", "lieudit"); |
| lieudit.setAllowBlank(true); |
| lieudit.setTabIndex(2); |
| panneauSecondeColonne.add(lieudit, new AnchorLayoutData("95%")); |
| milieu = new TextField("Milieu", "milieu"); |
| milieu.setAllowBlank(true); |
| milieu.setTabIndex(4); |
| panneauSecondeColonne.add(milieu, new AnchorLayoutData("95%")); |
| comment = new TextArea("Notes", "comment"); |
| comment.setAllowBlank(true); |
| comment.setHeight(50); |
| comment.setTabIndex(7); |
| panneauSecondeColonne.add(comment, new AnchorLayoutData("95%") ); |
| if (Window.getClientWidth()> Window.getClientHeight()) { |
| panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5)); |
| panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5)); |
| } |
| else { |
| panneauIntermediaire.add(panneauPremierColonne); |
| panneauIntermediaire.add(panneauSecondeColonne); |
| } |
| panneauFormulaire.add(panneauIntermediaire); |
| Object[][] mode = {{"création",false} , {"modification", true} }; |
| storeMode = new SimpleStore(new String[] { "nom_mode", "mode" }, |
| mode); |
| storeMode.load(); |
| selecteurMode.setStore(storeMode); |
| selecteurMode.setDisplayField("nom_mode") ; |
| selecteurMode.setLabel("mode ") ; |
| selecteurMode.setForceSelection(true) ; |
| selecteurMode.setValue("création") ; |
| selecteurMode.setEditable(false) ; |
| selecteurMode.setCls("x-selec-crea") ; |
| bt = new Toolbar() ; |
| bt.addSpacer() ; |
| bt.addText("Mode de saisie ") ; |
| bt.addField(selecteurMode) ; |
| boutonOK.setTabIndex(8); |
| boutonAnnuler.setTabIndex(9); |
| if (Ext.isIE6()) { |
| panneauPremierColonne.setButtonAlign(Position.RIGHT); |
| panneauPremierColonne.addButton(boutonOK); |
| panneauSecondeColonne.setButtonAlign(Position.LEFT); |
| panneauSecondeColonne.addButton(boutonAnnuler); |
| } |
| else { |
| panneauFormulaire.addButton(boutonOK); |
| panneauFormulaire.addButton(boutonAnnuler); |
| } |
| selecteurMode.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| // et on met la valeur à jour dans la combobox |
| comboBox.setValue(record.getAsString("nom_mode")); |
| setModification(record.getAsString("mode")) ; |
| } |
| }); |
| this.add(panneauFormulaire) ; |
| this.setTopToolbar(bt) ; |
| this.setAutoScroll(true); |
| panneauFormulaire.addListener(new PanelListenerAdapter() { |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, int rawWidth, int rawHeight) { |
| panneauIntermediaire.setWidth(rawWidth); |
| panneauIntermediaire.setHeight(rawHeight); |
| }}); |
| // on ajoute les listeners |
| ajouterListeners() ; |
| } |
| private void ajouterListeners() |
| { |
| // Listener completion communne |
| commune.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| commune.setValue(record.getAsString("commune")); |
| departement=record.getAsString("departement"); |
| selectionCommune=true; |
| } |
| }); |
| ListenerConfig listenerConfigCommune=new ListenerConfig(); |
| listenerConfigCommune.setDelay(10); |
| listenerConfigCommune.setStopPropagation(false); |
| listenerConfigCommune.setStopEvent(false); |
| commune.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| if (selectionCommune) { |
| communeModifiee= true; |
| selectionCommune=false; |
| } |
| else { |
| validerSaisie(Champs.COMMUNE); |
| // lancer mise a jour |
| } |
| break; |
| default: |
| departement=""; |
| obtenirListeReferentielCommune(); |
| communeModifiee= true; |
| break; |
| } |
| } |
| }, listenerConfigCommune |
| ); |
| date.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| if(date.getRawValue().equals(VALEURS_MULTIPLES)) { |
| date.clearInvalid(); |
| } |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.DATE); |
| break; |
| default: |
| dateModifiee = true; |
| } |
| } |
| }); |
| date.addListener(new DatePickerListenerAdapter() { |
| public void onSelect(DatePicker dataPicker, Date date) { |
| dateModifiee = true; |
| } |
| }); |
| station.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.STATION); |
| break; |
| default: |
| stationModifiee = true; |
| } |
| } |
| }); |
| // Listener completion espece |
| espece.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| espece.setValue(record.getAsString("nom")); |
| numeroNom=record.getAsString("numeroNom"); |
| selectionEspece=true; |
| observationMediateur.obtenirImageInformationExternes(numeroNom); |
| } |
| }); |
| ListenerConfig listenerConfigEspece=new ListenerConfig(); |
| listenerConfigEspece.setDelay(10); |
| listenerConfigEspece.setStopPropagation(false); |
| listenerConfigEspece.setStopEvent(false); |
| espece.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| if(selectionEspece) { |
| especeModifiee = true; |
| selectionEspece=false; |
| } |
| else { |
| validerSaisie(Champs.ESPECE); |
| } |
| break; |
| default: |
| numeroNom=""; |
| obtenirListeReferentielNom(); |
| especeModifiee = true; |
| break; |
| } |
| } |
| }, listenerConfigEspece |
| ); |
| lieudit.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.LIEUDIT); |
| break; |
| default: |
| lieuDitModifie = true; |
| } |
| } |
| }); |
| milieu.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.MILIEU); |
| break; |
| default: |
| milieuModifie = true; |
| } |
| } |
| }); |
| comment.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| default: |
| commModifie = true; |
| } |
| } |
| }); |
| boutonOK.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| if(modification) { |
| if(masseModification) { |
| modifierObservationEnMasse(null); |
| } else { |
| modifierObservation() ; |
| } |
| } |
| else { |
| ajouterObservation(); |
| } |
| } |
| }); |
| boutonAnnuler.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| if(modification) |
| { |
| supprimerObservation() ; |
| } |
| else |
| { |
| raz(); |
| } |
| } |
| }); |
| this.addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container self) { |
| commune.focus(); |
| } |
| }); |
| } |
| /** |
| * Validation de la saisie |
| */ |
| private void validerSaisie(Champs champs) { |
| if(modification) { |
| if(masseModification) { |
| modifierObservationEnMasse(champs); |
| } else { |
| modifierObservation(); |
| } |
| raz(champs); |
| } |
| else { |
| ajouterObservation(); |
| raz(champs); |
| } |
| } |
| /** |
| * Desactive visuellement ce panneau |
| */ |
| public void desactiverPanneau() |
| { |
| this.setDisabled(true) ; |
| } |
| /** |
| * Active visuellement ce panneau |
| */ |
| public void activerPanneau() |
| { |
| this.setDisabled(false) ; |
| } |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| // si l'on a reçu une liste du referentiel commune (completion referentiel commune) |
| if(nouvelleDonnees instanceof ListeReferentielCommune) |
| { |
| ListeReferentielCommune data = (ListeReferentielCommune) nouvelleDonnees ; |
| Object[][] communeData = new Object[data.size()][2]; |
| int i = 0 ; |
| // on la parse et on récupère les informations quiç nous interessent |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| ReferentielCommune ref=(ReferentielCommune) data.get(it.next()); |
| communeData[i][0]= ref.getCommune(); |
| communeData[i][1]= ref.getDepartement(); |
| i++ ; |
| } |
| // creation du store |
| FieldDef defCommune = new StringFieldDef("commune"); |
| FieldDef defDepartement = new StringFieldDef("departement"); |
| FieldDef[] defTab = { defCommune, defDepartement}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(communeData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| store.load() ; |
| commune.setStore(store); |
| } |
| // si l'on a reçu une liste du référentiel nom (complétion referentiel nom) |
| if(nouvelleDonnees instanceof ListeReferentielNom) |
| { |
| ListeReferentielNom data = (ListeReferentielNom) nouvelleDonnees ; |
| Object[][] nomData = new Object[data.size()][2]; |
| int i = 0 ; |
| // on la parse et on récupère les informations quiç nous interessent |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| ReferentielNom ref=(ReferentielNom) data.get(it.next()); |
| nomData[i][0]= ref.getNom(); |
| nomData[i][1]= ref.getNumeroNom(); |
| i++ ; |
| } |
| // creation du store |
| FieldDef defNom = new StringFieldDef("nom"); |
| FieldDef defNumeroNom = new StringFieldDef("numeroNom"); |
| FieldDef[] defTab = { defNom, defNumeroNom}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(nomData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| store.load() ; |
| espece.setStore(store); |
| } |
| // On recoit une observation dont on veut afficher le detail |
| if(nouvelleDonnees instanceof Observation) |
| { |
| Observation obs = (Observation)nouvelleDonnees ; |
| afficherDetailsObservation(obs) ; |
| } |
| if(nouvelleDonnees instanceof ListeObservation) { |
| ListeObservation listeObs = (ListeObservation)nouvelleDonnees; |
| calculerAfficherDifferences(listeObs); |
| } |
| // Sur Mise à jour ou suppression d'une suppression ? |
| if(nouvelleDonnees instanceof String) |
| { |
| String str = (String)nouvelleDonnees ; |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| if(nouvelleDonnees instanceof String[]) { |
| String[] anumNom = (String[])nouvelleDonnees ; |
| numeroNom = anumNom[1]; |
| espece.setValue(anumNom[0]); |
| setModification("false"); |
| } |
| } |
| public void obtenirListeReferentielCommune() { |
| String com=commune.getText().replaceAll(" ","/"); |
| com=com.replaceAll("%",""); |
| observationMediateur.obtenirListeReferentielCommune(this,com); |
| } |
| public void obtenirListeReferentielNom() { |
| String esp=espece.getText().replaceAll(" ","/"); |
| esp=esp.replaceAll("%",""); |
| observationMediateur.obtenirListeReferentielNom(this,esp); |
| } |
| public void ajouterObservation() { |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.getText().split(" "); |
| if(depCom.length > 1) { |
| String dep = depCom[1].replace('(', ' '); |
| dep =dep.replace(')', ' '); |
| dep = dep.trim(); |
| dep = dep.replace('\\',' '); |
| dep = dep.trim(); |
| try |
| { |
| int nDep = Integer.parseInt(dep); |
| if(nDep > 0 && nDep < 110) { |
| departement = dep ; |
| } |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| } |
| } |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),date.getRawValue()); |
| observationMediateur.ajouterObservation(obs); |
| } |
| private void modifierObservation() { |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.getText().split(" "); |
| if(depCom.length > 1) { |
| String dep = depCom[1].replace('(', ' '); |
| dep =dep.replace(')', ' '); |
| dep = dep.trim(); |
| dep = dep.replace('\\',' '); |
| dep = dep.trim(); |
| try |
| { |
| int nDep = Integer.parseInt(dep); |
| if(nDep > 0 && nDep < 110) { |
| departement = dep ; |
| } |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| } |
| } |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),date.getRawValue()); |
| obs.setNumeroOrdre(numeroOrdre); |
| observationMediateur.modifierObservation(obs); |
| selecteurMode.setValue("création"); |
| setModification("false"); |
| } |
| private void modifierObservationEnMasse(Champs champModifie) { |
| String communeM = null; |
| String departementM = null; |
| String numNomSelM = null; |
| String lieuDitM = null; |
| String stationM = null; |
| String milieuM = null; |
| String dateM = null; |
| String especeM = null; |
| String commM = null; |
| String champs = modeleMessageModif; |
| if(communeModifiee) { |
| communeM = commune.getText(); |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.getText().split(" "); |
| if(depCom.length > 1) { |
| String dep = depCom[1].replace('(', ' '); |
| dep =dep.replace(')', ' '); |
| dep = dep.trim(); |
| dep = dep.replace('\\',' '); |
| dep = dep.trim(); |
| try |
| { |
| int nDep = Integer.parseInt(dep); |
| if(nDep > 0 && nDep < 110) { |
| departement = dep ; |
| } |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| } |
| } |
| departementM = departement; |
| } else { |
| champs = champs.replaceAll("commune", ""); |
| } |
| if(lieuDitModifie) { |
| lieuDitM = lieudit.getText(); |
| }else { |
| champs = champs.replaceAll(":lieu-dit", ""); |
| } |
| if(stationModifiee) { |
| stationM = station.getText(); |
| }else { |
| champs = champs.replaceAll(":station", ""); |
| } |
| if(milieuModifie) { |
| milieuM = milieu.getText(); |
| }else { |
| champs = champs.replaceAll(":milieu", ""); |
| } |
| if(dateModifiee && !date.getRawValue().equals(VALEURS_MULTIPLES)) { |
| dateM = date.getRawValue(); |
| }else { |
| champs = champs.replaceAll(":date", ""); |
| } |
| if(especeModifiee) { |
| especeM = espece.getText(); |
| numNomSelM = numeroNom; |
| }else { |
| champs = champs.replaceAll(":espece", ""); |
| } |
| if(commModifie) { |
| commM = comment.getText(); |
| }else { |
| champs = champs.replaceAll(":commentaire", ""); |
| } |
| champs = champs.replaceAll(":",", "); |
| if(champs.startsWith(",")) { |
| champs = champs.replaceFirst(",", ""); |
| } |
| String message = "Voulez vous modifier le(s) champ(s) suivant(s) : "+champs+" pour les observations selectionnées ?" ; |
| if(champs.trim().equals("")) { |
| Window.alert("Aucun champ n'a été modifié"); |
| } else { |
| Observation obs = new Observation(especeM,numNomSelM,communeM,departementM,lieuDitM,stationM,milieuM, commM,dateM); |
| obs.setNumeroOrdre(numeroOrdre); |
| if(Window.confirm(message)) { |
| observationMediateur.modifierObservationEnMasse(obs); |
| reinitialiserValeurModifiees(); |
| } |
| } |
| } |
| private void supprimerObservation() { |
| observationMediateur.supprimerObservation(this, numeroOrdre); |
| } |
| public void afficherDetailsObservation(Observation obs) |
| { |
| raz() ; |
| String idLoc ; |
| if(obs.getIdentifiantLocalite() != VALEURS_MULTIPLES) { |
| idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/"); |
| idLoc = idLoc.replaceAll("%",""); |
| idLoc = idLoc.replaceAll("\"",""); |
| idLoc = idLoc.replace('\\',' '); |
| idLoc = idLoc.trim(); |
| } else { |
| idLoc = obs.getIdentifiantLocalite(); |
| } |
| if(!obs.getDate().equals("null") && !obs.getDate().equals("000null") && !obs.getDate().equals(VALEURS_MULTIPLES)) { |
| String[] dateEtHeure = obs.getDate().split(" ", 2); |
| if(verifierFormatDate(dateEtHeure[0])) { |
| date.setValue(dateEtHeure[0]) ; |
| } |
| else |
| { |
| date.setRawValue(""); |
| } |
| } else { |
| date.setRawValue(VALEURS_MULTIPLES); |
| date.clearInvalid(); |
| } |
| if(!obs.getLieudit().equals("null") && !obs.getLieudit().equals("000null")) { |
| lieudit.setValue(obs.getLieudit()) ; |
| } |
| if(!obs.getStation().equals("null") && !obs.getStation().equals("000null")) { |
| station.setValue(obs.getStation()) ; |
| } |
| if(!obs.getMilieu().equals("null") && !obs.getMilieu().equals("000null")) { |
| milieu.setValue(obs.getMilieu()) ; |
| } |
| if(!obs.getCommentaire().equals("null") && !obs.getCommentaire().equals("000null")) { |
| comment.setValue(obs.getCommentaire()) ; |
| } |
| if(!obs.getLocalite().equals("null") && !obs.getLocalite().equals("000null")) { |
| if(!idLoc.equals("000null")) { |
| if(!idLoc.equals(VALEURS_MULTIPLES)) { |
| commune.setValue(obs.getLocalite()+" ("+idLoc+")") ; |
| } else { |
| commune.setValue(VALEURS_MULTIPLES); |
| } |
| } |
| else |
| { |
| commune.setValue(obs.getLocalite()); |
| } |
| } |
| if(!obs.getIdentifiantLocalite().equals("null") && !obs.getIdentifiantLocalite().equals("000null")) { |
| departement = idLoc; |
| } |
| if(!obs.getNomSaisi().equals("null") && !obs.getNomSaisi().equals("000null")) { |
| espece.setValue(obs.getNomSaisi()) ; |
| } |
| if(!obs.getNumeroNomenclaturalSaisi().equals("null") && !obs.getNumeroNomenclaturalSaisi().equals("000null")) { |
| numeroNom = obs.getNumeroNomenclaturalSaisi() ; |
| } |
| if(!obs.getNumeroOrdre().equals("null") && !obs.getNumeroOrdre().equals("000nu2ll")) { |
| numeroOrdre = obs.getNumeroOrdre() ; |
| } |
| } |
| public void raz() |
| { |
| raz(Champs.TOUT); |
| } |
| public void raz(Champs champs) |
| { |
| switch (champs) { |
| case DATE: |
| date.reset() ; |
| break; |
| case LIEUDIT: |
| lieudit.reset() ; |
| break; |
| case STATION: |
| station.reset() ; |
| break; |
| case MILIEU: |
| milieu.reset() ; |
| break; |
| case COMMENT: |
| comment.reset() ; |
| break; |
| case COMMUNE: |
| commune.reset() ; |
| departement =""; |
| break; |
| case ESPECE: |
| espece.reset(); |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| break; |
| case TOUT: |
| commune.reset(); |
| date.reset() ; |
| lieudit.reset() ; |
| station.reset() ; |
| milieu.reset() ; |
| comment.reset() ; |
| milieu.reset() ; |
| departement =""; |
| espece.reset(); |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| break; |
| } |
| } |
| private void setModification(String mode) |
| { |
| if(mode.equals("true")) { |
| boutonOK.setText("Modifier") ; |
| setTitle("Modification") ; |
| boutonAnnuler.setText("Supprimer") ; |
| modification = true ; |
| selecteurMode.removeClass("x-selec-crea") ; |
| selecteurMode.setCls("x-selec-modif") ; |
| observationMediateur.onModeModification(); |
| } |
| else |
| { |
| boutonOK.setText("Ajouter") ; |
| setTitle("Saisir") ; |
| boutonAnnuler.setText("Réinitialiser") ; |
| modification = false ; |
| selecteurMode.removeClass("x-selec-modif") ; |
| selecteurMode.setCls("x-selec-crea") ; |
| } |
| } |
| /** |
| * renvoie vrai si on est en mode modification, faux si on est en mode création |
| * @return |
| */ |
| public boolean getModification() |
| { |
| return modification ; |
| } |
| /** |
| * renvoie vrai si on est en mode modification de masse, faux sinon |
| * @return |
| */ |
| public boolean getMasseModification() |
| { |
| return masseModification ; |
| } |
| public boolean verifierFormatDate(String date) { |
| String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ; |
| if(date.matches(regex) && !date.equals("0000-00-00")) { |
| return true ; |
| } |
| else { |
| return false; |
| } |
| } |
| public void setMasseModification(boolean masseModification) { |
| this.masseModification = masseModification; |
| if(masseModification) { |
| reinitialiserValeurModifiees(); |
| } |
| } |
| private void calculerAfficherDifferences(ListeObservation listeObs) { |
| String departement = null; |
| String commune = null; |
| String lieuDit = null; |
| String station = null; |
| String milieu = null; |
| String espece = null; |
| String date = null; |
| String notes = null; |
| String ordreObs = ""; |
| for(Iterator<String> it = listeObs.keySet().iterator();it.hasNext();) { |
| Observation obsEnCours = listeObs.get(it.next()); |
| departement = comparerDifferencesChamps(departement, obsEnCours.getIdentifiantLocalite()); |
| commune = comparerDifferencesChamps(commune, obsEnCours.getLocalite()); |
| lieuDit = comparerDifferencesChamps(lieuDit, obsEnCours.getLieudit()); |
| station = comparerDifferencesChamps(station, obsEnCours.getStation()); |
| milieu = comparerDifferencesChamps(milieu, obsEnCours.getMilieu()); |
| espece = comparerDifferencesChamps(espece, obsEnCours.getNomSaisi()); |
| date = comparerDifferencesChamps(date, obsEnCours.getDate()); |
| notes = comparerDifferencesChamps(notes, obsEnCours.getCommentaire()); |
| ordreObs += obsEnCours.getNumeroOrdre()+","; |
| } |
| Observation obs=new Observation(espece,numeroNom,commune,departement,lieuDit,station,milieu, notes,date); |
| obs.setNumeroOrdre(ordreObs); |
| rafraichir(obs, false); |
| } |
| private String comparerDifferencesChamps(String valeurActuelle, String nouvelleValeur) { |
| String retour = "000null"; |
| if(valeurActuelle == null) { |
| retour = nouvelleValeur; |
| } else { |
| if(valeurActuelle.equals(nouvelleValeur)) { |
| retour = valeurActuelle; |
| } else { |
| retour = VALEURS_MULTIPLES; |
| } |
| } |
| return retour; |
| } |
| private void reinitialiserValeurModifiees() { |
| communeModifiee = false; |
| lieuDitModifie = false; |
| stationModifiee = false; |
| milieuModifie = false; |
| dateModifiee = false; |
| especeModifiee = false; |
| commModifie = false; |
| } |
| private Field obtenirCorrespondanceChampsEnum(Champs champ) { |
| switch(champ) { |
| case DATE: |
| return date; |
| case COMMUNE: |
| return commune; |
| case LIEUDIT: |
| return lieudit; |
| case STATION: |
| return station; |
| case MILIEU: |
| return milieu; |
| case COMMENT: |
| return comment; |
| case ESPECE: |
| return espece; |
| } |
| return null; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java |
|---|
| New file |
| 0,0 → 1,133 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreDateObservationFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreEntiteGeographiqueObservationFiltreVue; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| /** |
| * Panneau contenant les filtres qu'on peut appliquer aux images |
| * |
| * @author aurelien |
| * |
| */ |
| public class PanneauFiltresObservationVues extends Panel { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * L'arbre pour la recherche entite geographique |
| * |
| */ |
| private ArbreEntiteGeographiqueObservationFiltreVue arbreEntiteGeographiqueObservationFiltreVue = null; |
| /** |
| * L'arbre pour la recherche date |
| * |
| */ |
| private ArbreDateObservationFiltreVue arbreDateObservationFiltreVue = null; |
| private ArbreMotsClesFiltreVue arbreMotsClesFiltreVue = null ; |
| /** |
| * Construcuteur sans argument (privé car on ne doit pas l'utiliser) |
| */ |
| @SuppressWarnings("unused") |
| private PanneauFiltresObservationVues() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public PanneauFiltresObservationVues(ObservationMediateur obs) { |
| super("Filtres"); |
| observationMediateur = obs; |
| this.setCollapsible(true); |
| //this.setLayout(new AnchorLayout()) ; |
| this.setLayout(new RowLayout()); |
| arbreEntiteGeographiqueObservationFiltreVue = new ArbreEntiteGeographiqueObservationFiltreVue(observationMediateur); |
| add(arbreEntiteGeographiqueObservationFiltreVue,new RowLayoutData()); |
| //arbreEntiteGeographiqueObservationFiltreVue.setHeight(300) ; |
| arbreEntiteGeographiqueObservationFiltreVue.setWidth("100%") ; |
| arbreEntiteGeographiqueObservationFiltreVue.setBorder(false); |
| arbreDateObservationFiltreVue = new ArbreDateObservationFiltreVue(observationMediateur) ; |
| //arbreDateObservationFiltreVue.setHeight(300) ; |
| add(arbreDateObservationFiltreVue, new RowLayoutData()); |
| arbreDateObservationFiltreVue.setWidth("100%") ; |
| arbreDateObservationFiltreVue.setBorder(false); |
| arbreMotsClesFiltreVue = new ArbreMotsClesFiltreVue(observationMediateur); |
| add(arbreMotsClesFiltreVue, new RowLayoutData()); |
| arbreMotsClesFiltreVue.setWidth("100%") ; |
| arbreMotsClesFiltreVue.setTitle("Mots Clés"); |
| arbreMotsClesFiltreVue.setTitleCollapse(true); |
| arbreMotsClesFiltreVue.setCollapsible(true); |
| arbreMotsClesFiltreVue.setBorder(false); |
| arbreMotsClesFiltreVue.hide(); |
| } |
| /** |
| * Accesseur pour le filtre des mots clés |
| * |
| * @return le filtre des mots clés |
| */ |
| public ArbreEntiteGeographiqueObservationFiltreVue getArbreEntiteGeographiqueObservationFiltreVue() { |
| return arbreEntiteGeographiqueObservationFiltreVue; |
| } |
| public ArbreDateObservationFiltreVue getArbreDateObservationFiltreVue() { |
| return arbreDateObservationFiltreVue; |
| } |
| public ArbreMotsClesFiltreVue getArbreMotsClesFiltreVue() { |
| return arbreMotsClesFiltreVue; |
| } |
| /** |
| * Renvoie un booléen indiquant si un des filtres a été modifié |
| * |
| * @return true sur un des filtres est modifié, false sinon |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return (arbreEntiteGeographiqueObservationFiltreVue.renvoyerEtatFiltre() || arbreDateObservationFiltreVue.renvoyerEtatFiltre()); |
| } |
| /** |
| * Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre", |
| * "valeur" |
| * |
| * @return un tableau contenant les noms et les valeurs à filtrer |
| */ |
| public String[][] renvoyerValeursAFiltrer() { |
| String[][] filtres = { arbreEntiteGeographiqueObservationFiltreVue.renvoyerValeursAFiltrer(), |
| arbreDateObservationFiltreVue.renvoyerValeursAFiltrer(), |
| arbreMotsClesFiltreVue.renvoyerValeursAFiltrer() |
| }; |
| return filtres; |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java |
|---|
| New file |
| 0,0 → 1,104 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| public class MenuObservationVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur; |
| /** |
| * Item pour la suppression d'obs |
| */ |
| private Item supprimerObservation = null; |
| private Item transmettreObservation = null; |
| private Item deTransmettreObservation = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuObservationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuObservationVue(ObservationMediateur om) { |
| super(); |
| oMediateur = om; |
| transmettreObservation = new Item("Rendre publiques les observations séléctionnées"); |
| addItem(transmettreObservation); |
| deTransmettreObservation = new Item("Rendre privées les observations séléctionnées"); |
| addItem(deTransmettreObservation); |
| supprimerObservation = new Item("Supprimer les observations séléctionnées"); |
| addItem(supprimerObservation); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(supprimerObservation)) { |
| // on notifie le médiateur |
| getOMediateur().supprimerObservations(); |
| } |
| // si c'est la transmission |
| if (item.equals(transmettreObservation)) { |
| // on notifie le médiateur |
| getOMediateur().transmettreObservations(true); |
| } |
| // si c'est la detransmission |
| if (item.equals(deTransmettreObservation)) { |
| // on notifie le médiateur |
| getOMediateur().transmettreObservations(false); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ObservationMediateur getOMediateur() { |
| return oMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/EtatConnexionVue.java |
|---|
| New file |
| 0,0 → 1,335 |
| /** |
| David Delon david.delon@clapas.net 2007 |
| */ |
| /* |
| * EtatConnexionVue.java : affichage information portant sur le statut de la connexion utilisateur |
| * |
| * |
| * 1: Le programme affiche le statut connecte si l'utilisateur s'est connecte precedemment, sinon s'affiche le statut deconnecte |
| * 2: Le programme arme les actions liees a la connection ou a la deconnection |
| * - Connection : affichage de la boite de connexion |
| * - Deconnexion : appel du service de deconnexion, et appel de la re-initialisation de l'affichage pour le nouvel identifiant utilisateur obtenu (identifiant de session) |
| */ |
| package org.tela_botanica.client.vues; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.modeles.Configuration; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| /** |
| * Un indicateur d'etat de connexion |
| * |
| * @author David Delon |
| * |
| */ |
| public class EtatConnexionVue extends Panel { |
| /** |
| * Médiateur associé à la vue |
| */ |
| private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
| /** |
| * Texte lié à la connexion. |
| * |
| */ |
| private String labelEtatConnexion = null; |
| private String liens = "<div id=\"liensExt\"><a href=\"#\" id=\"lienAide\">Aide</a> <a href=\"#\" id=\"lienBugs\">Bugs </a></div>" ; |
| /** |
| * Booleen indiquant si utilisateur connecte |
| * |
| */ |
| public EtatConnexionVue(CarnetEnLigneMediateur cm) { |
| carnetEnLigneMediateur=cm; |
| this.setBodyBorder(false) ; |
| this.setBorder(false) ; |
| this.setId("panneau_etat_connexion"); |
| // Pas de word wrap |
| labelEtatConnexion=""; |
| this.setHtml(labelEtatConnexion+liens); |
| ajouterListeners(); |
| } |
| public void ajouterListeners() { |
| ExtElement lienAide = Ext.get("lienAide"); |
| if(lienAide != null) |
| { |
| lienAide.removeAllListeners(); |
| lienAide.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| ExtElement lienAide = Ext.get("lienAide"); |
| if(lienAide != null) |
| { |
| lienAide.removeAllListeners(); |
| lienAide.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| }); |
| } |
| } |
| }); |
| } |
| ExtElement lienBugs = Ext.get("lienBugs"); |
| if(lienBugs != null) |
| { |
| lienBugs.removeAllListeners(); |
| lienBugs.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String bugsURL = Configuration.getSuiviBugUrl() ; |
| Window.open(bugsURL, "", "") ; |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| ExtElement lienBugs = Ext.get("lienBugs"); |
| if(lienBugs != null) |
| { |
| lienBugs.removeAllListeners(); |
| lienBugs.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String bugsURL = Configuration.getSuiviBugUrl() ; |
| Window.open(bugsURL, "", "") ; |
| } |
| }); |
| } |
| } |
| }); |
| } |
| } |
| /** |
| * Affichage de l'etat de connexion |
| * @param text |
| * @param connecte |
| */ |
| public void setEtat(String identifiant, boolean connecte) { |
| if(connecte) { |
| labelEtatConnexion = "<div id=\"etatConnexion\">Connecté en tant que "+identifiant+" <a id=\"lienDeconnexion\" href=\"#\">(deconnexion)</a>" ; |
| labelEtatConnexion += "</div>" ; |
| labelEtatConnexion += liens ; |
| setHtml(labelEtatConnexion); |
| ExtElement lienDeco = Ext.get("etatConnexion"); |
| if(lienDeco != null) |
| { |
| lienDeco.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| carnetEnLigneMediateur.deconnecterUtilisateur(); |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() |
| { |
| public void onAfterLayout(Container c) |
| { |
| ExtElement lienDeco = Ext.get("etatConnexion"); |
| lienDeco.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| carnetEnLigneMediateur.deconnecterUtilisateur(); |
| setEtat(null, false); |
| } |
| }); |
| } |
| }); |
| } |
| } |
| else |
| { |
| labelEtatConnexion = "<div id=\"etatConnexion\"> Utilisez ce carnet en ligne pour saisir vos observations, <a id=\"lienConnexion\" href=\"#\">identifiez-vous</a> pour les transmettre à Tela Botanica</div>"; |
| labelEtatConnexion += liens ; |
| setHtml(labelEtatConnexion); |
| ExtElement lienCo = Ext.get("etatConnexion"); |
| if(lienCo != null) { |
| lienCo.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| carnetEnLigneMediateur.afficherDialogueConnexion(); |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| ExtElement lienCo = Ext.get("etatConnexion"); |
| lienCo.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| carnetEnLigneMediateur.afficherDialogueConnexion(); |
| } |
| }); |
| } |
| }); |
| } |
| } |
| ExtElement lienBugs = Ext.get("lienBugs"); |
| if(lienBugs != null) |
| { |
| lienBugs.removeAllListeners(); |
| lienBugs.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String bugsURL = Configuration.getSuiviBugUrl() ; |
| Window.open(bugsURL, "", "") ; |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| ExtElement lienBugs = Ext.get("lienBugs"); |
| if(lienBugs != null) |
| { |
| lienBugs.removeAllListeners(); |
| lienBugs.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String bugsURL = Configuration.getSuiviBugUrl() ; |
| Window.open(bugsURL, "", "") ; |
| } |
| }); |
| } |
| } |
| }); |
| } |
| ExtElement lienAide = Ext.get("lienAide"); |
| if(lienAide != null) |
| { |
| lienAide.removeAllListeners(); |
| lienAide.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| ExtElement lienAide = Ext.get("lienAide"); |
| if(lienAide != null) |
| { |
| lienAide.removeAllListeners(); |
| lienAide.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| }); |
| } |
| } |
| }); |
| } |
| } |
| } |
| /* +--Fin du code ---------------------------------------------------------------------------------------+ |
| * $Log$ |
| * Revision 1.1 2008-11-13 11:27:05 ddelon |
| * Reecriture gwt-ext |
| * |
| * Revision 1.1 2008-06-09 14:19:37 ddelon |
| * Initialisation observation |
| * |
| * Revision 1.2 2008-04-28 13:10:44 ddelon |
| * Integration MyGwt |
| * |
| * Revision 1.1 2008-01-02 21:26:04 ddelon |
| * mise en place mygwt |
| * |
| * Revision 1.6 2007-12-22 14:48:53 ddelon |
| * Documentation et refactorisation |
| * |
| * Revision 1.5 2007-09-17 19:25:34 ddelon |
| * Documentation |
| * |
| * |
| */ |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java |
|---|
| New file |
| 0,0 → 1,258 |
| /** |
| David Delon david.delon@clapas.net 2007 |
| */ |
| /* |
| * LoginDialog.java (DialogBox) |
| * |
| * Cas d'utilisation : |
| * Dialogue de validation de l'identification utilisateur |
| * |
| * 1 : L'utilisateur saisit son identifiant (e-mail) et son mot de passe |
| * 2 : Le dialogue controle aupres du systeme distant la validite des informations saisies |
| * 3 : Le dialogue transmet au systeme local les informations d'identification |
| * 3a : Le dialogue informe l'utilisateur que les elements d'identification ne sont pas valide : retour au point 1, ou passe au point 4. |
| * 4 : Cloture du dialogue |
| * 5 : Appel du dialogue d'importation |
| */ |
| package org.tela_botanica.client.vues; |
| // TODO : controle de forme sur saisie (regex integree) ... |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import com.google.gwt.user.client.ui.DialogBox; |
| import com.google.gwt.user.client.ui.KeyboardListener; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Position; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.KeyListener; |
| import com.gwtext.client.widgets.form.FormPanel; |
| import com.gwtext.client.widgets.form.TextField; |
| public class FormulaireDeConnexionVue extends DialogBox { |
| /** |
| * Médiateur associé à la vue |
| */ |
| private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
| /** |
| * email saisi |
| */ |
| private TextField ident=null; |
| /** |
| * mot de passe saisi |
| */ |
| private TextField motDePasse=null; |
| private Label saisieInvalide = null ; |
| public FormulaireDeConnexionVue(CarnetEnLigneMediateur cm) { |
| carnetEnLigneMediateur=cm; |
| Panel panneauPrincipalDialogue=new Panel(); |
| FormPanel panneauFormulaire = new FormPanel(Position.RIGHT); |
| panneauFormulaire.setTitle("Connexion"); |
| panneauFormulaire.setWidth(350); |
| panneauFormulaire.setLabelWidth(100); |
| /* |
| * E-Mail : Zone_saisie_email |
| * Mot-de-passe : Zone_saisie_mot_de_passe |
| * Message d'information |
| * Bouton_Ok Bouton_Annuler |
| */ |
| /** |
| * On ajoute les differents elements du formulaire |
| */ |
| ident = new TextField("Mail", "ident", 200); |
| ident.setAllowBlank(false); |
| ident.setInvalidText("Mail vide ou incorrect"); |
| ident.setTabIndex(800); |
| panneauFormulaire.add(ident); |
| // Mot de passe |
| motDePasse = new TextField("Mot de passe", "motDePasse", 200); |
| motDePasse.setAllowBlank(false); |
| ident.setInvalidText("Mot de passe vide ou incorrect"); |
| motDePasse.setPassword(true); |
| motDePasse.setTabIndex(801); |
| panneauFormulaire.add(motDePasse); |
| Button boutonOK = new Button("Ok"); |
| boutonOK.setTabIndex(802); |
| panneauFormulaire.addButton(boutonOK); |
| Button boutonAnnuler = new Button("Annuler"); |
| boutonAnnuler.setTabIndex(803); |
| panneauFormulaire.addButton(boutonAnnuler); |
| // Click sur bouton de validation |
| boutonOK.addListener( |
| new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText()); |
| } |
| } |
| ); |
| // Click sur bouton d'annulation |
| boutonAnnuler.addListener( |
| new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| cacher(); |
| } |
| } |
| ); |
| /** |
| * Validation directe depuis un champ de saisie |
| * |
| */ |
| // gestion de la touche entrée |
| ident.addKeyListener(EventObject.ENTER, new KeyListener() { |
| public void onKey(int key, EventObject e) { |
| carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText()); |
| } |
| }); |
| // Mot de passe |
| motDePasse.addKeyListener(EventObject.ENTER, new KeyListener() { |
| public void onKey(int key, EventObject e) { |
| carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText()); |
| } |
| }); |
| saisieInvalide = new Label(""); |
| saisieInvalide.setStyleName("saisie_invalide_invisible"); |
| panneauFormulaire.add(saisieInvalide); |
| panneauPrincipalDialogue.add(panneauFormulaire); |
| setWidget(panneauPrincipalDialogue); |
| } |
| /* |
| * On sort sur touche echappement |
| */ |
| public boolean onKeyDownPreview(char key, int modifiers) { |
| switch (key) { |
| case KeyboardListener.KEY_ESCAPE: |
| hide(); |
| break; |
| } |
| return true; |
| } |
| public void afficherMessageAlerte() { |
| saisieInvalide.setText("Identifiant ou mot de passe invalide"); |
| saisieInvalide.setStyleName("saisie_invalide"); |
| } |
| public void cacher() { |
| saisieInvalide.setText(""); |
| saisieInvalide.setStyleName("saisie_invalide_invisible"); |
| hide(); |
| } |
| } |
| /* +--Fin du code ---------------------------------------------------------------------------------------+ |
| * $Log$ |
| * Revision 1.1 2008-11-13 11:27:05 ddelon |
| * Reecriture gwt-ext |
| * |
| * Revision 1.1 2008-06-09 14:19:37 ddelon |
| * Initialisation observation |
| * |
| * Revision 1.10 2007-09-17 19:25:34 ddelon |
| * Documentation |
| * |
| * Revision 1.9 2007-05-21 21:03:44 ddelon |
| * nettoyage de code |
| * |
| * Revision 1.8 2007-05-21 18:14:06 ddelon |
| * Gestion importation releve locaux |
| * |
| * Revision 1.7 2007-05-21 11:47:30 ddelon |
| * meta cvs |
| * |
| * Revision 1.6 2007-05-21 11:39:48 ddelon |
| * meta cvs |
| * |
| * Revision 1.5 2007-05-21 11:39:12 ddelon |
| * meta cvs |
| * |
| * Revision 1.4 2007-05-21 11:37:35 ddelon |
| * meta cvs |
| * |
| * Revision 1.3 2007-05-21 11:36:51 ddelon |
| * meta cvs |
| * |
| */ |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/BarreNotationVue.java |
|---|
| New file |
| 0,0 → 1,223 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Image; |
| import com.google.gwt.user.client.ui.MouseListenerAdapter; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.widgets.Panel; |
| /** |
| * Une barre de notation avec des étoiles, tout ce qu'il ya de plus classique, |
| * utilisant Ajax (et pas CSS) |
| * |
| * @author aurelien |
| * |
| */ |
| public class BarreNotationVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| @SuppressWarnings("unused") |
| private ImageMediateur iMediateur = null; |
| /** |
| * La note actuellement affichée |
| */ |
| private int noteEnCours = 0; |
| /** |
| * La note maximum |
| */ |
| private int noteMax = 0; |
| /** |
| * Booléen indiquant si une note est affectée à la barre en ce moment |
| */ |
| private boolean estNote = false; |
| /** |
| * Tablmeau d'images contenant les étoiles affichées |
| */ |
| private Image[] etoiles = null; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private BarreNotationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| * @param noteMax |
| * la note maximale |
| */ |
| public BarreNotationVue(ImageMediateur im, int noteMax) { |
| iMediateur = im; |
| setNoteMax(noteMax); |
| this.setSize(200, 100); |
| this.setBodyBorder(false); |
| this.setBorder(false); |
| this.setCls("x-view-notation"); |
| ajouterListeners(); |
| } |
| public void ajouterListeners() { |
| for (int i = 0; i < etoiles.length; i++) { |
| etoiles[i].addMouseListener(new MouseListenerAdapter() { |
| // si la souris passe sur la barre |
| public void onMouseEnter(Widget sender) { |
| Image enCours = (Image) sender; |
| // on met en surbrillance toutes les étoiles allant de la |
| // première jusqu'à |
| // celle sous le curseur |
| for (int i = 0; etoiles[i] != enCours; i++) { |
| etoiles[i].setUrl("note-hover.gif"); |
| } |
| enCours.setUrl("note-hover.gif"); |
| } |
| // si la souris sort de la barre |
| public void onMouseLeave(Widget sender) { |
| // on affiche la véritable note |
| afficherNote(); |
| } |
| }); |
| etoiles[i].addClickListener(new ClickListener() { |
| // si on clique sur une étoiles |
| public void onClick(Widget sender) { |
| int i = 0; |
| // on récupère le numéro de l'étoile sur laquelle on a |
| // cliqué |
| while (etoiles[i] != (Image) sender) { |
| i++; |
| } |
| // et on affecte la note |
| noter(i); |
| } |
| }); |
| } |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| // si on recoit un tableau de string |
| if (nouvelleDonnees instanceof String[]) { |
| // on récupère le premier élément (un entier, qui contient la note) |
| String[] note = (String[]) nouvelleDonnees; |
| int noteInt = Integer.parseInt(note[0]); |
| // si l'entier est une note valide |
| if (noteInt != -1 && noteInt >= 0) { |
| noter(noteInt); |
| } |
| // sinon si l'entier vaut -1 |
| else { |
| // alors on note avec 0 |
| // et on met le booleen de notation a false (qui signifie que |
| // l'image n'est pas encore notée) |
| estNote = false; |
| noteEnCours = 0; |
| // et demande l'affichage |
| afficherNote(); |
| } |
| } |
| } |
| /** |
| * Affecte une note à la barre et rafraichit l'affichage |
| * |
| * @param note |
| * la nouvelle note |
| */ |
| public void noter(int note) { |
| // on affecte la note |
| noteEnCours = note; |
| // on met le boolean de notation à true (l'image est notée) |
| estNote = true; |
| // et on demande l'affichage |
| afficherNote(); |
| } |
| /** |
| * Setteur pour la note maximale |
| * |
| * @param nMax |
| * la nouvelle note maximale |
| */ |
| public void setNoteMax(int nMax) { |
| // on affecte la note |
| noteMax = nMax; |
| // on prépare le tableau d'image |
| etoiles = new Image[noteMax]; |
| // qu'on remplit par defaut avec des images d'étoiles vides |
| for (int i = 0; i < noteMax; i++) { |
| etoiles[i] = new Image("note_off.gif"); |
| etoiles[i].setStylePrimaryName("x-view-notation-bar"); |
| this.add(etoiles[i]); |
| } |
| } |
| /** |
| * Affiche la note d'une image sous la forme d'étoiles |
| */ |
| public void afficherNote() { |
| // si l'image est notée |
| if (estNote) { |
| // on affiche autant d'étoiles que le chiffre de la note |
| for (int i = 0; i <= noteEnCours; i++) { |
| etoiles[i].setUrl("note-on.gif"); |
| } |
| // et si elle est inférieure à la note maximale, on remplit le reste |
| // par des étoiles vides |
| for (int j = noteEnCours + 1; j < noteMax; j++) { |
| etoiles[j].setUrl("note-off.gif"); |
| } |
| } |
| // sinon |
| else { |
| // on remplit toute la barre avec des étoiles vides |
| for (int i = 0; i < noteMax; i++) { |
| etoiles[i].setUrl("note-off.gif"); |
| } |
| } |
| } |
| /** |
| * Accesseur pour la note en cours sous forme de string |
| * |
| * @return la note en cours sous forme d'une chaine de charactères |
| */ |
| public String getNote() { |
| return "" + noteEnCours; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/MenuImageVue.java |
|---|
| New file |
| 0,0 → 1,178 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.MenuItem; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| /** |
| * Menu de gestion des images |
| * |
| * @author aurelien |
| * |
| */ |
| public class MenuImageVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour l'upload |
| */ |
| private MenuItem uploaderImage = null; |
| /** |
| * Item pour la suppression |
| */ |
| private Item supprimerImage = null; |
| /** |
| * Item pour l'ajout d'images à la selection |
| */ |
| private Item ajouterImageSelection = null; |
| /** |
| * Item pour vider la selection d'images |
| */ |
| private Item viderSelection = null; |
| /** |
| * Item pour lier la selection d'images |
| */ |
| private Item afficherSelection = null; |
| private Item uploadMultiple = null ; |
| private Item uploadSimple = null ; |
| private Menu mn = null ; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuImageVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| mn = new Menu(); |
| uploadMultiple = new Item("Plusieurs dossiers ou fichiers à la fois"); |
| uploadSimple = new Item("Un fichier à la la fois"); |
| mn.addItem(uploadMultiple); |
| mn.addItem(uploadSimple); |
| // on construit le menu |
| uploaderImage = new MenuItem("Ajouter des images", mn); |
| supprimerImage = new Item("Supprimer les images selectionnées"); |
| ajouterImageSelection = new Item( |
| "Ajouter les images sélectionnées au tampon"); |
| viderSelection = new Item("Vider le tampon"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(uploaderImage); |
| addItem(supprimerImage); |
| addSeparator() ; |
| addItem(ajouterImageSelection); |
| addItem(viderSelection); |
| addItem(afficherSelection); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(supprimerImage)) { |
| // on notifie le médiateur |
| getIMediateur().supprimerImages(); |
| } |
| // si c'est l'ajout à la sélection |
| if (item.equals(ajouterImageSelection)) { |
| getIMediateur().ajouterImagesSelection(); |
| } |
| // si c'est le vidage de la sélection |
| if (item.equals(viderSelection)) { |
| getIMediateur().viderSelection(); |
| } |
| // si c'est l'affichage de la selection |
| if (item.equals(afficherSelection)) { |
| getIMediateur().afficherIdSelectionImages(); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| public void onShow(Menu menu) { |
| if(getIMediateur().getCompteSelection() != 0) { |
| afficherSelection.enable(); |
| viderSelection.enable(); |
| } |
| else { |
| afficherSelection.disable(); |
| viderSelection.disable(); |
| } |
| } |
| }); |
| mn.addListener(new MenuListenerAdapter() { |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'upload |
| if (item.equals(uploadMultiple)) { |
| // on notifie le médiateur |
| getIMediateur().uploaderImages(true); |
| } |
| // si c'est l'upload |
| if (item.equals(uploadSimple)) { |
| // on notifie le médiateur |
| getIMediateur().uploaderImages(false); |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/ZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,553 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Image; |
| import com.google.gwt.user.client.ui.LoadListener; |
| import com.google.gwt.user.client.ui.MouseWheelListener; |
| import com.google.gwt.user.client.ui.MouseWheelVelocity; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.core.AnimationConfig; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.core.RegionPosition; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.dd.DropTarget; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| import com.gwtext.client.widgets.layout.BorderLayout; |
| import com.gwtext.client.widgets.layout.BorderLayoutData; |
| /** |
| * Panneau d'affichage d'une image avec des boutons précdents et suivant |
| * |
| * @author aurelien |
| * |
| */ |
| public class ZoomImageVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Panneau conteneur pour l'image |
| */ |
| private Panel imageConteneur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image("vide.jpg"); |
| /** |
| * Bouton précédent |
| */ |
| private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Bouton suivant |
| */ |
| private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Taille originale Y de l'image |
| */ |
| private int imageHeight = 0; |
| /** |
| * Taille originale X de l'image |
| */ |
| private int imageWidth = 0; |
| /** |
| * Identifiant de l'image |
| */ |
| private String idImage = "0" ; |
| /** |
| * Booleen d'initalisation général |
| */ |
| private boolean initialise = false; |
| /** |
| * Booleen d'initalisation du conteneur d'image |
| */ |
| private boolean conteneurInitialise = false; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour revenir à la vue précédente, utilisez la roulette ou les boutons fléchés pour faire défiler les images </div>") ; |
| /** |
| * true pour animer les transitions des animations |
| */ |
| private boolean animerTransition = false; |
| /** |
| * duree des animation |
| */ |
| private float dureeAnimation = (float) 0.15 ; |
| /**. |
| * boolean de gestion du double clic |
| */ |
| private boolean enClic = false; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ZoomImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| */ |
| public ZoomImageVue(ImageMediateur im) { |
| super("Zoom"); |
| setId("x-view-zoom-panel"); |
| // on associe le médiateur |
| iMediateur = im; |
| prev.setStylePrimaryName("x-view-zoom-button-p"); |
| suiv.setStylePrimaryName("x-view-zoom-button-s"); |
| // on crée une image qui gère le double clic et la roulette de la souris |
| image = new Image(); |
| this.setHeader(false); |
| imageConteneur = new Panel(); |
| imageConteneur.setBorder(false); |
| imageConteneur.add(image); |
| imageConteneur.setId("x-view-zoom-img"); |
| // il n'existe pas de méthode pour ajouter un listener pour le double |
| // clic sur une image |
| // alors on lui dit manuellement de capter l'évènement double clic |
| //imageConteneur.sinkEvents(Event.ONMOUSEWHEEL); |
| // l'image de base est vide |
| image.setUrl("vide.jpg"); |
| this.setLayout(new BorderLayout()); |
| prev.setWidth("60px"); |
| suiv.setWidth("60px"); |
| this.add(prev, new BorderLayoutData(RegionPosition.WEST)); |
| this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER)); |
| this.add(suiv, new BorderLayoutData(RegionPosition.EAST)); |
| imageConteneur.setMaskDisabled(true); |
| this.setBorder(false); |
| conteneurInitialise = true; |
| initialise = true; |
| configDragAndDrop() ; |
| // on ajoute les listeners |
| ajouterListeners(); |
| tp.setDismissDelay(1750); |
| tp.applyTo(image.getElement()) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen qui dit si on doit répnadre l'évènement |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit une string |
| if (nouvelleDonnees instanceof String[] && initialise |
| && conteneurInitialise) { |
| String[] infos = (String[]) nouvelleDonnees; |
| // c'est l'url de l'image qu'on associe à la vue |
| if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) { |
| getImage().setUrl(infos[0]); |
| int x = Integer.parseInt(infos[1]); |
| int y = Integer.parseInt(infos[2]); |
| setTailleImage(x, y); |
| setIdImage(infos[3]) ; |
| //verifierEtRetaillerImage(); |
| } |
| } else { |
| // sinon on met une image vide |
| getImage().setUrl("vide.jpg"); |
| } |
| } |
| /** |
| * Desactive visuellement le panneau et les boutons |
| */ |
| public void desactiverPanneau() { |
| getImage().setUrl("vide.jpeg"); |
| prev.setEnabled(false); |
| suiv.setEnabled(false); |
| } |
| /** |
| * Active visuellement le panneau et les boutons |
| */ |
| public void activerPanneau() { |
| prev.setEnabled(true); |
| suiv.setEnabled(true); |
| } |
| public void masquerChargement() { |
| ExtElement imgEl = Ext.get(imageConteneur.getElement()); |
| if(imgEl != null && !imgEl.isMasked()) { |
| imgEl.mask("Chargement"); |
| } |
| } |
| public void demasquerChargement() { |
| ExtElement imgEl = Ext.get(imageConteneur.getElement()); |
| if(imgEl != null && imgEl.isMasked()) { |
| imgEl.unmask(); |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| image.addLoadListener(new LoadListener() { |
| public void onError(Widget sender) { |
| // TODO Auto-generated method stub |
| } |
| public void onLoad(Widget sender) { |
| int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth()); |
| int[] tailleImage = calculerDimensions(getTailleImage(), max, max); |
| ExtElement imgElement = Ext.get(image.getElement()); |
| if(animerTransition) { |
| AnimationConfig a = new AnimationConfig() ; |
| a.setDuration((float) dureeAnimation); |
| imgElement.setHeight(tailleImage[1], a); |
| imgElement.setWidth(tailleImage[0], a); |
| } else { |
| imgElement.setHeight(tailleImage[1], false); |
| imgElement.setWidth(tailleImage[0], false); |
| } |
| demasquerChargement(); |
| } |
| }); |
| image.addClickListener(new ClickListener() { |
| public void onClick(Widget sender) { |
| if(enClic) { |
| getIMediateur().doubleClicZoomImage(); |
| } else { |
| Timer t = new Timer() { |
| public void run() { |
| enClic = false; |
| } |
| }; |
| enClic = true; |
| t.schedule(800); |
| } |
| } |
| }); |
| image.addMouseWheelListener(new MouseWheelListener() { |
| public void onMouseWheel(Widget sender, MouseWheelVelocity velocity) { |
| if(velocity.getDeltaY() > 0) { |
| suiv.click(); |
| } else { |
| prev.click(); |
| } |
| } |
| }); |
| // gestion du clic sur le bouton précedent |
| prev.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| // on notifie le médiateur |
| masquerChargement(); |
| getIMediateur().clicBoutonZoomImage("prev"); |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| // on notifie le médiateur |
| masquerChargement(); |
| getIMediateur().clicBoutonZoomImage("suiv"); |
| } |
| }); |
| // gestion du redimensionnement |
| this.addListener(new PanelListenerAdapter() { |
| // lors d'un redimensionnement de l'application |
| public void onBodyResize(Panel panel, java.lang.String width, |
| java.lang.String height) { |
| // on vérifie et on retaille l'image |
| verifierEtRetaillerImage(); |
| } |
| }); |
| // gestion du redimensionnement lors de l'affichage du conteneur |
| imageConteneur.addListener(new PanelListenerAdapter() { |
| // avant de finir d'afficher |
| public void onAfterLayout(Container self) { |
| // on redimensionne |
| verifierEtRetaillerImage(); |
| } |
| }); |
| } |
| /** |
| * Verifie si l'image est plus grande que le conteneur et la retaille le cas |
| * echeant |
| */ |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = getTailleImage()[0]; |
| int originalY = getTailleImage()[1]; |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = imageConteneur.getWidth(); |
| int tailleConteneurY = imageConteneur.getHeight(); |
| // si celle-ci est égale à 0 (conteneur mal initialisé) |
| /* |
| * if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on |
| * essaie de la calculer en fonction de la taille du parent et des |
| * frères tailleConteneurY = this.getHeight() ; tailleConteneurX = |
| * this.getWidth() - prev.getOffsetWidth() * 2 ; |
| * } |
| */ |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| if (originalY > tailleConteneurY || originalX > tailleConteneurX) { |
| // si la longueur de l'image est la plus grande des deux |
| if (originalX > originalY) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = tailleConteneurX; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } else { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = tailleConteneurY; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| getImage().setSize("" + nouvelleTailleX + "px", |
| "" + nouvelleTailleY + "px"); |
| } |
| public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ; |
| float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ; |
| float[] XYresize = new float[2]; |
| if(maxTaille == tailleXY[0]) { |
| float rapport = tailleXYf[1]/tailleXYf[0] ; |
| XYresize[0] = tailleOr ; |
| XYresize[1] = tailleOr*rapport ; |
| }else { |
| float rapport = tailleXYf[0]/tailleXYf[1] ; |
| XYresize[1] = tailleOr ; |
| XYresize[0] = tailleOr*rapport ; |
| } |
| int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ; |
| return res; |
| } |
| public void configDragAndDrop() |
| { |
| // on fabrique la nouvelle configuration |
| // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("DragGroupName"); |
| //La drop target permet de gérer l'évenement onDrop sur l'élement courant |
| @SuppressWarnings("unused") |
| DropTarget tg = new DropTarget(this, dtc) |
| { |
| public boolean notifyDrop(DragSource source, EventObject e, DragData data){ |
| // si on reçoit des données provenant d'une grille |
| if(data instanceof GridDragData) |
| { |
| // on appelle le médiateur |
| return iMediateur.lierObsDD(source, e, data,getId()) ; |
| } |
| return false ; |
| } |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Accesseur au conteneur de l'image |
| * |
| * @return le conteneur de l'image |
| */ |
| public Image getImage() { |
| return image; |
| } |
| /** |
| * Acesseurs pour l'identifiant de l'image |
| * @return l'id de l'image |
| */ |
| public String getIdImage() |
| { |
| return idImage ; |
| } |
| /** |
| * Accesseur pour le bouton précédent |
| * |
| * @return le bouton précédent |
| */ |
| public com.google.gwt.user.client.ui.Button getPrev() { |
| return prev; |
| } |
| /** |
| * Accesseur pour le bouton suivant |
| * |
| * @return le bouton suivant |
| */ |
| public com.google.gwt.user.client.ui.Button getSuiv() { |
| return suiv; |
| } |
| /** |
| * Setter pour la taille de l'image |
| * |
| * @param x |
| * la largeur en pixels |
| * @param y |
| * la hauteur en pixels |
| */ |
| public void setTailleImage(int x, int y) { |
| imageHeight = y; |
| imageWidth = x; |
| } |
| /** |
| * Setteur pour l'identifiant de l'image |
| * @param id le nouvel identifiant |
| */ |
| public void setIdImage(String id) |
| { |
| idImage = id ; |
| } |
| /** |
| * renvoie la taille originale de l'image |
| * |
| * @return un tableau de deux entiers contenant la largeur puis la hauteur |
| */ |
| public int[] getTailleImage() { |
| int[] taille = { imageHeight, imageWidth }; |
| return taille; |
| } |
| /** |
| * Accesseur pour le conteneur de l'image |
| * @return le conteur de l'image |
| */ |
| public Panel getImageConteneur() { |
| return imageConteneur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,382 |
| package org.tela_botanica.client.vues.image; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.ListeObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.SimpleStore; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.dd.DropTarget; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.grid.ColumnConfig; |
| import com.gwtext.client.widgets.grid.ColumnModel; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| import com.gwtext.client.widgets.grid.GridPanel; |
| import com.gwtext.client.widgets.grid.event.GridListenerAdapter; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.dd.DragData; |
| /** |
| * liste d'observation pour l'association d'images aux observations |
| * @author aurelien |
| * |
| */ |
| public class MiniListeObservationVue extends GridPanel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null ; |
| /** |
| * Booléen d'instanciation |
| */ |
| private boolean estInstancie = false ; |
| /** |
| * Le modèle de colonnes |
| */ |
| private ColumnModel colModel = null ; |
| private SimpleStore store = null ; |
| //private BarrePaginationVue pgBar = new BarrePaginationVue(iMediateur) ; |
| private Toolbar bt = new Toolbar() ; |
| /** |
| * Combobox permettant de selectionner le mode |
| * modification ou bien création |
| */ |
| private ComboBox selecteurMode = new ComboBox(); |
| Store storeMode = null ; |
| private boolean liaison; |
| /** |
| * Constructeur avec arguments |
| * @param im le médiateur à associer à la vue |
| */ |
| public MiniListeObservationVue(ImageMediateur im) |
| { |
| iMediateur = im ; |
| this.setId("x-view-mini-obs") ; |
| // on crée un store simple contenant un petit set de données et deux colonnes |
| store = new SimpleStore(new String[]{"id_obs","plante","date","lieu"}, getObs()); |
| ColumnConfig[] columns = { |
| new ColumnConfig("Numero", "id_obs", 50, true), |
| new ColumnConfig("Taxon", "plante", 145, true), |
| new ColumnConfig("Date", "date", 68, true), |
| new ColumnConfig("Lieu", "lieu", 145, true) } ; |
| ColumnModel columnModel = new ColumnModel(columns); |
| colModel = columnModel ; |
| setTitle("Observations"); |
| // on associe le modèle de colonnes |
| setColumnModel(columnModel); |
| setAutoScroll(true) ; |
| setHeight("100%") ; |
| setAutoWidth(true) ; |
| // on autorise le drag 'n drop pour un certain groupe |
| this.setEnableDragDrop(true); |
| this.setDdGroup("DragGroupName"); |
| store.load(); |
| setStore(store) ; |
| //setBottomToolbar(pgBar) ; |
| Object[][] mode = {{"toutes les observations",false} , {"observations liées", true} }; |
| storeMode = new SimpleStore(new String[] { "nom_mode", "mode" }, |
| mode); |
| storeMode.load(); |
| selecteurMode.setStore(storeMode); |
| selecteurMode.setDisplayField("nom_mode") ; |
| selecteurMode.setLabel("mode ") ; |
| selecteurMode.setForceSelection(true) ; |
| selecteurMode.setValue("toutes les observations") ; |
| selecteurMode.setEditable(false) ; |
| selecteurMode.setCls("x-selec-consult") ; |
| bt = new Toolbar() ; |
| bt.addField(selecteurMode) ; |
| //this.setAutoExpandColumn("plante"); |
| setTopToolbar(bt) ; |
| selecteurMode.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| // et on met la valeur à jour dans la combobox |
| comboBox.setValue(record.getAsString("nom_mode")); |
| setModification(record.getAsString("mode")) ; |
| } |
| }); |
| setAutoScroll(true) ; |
| // on configure le drag 'n drop |
| configDragAndDrop() ; |
| this.addListener(new ContainerListenerAdapter() { |
| public void onRender(Component c) { |
| obtenirMiniListeObservations() ; |
| } |
| public void onAfterLayout(Container c) |
| { |
| obtenirMiniListeObservations() ; |
| } |
| }) ; |
| this.addGridListener(new GridListenerAdapter() { |
| public void onContextMenu(EventObject e) { |
| e.stopEvent() ; |
| MenuLiaisonVue mlv = new MenuLiaisonVue(iMediateur,liaison) ; |
| mlv.showAt(e.getXY()) ; |
| } |
| }) ; |
| } |
| /** |
| * Configure le drag 'n drop pour la liste |
| */ |
| private void configDragAndDrop() |
| { |
| // on choisit le texte qui sera affiché lors d'un drag 'n drop |
| setDragDropText("Faites glisser la selection d'observations sur une image pour les lier") ; |
| //On active le drag 'n drop |
| this.setEnableDragDrop(true); |
| // on fabrique la nouvelle configuration |
| // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup |
| this.setDdGroup("DragGroupName"); |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("DragGroupName"); |
| //La drop target permet de gérer l'évenement onDrop sur l'élement courant |
| @SuppressWarnings("unused") |
| DropTarget tg = new DropTarget(this, dtc) |
| { |
| public boolean notifyDrop(DragSource source, EventObject e, DragData data){ |
| // si on reçoit des données provenant d'une grille |
| if(data instanceof GridDragData) |
| { |
| // on la convertit |
| GridDragData gdd = (GridDragData)data ; |
| // et on vérifie que les données ne viennent pas de l'élément courant |
| if(gdd.getGrid().getId().equals("x-view-mini-obs")) |
| { |
| return false ; |
| } |
| else |
| { |
| // on appelle le médiateur |
| return iMediateur.lierImagesDD(source, e, data) ; |
| } |
| } |
| return false ; |
| } |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof ListeObservation) |
| { |
| if(this.getView() != null) |
| { |
| ListeObservation data = (ListeObservation)nouvelleDonnees ; |
| String[][] listeObs = new String[data.size()][4] ; |
| int i = 0 ; |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| Observation obs=(Observation) data.get(it.next()); |
| listeObs[i][0] = obs.getNumeroOrdre(); |
| listeObs[i][1] = obs.getNomSaisi(); |
| listeObs[i][2] = obs.getDate() ; |
| listeObs[i][3] = obs.getLocalite(); |
| i++ ; |
| } |
| store = new SimpleStore(new String[]{"id_obs","plante","date","lieu"}, listeObs); |
| store.load(); |
| this.reconfigure(store, colModel) ; |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| public void onShow(Component c) |
| { |
| obtenirMiniListeObservations() ; |
| } |
| public void onAfterLayout(Container c) |
| { |
| obtenirMiniListeObservations() ; |
| } |
| }) ; |
| } |
| } |
| deMasquerChargement() ; |
| } |
| private void obtenirMiniListeObservations() |
| { |
| iMediateur.obtenirMiniListeObservations(this) ; |
| } |
| /** |
| * Renvoie le faux set de données pour le store |
| * @return un tableau à deux colonnes int - String |
| */ |
| private Object[][] getObs() { |
| return new Object[][]{ |
| } ; |
| } |
| public Store getStore() |
| { |
| return store ; |
| } |
| /*public BarrePaginationVue getBarrePagination() |
| { |
| return pgBar ; |
| }*/ |
| private void setModification(String mode) |
| { |
| if(mode.equals("true")) { |
| liaison = true ; |
| selecteurMode.removeClass("x-selec-consult") ; |
| selecteurMode.setCls("x-selec-liaison") ; |
| } |
| else |
| { |
| liaison = false ; |
| selecteurMode.removeClass("x-selec-liaison") ; |
| selecteurMode.setCls("x-selec-consult") ; |
| } |
| masquerChargement() ; |
| store.removeAll() ; |
| iMediateur.changerModeLiaison(liaison) ; |
| } |
| public boolean getMode() { |
| return liaison ; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void deMasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.unmask() ; |
| } |
| } |
| public String getIdSelectionnees() { |
| Record[] sels = getSelectionModel().getSelections() ; |
| String id = sels[0].getAsString("id_obs") ; |
| return id ; |
| } |
| public void supprimerLiaison() { |
| Record[] rdObs = getSelectionModel().getSelections() ; |
| for(int i = 0 ; i < rdObs.length ; i++) { |
| getStore().remove(rdObs[i]) ; |
| this.getView().refresh() ; |
| } |
| } |
| public void redimensionner() { |
| if(getView() != null) { |
| this.setWidth("100%"); |
| getView().setForceFit(true); |
| doLayout(); |
| } |
| else { |
| Window.alert("null"); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/PanneauFiltresImagesVues.java |
|---|
| New file |
| 0,0 → 1,145 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| /** |
| * Panneau contenant les filtres qu'on peut appliquer aux images |
| * |
| * @author aurelien |
| * |
| */ |
| public class PanneauFiltresImagesVues extends Panel { |
| /** |
| * Le médiateur associé |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * L'arbre pour la recherche par mots clés |
| */ |
| private ArbreMotsClesFiltreVue motsClesFiltres = null; |
| /** |
| * La barre de recherche par commentaires |
| */ |
| private BarreRechercheFiltreVue commFiltresVues = null; |
| /** |
| * Recherche par date |
| */ |
| private DateFiltreVue dateFiltreVues = null; |
| /** |
| * Recherche par contenu du tampon |
| */ |
| private SelectionFiltreVue selectionFiltreVue = null; |
| /** |
| * Bouton de validation |
| */ |
| private Button valider = null; |
| /** |
| * Construcuteur sans argument (privé car on ne doit pas l'utiliser) |
| */ |
| @SuppressWarnings("unused") |
| private PanneauFiltresImagesVues() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public PanneauFiltresImagesVues(ImageMediateur im) { |
| super("Filtres"); |
| iMediateur = im; |
| this.setCollapsible(true); |
| setLayout(new VerticalLayout()); |
| commFiltresVues = new BarreRechercheFiltreVue(im); |
| add(commFiltresVues); |
| dateFiltreVues = new DateFiltreVue(im); |
| add(dateFiltreVues); |
| selectionFiltreVue = new SelectionFiltreVue(im); |
| add(selectionFiltreVue); |
| motsClesFiltres = new ArbreMotsClesFiltreVue(im); |
| add(motsClesFiltres); |
| Panel panelValidation = new Panel(); |
| valider = new Button("Rechercher"); |
| panelValidation.add(valider); |
| panelValidation.setBorder(false); |
| add(panelValidation); |
| valider.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le filtre des mots clés |
| * |
| * @return le filtre des mots clés |
| */ |
| public ArbreMotsClesFiltreVue getMotsClesFiltre() { |
| return motsClesFiltres; |
| } |
| /** |
| * Accesseur pour le filtre par commentaire |
| * |
| * @return le filtre des commentaires |
| */ |
| public BarreRechercheFiltreVue getBarreRecherche() { |
| return commFiltresVues; |
| } |
| /** |
| * Renvoie un booléen indiquant si un des filtres a été modifié |
| * |
| * @return true sur un des filtres est modifié, false sinon |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return (motsClesFiltres.renvoyerEtatFiltre() |
| || commFiltresVues.renvoyerEtatFiltre() |
| || dateFiltreVues.renvoyerEtatFiltre() |
| || selectionFiltreVue.renvoyerEtatFiltre()); |
| } |
| /** |
| * Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre", |
| * "valeur" |
| * |
| * @return un tableau contenant les noms et les valeurs à filtrer |
| */ |
| public String[][] renvoyerValeursAFiltrer() { |
| String[][] filtres = { motsClesFiltres.renvoyerValeursAFiltrer(), |
| commFiltresVues.renvoyerValeursAFiltrer(), |
| dateFiltreVues.renvoyerValeursAFiltrer(), |
| selectionFiltreVue.renvoyerValeursAFiltrer() }; |
| return filtres; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/BarreRechercheFiltreVue.java |
|---|
| New file |
| 0,0 → 1,161 |
| package org.tela_botanica.client.vues.image; |
| 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.core.EventObject; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.KeyListener; |
| import com.gwtext.client.widgets.form.TextField; |
| /** |
| * Fenêtre de recherche pour les mots clés, contenant un champ texte, et un |
| * bouton cliquable |
| * |
| * @author aurelien |
| * |
| */ |
| public class BarreRechercheFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Barre de recherche |
| * |
| */ |
| private TextField champRecherche = null; |
| /** |
| * Booleen d'etat du filtre |
| */ |
| private boolean filtreModifie = false; |
| /** |
| * mot(s) à chercher |
| */ |
| private String motsAChercher = ""; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private BarreRechercheFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec médiateur |
| * |
| * @param im |
| */ |
| public BarreRechercheFiltreVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| Label labelRecherche = new Label("Par commentaires :"); |
| champRecherche = new TextField(); |
| add(labelRecherche); |
| add(champRecherche); |
| setPaddings(5); |
| setBorder(false); |
| setAutoWidth(true); |
| setCollapsible(true); |
| ajouterListeners(); |
| } |
| /** |
| * ajoute des listeners |
| */ |
| private void ajouterListeners() { |
| // gestion de la touche entrée |
| champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() { |
| public void onKey(int key, EventObject e) { |
| valider(); |
| getIMediateur().obtenirPhotoGalerie( |
| getIMediateur().getFiltreCommentaires()); |
| } |
| }); |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| filtreModifie = false; |
| } |
| /** |
| * renvoie l'état du filtre (modifié ou non) |
| * |
| * @return l'état du filtre |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| public String renvoyerNomFiltre() { |
| return "Recherche Commentaires"; |
| } |
| /** |
| * 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[] valeurFiltre = { "ci_meta_comment", motsAChercher }; |
| return valeurFiltre; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Effectue quelque opérations dans la classe et envoie une requête de |
| * données au médiateur |
| */ |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/MenuFiltreVue.java |
|---|
| New file |
| 0,0 → 1,96 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| public class MenuFiltreVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour la recherche par mots clés |
| */ |
| private Item chercherImage = null; |
| /** |
| * Item pour la recherche sur les commentaires |
| */ |
| private Item chercherCommentaire = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuFiltreVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| // on construit le menu |
| chercherImage = new Item("Filtrer par les mots clés"); |
| chercherCommentaire = new Item("Filtrer par les commentaires"); |
| addItem(chercherImage); |
| addItem(chercherCommentaire); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la recherche par mots clé |
| if (item.equals(chercherImage)) { |
| // on notifie le médiateur |
| // getIMediateur().afficherFiltreMotsCles() ; |
| } |
| // si c'est la recherche par commentaires |
| if (item.equals(chercherCommentaire)) { |
| // on notifie le médiateur |
| // getIMediateur().afficherFiltreCommentaires() ; |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/PanneauMetadonneesVue.java |
|---|
| New file |
| 0,0 → 1,395 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.vues.ArbreMotsClesVue; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.NameValuePair; |
| 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.TabPanel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListener; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.DateField; |
| import com.gwtext.client.widgets.form.TextArea; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.grid.GridPanel; |
| import com.gwtext.client.widgets.grid.GridView; |
| import com.gwtext.client.widgets.grid.PropertyGridPanel; |
| import com.gwtext.client.widgets.grid.event.GridCellListenerAdapter; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| /** |
| * Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il |
| * implémente l'interface rafraichissable |
| * |
| * @author aurelien |
| * |
| */ |
| public class PanneauMetadonneesVue extends TabPanel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur imediateur = null; |
| /** |
| * Le panneau des Exifs |
| */ |
| private PropertyGridPanel ExifGrid = null; |
| /** |
| * Le panneau des Iptc |
| */ |
| private PropertyGridPanel IptcGrid = null; |
| /** |
| * La grille pour le panneau des Exifs |
| */ |
| private GridView gViewExif = null; |
| /** |
| * La grille pour le panneau de Iptc |
| */ |
| private GridView gViewIptc = null; |
| /** |
| * L'onglet des Exifs |
| */ |
| private Panel panneauExifGrid = null; |
| /** |
| * L'onglet des Iptc |
| */ |
| private Panel panneauIptcGrid = null; |
| /** |
| * L'onglet des infos |
| */ |
| private Panel panneauInfoGrid = null; |
| /** |
| * L'onglet des mots clés |
| */ |
| private ArbreMotsClesVue panneauMotsCles = null; |
| /** |
| * l'onglet des observations |
| */ |
| private Panel panneauMiniListeObservation = null; |
| /** |
| * Le champ commentaire |
| */ |
| private TextField commentaireGeneral = null; |
| /** |
| * Le champ date |
| */ |
| private DateField dateImage = null; |
| /** |
| * La mini liste des observations |
| */ |
| private MiniListeObservationVue miniListeObservation = null ; |
| /** |
| * Le bouton de validation |
| */ |
| Button validerInfo = null; |
| /** |
| * Barre de notation |
| */ |
| BarreNotationVue noteVue = null; |
| /** |
| * Booleen d'instanciation |
| */ |
| boolean estInstancie = false; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private PanneauMetadonneesVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| */ |
| public PanneauMetadonneesVue(ImageMediateur im) { |
| super(); |
| // on associe le médiateur |
| imediateur = im; |
| // on crée et dispose les panneaux et les champs |
| panneauExifGrid = new Panel("Exif"); |
| panneauIptcGrid = new Panel("Iptc"); |
| panneauInfoGrid = new Panel("Infos"); |
| panneauMotsCles = new ArbreMotsClesVue(im); |
| panneauMotsCles.setHeight("500px"); |
| Panel sousPanneauInfosGenerales = new Panel("Infos Générales"); |
| sousPanneauInfosGenerales.setLayout(new VerticalLayout()); |
| sousPanneauInfosGenerales.setBorder(false); |
| sousPanneauInfosGenerales.setHeight(200); |
| sousPanneauInfosGenerales.setAutoWidth(true); |
| sousPanneauInfosGenerales.setMargins(5); |
| sousPanneauInfosGenerales.setPaddings(5); |
| sousPanneauInfosGenerales.setCollapsible(true); |
| Label labelComm = new Label("Commentaires :"); |
| labelComm.setHeight("20px"); |
| commentaireGeneral = new TextArea(); |
| commentaireGeneral.setWidth("90%"); |
| Label labelDate = new Label("Date :"); |
| Label labelNote = new Label("Note :"); |
| panneauMotsCles.setBorder(false); |
| labelDate.setHeight("20px"); |
| dateImage = new DateField(); |
| dateImage.setAutoWidth(true); |
| dateImage.setFormat("d/m/Y"); |
| validerInfo = new Button("OK"); |
| noteVue = new BarreNotationVue(im, 5); |
| panneauMiniListeObservation = new Panel("Observations") ; |
| panneauMiniListeObservation.setLayout(new FitLayout()) ; |
| panneauMiniListeObservation.setHeight(800) ; |
| miniListeObservation = new MiniListeObservationVue(im) ; |
| panneauMiniListeObservation.add(miniListeObservation) ; |
| sousPanneauInfosGenerales.add(labelComm); |
| sousPanneauInfosGenerales.add(commentaireGeneral); |
| sousPanneauInfosGenerales.add(labelDate); |
| sousPanneauInfosGenerales.add(dateImage); |
| sousPanneauInfosGenerales.add(labelNote); |
| sousPanneauInfosGenerales.add(noteVue); |
| sousPanneauInfosGenerales.add(validerInfo); |
| sousPanneauInfosGenerales.setAutoHeight(true); |
| panneauMotsCles.setAutoHeight(true); |
| panneauInfoGrid.setBorder(false); |
| panneauInfoGrid.setAutoHeight(true); |
| panneauInfoGrid.add(sousPanneauInfosGenerales); |
| panneauInfoGrid.add(panneauMotsCles); |
| this.add(panneauInfoGrid); |
| this.add(panneauMiniListeObservation) ; |
| this.add(panneauExifGrid); |
| this.add(panneauIptcGrid); |
| gViewExif = new GridView(); |
| gViewExif.setForceFit(true); |
| ExifGrid = new PropertyGridPanel(); |
| ExifGrid.setId("meta_exif"); |
| ExifGrid.setView(gViewExif); |
| ExifGrid.setNameText("Métadonnées Exif"); |
| ExifGrid.setAutoWidth(true); |
| ExifGrid.setAutoHeight(true); |
| ExifGrid.setSorted(false); |
| gViewIptc = new GridView(); |
| gViewIptc.setForceFit(true); |
| IptcGrid = new PropertyGridPanel(); |
| IptcGrid.setId("meta_iptc"); |
| IptcGrid.setView(gViewIptc); |
| IptcGrid.setNameText("Métadonnées IPTC"); |
| IptcGrid.setAutoWidth(true); |
| IptcGrid.setAutoHeight(true); |
| IptcGrid.setSorted(false); |
| panneauExifGrid.add(ExifGrid); |
| panneauIptcGrid.add(IptcGrid); |
| // on ajoute les listeners |
| ajouterListeners(); |
| // on effectue le rendu |
| this.doLayout(true); |
| } |
| private void ajouterListeners() { |
| // on ajoute un écouteur |
| validerInfo.addListener(new ButtonListenerAdapter() { |
| // gestion du clic |
| public void onClick(Button button, EventObject e) { |
| button.focus(); |
| // lors du clic sur le bouton valider on met à jour les |
| // commentaires et la date |
| getIMediateur().mettreAJourInfo(commentaireGeneral.getText(), |
| dateImage.getRawValue(), noteVue.getNote()); |
| } |
| }); |
| // gestion des clics dans la grille |
| ExifGrid.addGridCellListener(new GridCellListenerAdapter() { |
| // lors d'un clic d'une cellule |
| public void onCellClick(GridPanel grid, int rowIndex, int colIndex, |
| EventObject e) { |
| // on empeche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| // lors du double clic sur une cellule |
| public void onCellDblClick(GridPanel grid, int rowIndex, |
| int colIndex, EventObject e) { |
| // on empêche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| }); |
| IptcGrid.addGridCellListener(new GridCellListenerAdapter() { |
| // lors d'un clic d'une cellule |
| public void onCellClick(GridPanel grid, int rowIndex, int colIndex, |
| EventObject e) { |
| // on empeche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| // lors d'un double clic d'une cellule |
| public void onCellDblClick(GridPanel grid, int rowIndex, |
| int colIndex, EventObject e) { |
| // on empeche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| }); |
| } |
| /** |
| * Desactive visuellement ce panneau |
| */ |
| public void desactiverPanneau() { |
| this.setDisabled(true); |
| } |
| /** |
| * Active visuellement ce panneau |
| */ |
| public void activerPanneau() { |
| this.setDisabled(false); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return imediateur; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen de notification de mise à jour |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit un tableau d'objets |
| if (nouvelleDonnees instanceof Object[]) { |
| // extrait infos, exifs et iptc |
| Object meta[] = (Object[]) nouvelleDonnees; |
| String[][] exif = (String[][]) meta[0]; |
| String[][] iptc = (String[][]) meta[1]; |
| String[][] gen = (String[][]) meta[2]; |
| NameValuePair[] exifSource = new NameValuePair[exif.length]; |
| NameValuePair[] iptcSource = new NameValuePair[iptc.length]; |
| int maxLength; |
| if (exif.length <= iptc.length) { |
| maxLength = iptc.length; |
| } else { |
| maxLength = exif.length; |
| } |
| for (int i = 0; i < maxLength; i++) { |
| if (i < exif.length && !exif[i][0].equals("null")) { |
| exifSource[i] = new NameValuePair(exif[i][0], exif[i][1]); |
| } |
| if (i < iptc.length && !iptc[i][0].equals("null")) { |
| iptcSource[i] = new NameValuePair(iptc[i][0], iptc[i][1]); |
| } |
| } |
| // on met à jour les champs avec la bonne valeur |
| commentaireGeneral.setValue(gen[0][1]); |
| dateImage.setRawValue(gen[1][1]); |
| // et on met à jour les données pour l'affichage |
| ExifGrid.setSource(exifSource); |
| IptcGrid.setSource(iptcSource); |
| } |
| } |
| /** |
| * Accesseur pour le panneau des mots clés |
| * |
| * @return the panneauMotsCles |
| */ |
| public ArbreMotsClesVue getPanneauMotsCles() { |
| return panneauMotsCles; |
| } |
| public BarreNotationVue getNoteVue() { |
| return noteVue; |
| } |
| public MiniListeObservationVue getMiniListeObservation() |
| { |
| return miniListeObservation ; |
| } |
| public void redimensionner() { |
| if(panneauMiniListeObservation.isCreated() && panneauMiniListeObservation.isVisible()) { |
| panneauMiniListeObservation.doLayout(); |
| //panneauMiniListeObservation.show(); |
| miniListeObservation.redimensionner(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/BarreOutilsVue.java |
|---|
| New file |
| 0,0 → 1,100 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.vues.MenuAideVue; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.ToolbarMenuButton; |
| /** |
| * Barre d'outils contenant le menu de gestion des images (accessible aussi par |
| * un clic droit dans la galerie) et d'autres menus et boutons utiles |
| * |
| * @author aurelien |
| * |
| */ |
| public class BarreOutilsVue extends Toolbar { |
| /** |
| * Un bouton qui sert à déployer le menu |
| */ |
| ToolbarMenuButton images = null; |
| /** |
| * Un bouton qui sert à déployer le menu |
| */ |
| ToolbarMenuButton utilisateur = null; |
| /** |
| * Bouton pour déployer le menu d'aide |
| */ |
| ToolbarMenuButton aide = null ; |
| /** |
| * Le médiateur associé à la toolbar |
| */ |
| ImageMediateur iMediateur = null; |
| /** |
| * Le menu de gestion des images |
| */ |
| MenuImageVue imageMenu = null; |
| /** |
| * Le menu de gestion des filtres |
| */ |
| MenuFiltreVue filtreMenu = null; |
| /** |
| * Le menu de gestion utilisateur |
| */ |
| MenuIdVue idMenu = null; |
| /** |
| * Menu de gestion d'aide |
| */ |
| MenuAideVue aideMenu = null ; |
| /** |
| * Constructeur sans argument (ne doit pas être utilisé donc privé) |
| */ |
| @SuppressWarnings("unused") |
| private BarreOutilsVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| */ |
| public BarreOutilsVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| imageMenu = new MenuImageVue(im); |
| filtreMenu = new MenuFiltreVue(im); |
| //aideMenu = new MenuAideVue(im); |
| images = new ToolbarMenuButton("Fichiers", imageMenu); |
| //aide = new ToolbarMenuButton("Aide", aideMenu); |
| this.addButton(images); |
| //this.addButton(aide); |
| } |
| /** |
| * @return the images |
| */ |
| public ToolbarMenuButton getImages() { |
| return images; |
| } |
| /** |
| * @return the iMediateur |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/GalerieImageVue.java |
|---|
| New file |
| 0,0 → 1,482 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.interfaces.VueListable; |
| import org.tela_botanica.client.vues.BarrePaginationVue; |
| import com.google.gwt.user.client.Element; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.core.XTemplate; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.IntegerFieldDef; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.dd.DropTarget; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.util.Format; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.DataView; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListener; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.DataViewListener; |
| import com.gwtext.client.widgets.event.DataViewListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| /** |
| * Galerie d'images miniatures Avec barre de pagination |
| * |
| * @author aurelien |
| */ |
| public class GalerieImageVue extends Panel implements Rafraichissable, |
| VueListable, ListePaginable { |
| /** |
| * instance du médiateur |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Dataview, littéralement "vue de données" qui permet de définir la manière |
| * d'afficher les données |
| */ |
| private DataView dView = null; |
| /** |
| * Dataview, littéralement "vue de données" qui permet de définir la manière |
| * d'afficher les données |
| */ |
| private Store st = null; |
| /** |
| * Barre de pagination gérant l'affichage d'un nombre donné d'élements par |
| * page et la navigation entre eux |
| */ |
| private BarrePaginationVue pt = null; |
| /** |
| * Booleen indiquant si la galerie est instanciée ou pas |
| */ |
| private boolean estInstancie = false; |
| private boolean garderRatio = true; |
| private int tailleOr = 100 ; |
| boolean lienUploadInitialise = false ; |
| HTML videPanel = null ; |
| /** |
| * Constructeur sans argument, privé car ne doit pas être utilisé |
| */ |
| @SuppressWarnings("unused") |
| private GalerieImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur avec lequel la vue va communiquer |
| */ |
| public GalerieImageVue(ImageMediateur im) { |
| super("Galerie"); |
| iMediateur = im; |
| // on ajoute des listeners au composant tout entier |
| this.addListener(new ContainerListenerAdapter() { |
| // pour gagner du temps on n'instancie la vue en elle même que lors |
| // du premier affichage (lazy rendering) |
| public void onShow(Component component) { |
| if (!estInstancie) { |
| initialiser(); |
| } |
| } |
| }); |
| AjouterListenersLiens(); |
| // et on ajoute la tool bar |
| pt = new BarrePaginationVue(this); |
| pt.setLabelElement("Images"); |
| pt.setTaillePageParDefaut(50); |
| this.setBottomToolbar(pt); |
| } |
| /** |
| * Ajoute tous les listeners nécessaires à l'intercation utilisateur avec la |
| * vue de données |
| */ |
| public void ajouterListenersDataView() { |
| // ajout de listeners pour la gestion de la selection |
| // dans la galerie |
| dView.addListener(new DataViewListenerAdapter() { |
| // gestion du clic sur une image |
| public void onClick(DataView source, int index, Element node, |
| EventObject e) { |
| // on en notifie le médiateur |
| getIMediateur().clicGalerieImage(index, node, e); |
| } |
| // gestion du clic droit |
| public void onContextMenu(DataView source, int index, Element node, |
| EventObject e) { |
| // on stoppe l'évenement |
| e.stopEvent(); |
| // et on notifie le médiateur |
| getIMediateur().montrerContextMenu(e); |
| } |
| // gestion du double clic |
| public void onDblClick(DataView source, int index, Element node, |
| EventObject e) { |
| // on notife le mediateur |
| getIMediateur().clicGalerieImage(index, node, e); |
| } |
| // gestion des actions en fonction de la selection |
| public void onSelectionChange(DataView view, Element[] selections) { |
| // s'il n'y a aucun élement sélectionné |
| if (selections.length <= 0) { |
| // on en notifie le médiateur |
| getIMediateur().aucuneSelection(); |
| } else { |
| // sinon on notifie le médiateur |
| getIMediateur().selection(); |
| // et on lui demande de synchroniser la séléction avec les |
| // autres vues |
| getIMediateur().synchroniserSelection("galerie"); |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour la dataview |
| * |
| * @return la dataview |
| */ |
| public DataView getDView() { |
| return dView; |
| } |
| /** |
| * Renvoie les ids des images sélectionnées |
| * |
| * @return un tableau de String contenant les identifiants des images |
| * sélectionnées |
| */ |
| public String[] getIdSelectionnees() { |
| Record[] selection = getDView().getSelectedRecords(); |
| int taille = selection.length; |
| String id_selection[] = new String[taille]; |
| for (int i = 0; i < selection.length; i++) { |
| id_selection[i] = selection[i].getAsString("num_image"); |
| } |
| return id_selection; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Accesseur pour le store |
| * |
| * @return le store associé à la vue |
| */ |
| public Store getSt() { |
| return st; |
| } |
| /** |
| * Accesseur pour la toolbar |
| * |
| * @return la toolbar associée à la vue |
| */ |
| public BarrePaginationVue getToolBarVue() { |
| return pt; |
| } |
| /** |
| * Fonction d'initialisation du contenu (appelée lors du premier affichage |
| * de la liste) |
| */ |
| public void initialiser() { |
| // Preparation de la dataview et du template |
| // le template va créer une div contenant une image |
| // pour chacune des photos |
| final XTemplate template = new XTemplate( |
| new String[] { |
| "<tpl for='.'>", |
| "<div class='thumb-wrap' id='{num_image}'>", |
| "<div class='thumb dview-list'><img src='{url_image_M}' width='{taille_x_s} px' height='{taille_y_s} px' title='{nom_original}'></div>", |
| "<span></span></div>", "</tpl>", |
| "<div class='x-clear'></div>" }); |
| // pour des raisons de performances on compile le template en une |
| // fonction |
| template.compile(); |
| // la dataview affichera les images en accord avec le template |
| // cree precedemment |
| dView = new DataView("div.thumb-wrap") { |
| public void prepareData(Data data) { |
| data.setProperty("shortName", Format.ellipsis(data |
| .getProperty("nom_original"), 15)); |
| int[] XY = {data.getPropertyAsInt("taille_x") ,data.getPropertyAsInt("taille_y")} ; |
| int[] XYresize ; |
| if(garderRatio) { |
| XYresize = calculerDimensions(XY); |
| } |
| else { |
| XYresize = new int[2] ; |
| XYresize[0] = XYresize[1] = tailleOr ; |
| } |
| data.setProperty("taille_x_s", XYresize[0]); |
| data.setProperty("taille_y_s", XYresize[1]); |
| } |
| }; |
| dView.setTpl(template); |
| // parametre d'affichage de la dataview |
| this.setAutoScroll(true); |
| dView.setAutoHeight(true); |
| dView.setMultiSelect(true); |
| dView.setOverCls("x-view-over"); |
| dView.setEmptyText(""); |
| // creation du store |
| FieldDef defNumImage = new IntegerFieldDef("num_image"); |
| FieldDef defNomImage = new StringFieldDef("nom_original"); |
| FieldDef defDatImage = new StringFieldDef("dat_image"); |
| FieldDef defLieImage = new StringFieldDef("lie_image"); |
| FieldDef defAppImage = new StringFieldDef("app_image"); |
| FieldDef defUrlImageS = new StringFieldDef("url_image_S"); |
| FieldDef defUrlImageM = new StringFieldDef("url_image_M"); |
| FieldDef defUrlImage = new StringFieldDef("url_image"); |
| FieldDef defTailleX = new IntegerFieldDef("taille_x"); |
| FieldDef defTailleY = new IntegerFieldDef("taille_y"); |
| FieldDef[] defTab = { defNumImage, defNomImage, defDatImage, defLieImage, |
| defAppImage, defUrlImageS, defUrlImageM, defUrlImage,defTailleX,defTailleY}; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| dView.setStore(st); |
| this.getDView().setLoadingText("chargement"); |
| this.add(dView); |
| dView.hide(); |
| videPanel = new HTML("<div class=\"avertissement\" >Aucune image à afficher. <br/> <a id=\"lienUploadMultiple\" href=\"#\" > Cliquez ici pour ajouter un dossier entier ou plusieurs fichiers </a> (nécessite Java) <br/> " + |
| " <a id=\"lienUploadSimple\" href=\"#\" > Cliquez ici pour ajouter un fichier à la fois </a> <br/> " + |
| " Pour ajouter des images plus tard, allez dans le menu Fichier -> Ajouter des images </div>"); |
| this.add(videPanel); |
| // ajouts de la gestion des evenements pour la dataview |
| configDragAndDrop() ; |
| ajouterListenersDataView(); |
| estInstancie = true ; |
| } |
| public void configDragAndDrop() |
| { |
| // on fabrique la nouvelle configuration |
| // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("DragGroupName"); |
| //La drop target permet de gérer l'évenement onDrop sur l'élement courant |
| @SuppressWarnings("unused") |
| DropTarget tg = new DropTarget(this, dtc) |
| { |
| public boolean notifyDrop(DragSource source, EventObject e, DragData data){ |
| // si les données proviennent d'une grille |
| if(data instanceof GridDragData) |
| { |
| // on appelle le médiateur |
| return iMediateur.lierObsDD(source, e, data,getId()) ; |
| } |
| return false ; |
| } |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si l'objet reçu est un store |
| if (nouvelleDonnees instanceof Store) { |
| st = (Store) nouvelleDonnees; |
| if(st.getCount() != 0) { |
| // on le charge |
| st.load(); |
| if(videPanel.isVisible()) { |
| videPanel.setVisible(false) ; |
| } |
| if(!dView.isVisible()) { |
| dView.setVisible(true); |
| } |
| // on l'affecte à la vue |
| dView.setStore(st); |
| // et on rafrachit la vue |
| dView.refresh(); |
| } |
| else |
| { |
| st.removeAll(); |
| st.load(); |
| dView.setStore(st); |
| if(dView.isVisible()) { |
| dView.hide() ; |
| } |
| if(!videPanel.isVisible()) { |
| videPanel.setVisible(true); |
| AjouterListenersLiens(); |
| } |
| } |
| } |
| // si le composant doit répandre le rafraichissement |
| if (repandreRafraichissement) { |
| // il en notifie le médiateur en lui donnant une copie des données |
| // et en notifiant qu'il en est l'expéditeur |
| getIMediateur().synchroniserDonneesZoomListeGalerie( |
| nouvelleDonnees, this); |
| } |
| } |
| /** |
| * Méthode héritée de l'interface VueListable Sélectionne les images dans la |
| * galerie suivant les identifiants donnés en paramètres |
| * |
| * @param ids |
| * les identifiants des images à sélectionner |
| */ |
| public void selectionnerImages(int[] ids) { |
| getDView().select(ids); |
| } |
| public void changerNumeroPage(int pageCourante) { |
| iMediateur.changerNumeroPage(pageCourante) ; |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| iMediateur.changerTaillePage(nouvelleTaillePage) ; |
| } |
| public int[] calculerDimensions(int[] tailleXY) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = this.tailleOr ; |
| float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ; |
| float[] XYresize = new float[2]; |
| if(maxTaille == tailleXY[0]) { |
| float rapport = tailleXYf[1]/tailleXYf[0] ; |
| XYresize[0] = tailleOr ; |
| XYresize[1] = tailleOr*rapport ; |
| }else { |
| float rapport = tailleXYf[0]/tailleXYf[1] ; |
| XYresize[1] = tailleOr ; |
| XYresize[0] = tailleOr*rapport ; |
| } |
| int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ; |
| return res; |
| } |
| private void AjouterListenersLiens() { |
| addListener(new PanelListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| ExtElement uploadS = Ext.get("lienUploadSimple"); |
| uploadS.removeAllListeners(); |
| uploadS.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| getIMediateur().uploaderImages(false); |
| } |
| }) ; |
| ExtElement uploadM = Ext.get("lienUploadMultiple"); |
| uploadM.removeAllListeners(); |
| uploadM.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| getIMediateur().uploaderImages(true); |
| } |
| }); |
| } |
| }); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/SelectionFiltreVue.java |
|---|
| New file |
| 0,0 → 1,89 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.form.Checkbox; |
| public class SelectionFiltreVue extends Panel implements Filtrable { |
| private ImageMediateur iMediateur = null; |
| private boolean filtreModifie = false; |
| private Checkbox check = null; |
| @SuppressWarnings("unused") |
| private SelectionFiltreVue() |
| { |
| super() ; |
| } |
| public SelectionFiltreVue(ImageMediateur im) { |
| super(); |
| iMediateur = im ; |
| Label labelRecherche = new Label( |
| "Afficher uniquement les images dans le tampon :"); |
| add(labelRecherche); |
| setBorder(false); |
| setPaddings(5); |
| /* |
| * combo = new ComboBox() ; String tout = "toutes les images "; String |
| * selection = "dans le tampon seulement" ; Object[][] data = new |
| * Object[2][2]; data[0][0] = 1 ; data[0][1] = tout ; data[1][0] = 2 ; |
| * data[1][1] = selection ; |
| * // creation du store qui les contient FieldDef defIdChoix = new |
| * IntegerFieldDef("id_choix"); FieldDef defNomChoix = new |
| * StringFieldDef("nom_choix"); |
| * |
| * FieldDef[] defTab = {defIdChoix, defNomChoix}; RecordDef rd = new |
| * RecordDef(defTab) ; |
| * |
| * final MemoryProxy dataProxy = new MemoryProxy(data); final |
| * ArrayReader reader = new ArrayReader(rd); |
| * |
| * st = new Store(dataProxy, reader); st.load() ; combo.setStore(st) ; |
| * combo.setGrow(true) ; combo.setMode(ComboBox.LOCAL); |
| * combo.setEditable(false) ; //combo.setDisplayField("nom_choix") ; |
| * add(combo) ; |
| */ |
| check = new Checkbox(); |
| check.setChecked(false) ; |
| add(check); |
| } |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| public String renvoyerNomFiltre() { |
| return "Filtre par tampon"; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| if (check.getValue()) { |
| String[] val = { "ci_id_tampon", iMediateur.renvoyerSelection() }; |
| return val; |
| } |
| String[] val = { "ci_id_tampon", "" }; |
| return val; |
| } |
| public void valider() { |
| filtreModifie = true; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/MenuIdVue.java |
|---|
| New file |
| 0,0 → 1,84 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| public class MenuIdVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour le changement d'utilisateur |
| */ |
| private Item changerId = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuIdVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuIdVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| // on construit le menu |
| changerId = new Item("Changer d'utilisateur"); |
| addItem(changerId); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la recherche par commentaires |
| if (item.equals(changerId)) { |
| // on notifie le médiateur |
| getIMediateur().afficherMenuId(); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/DateFiltreVue.java |
|---|
| New file |
| 0,0 → 1,149 |
| package org.tela_botanica.client.vues.image; |
| 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.widgets.Panel; |
| import com.gwtext.client.widgets.form.DateField; |
| /** |
| * Classe implémentant un filtre qui permet de rechercher une image par rapport |
| * à la date associée, des critères plus fins viendront compléter cela |
| * |
| * @author aurelien |
| * |
| */ |
| public class DateFiltreVue extends Panel implements Rafraichissable, Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Le widget calendrier |
| */ |
| private DateField filtreDate = null; |
| /** |
| * Booleen d'état du filtre |
| */ |
| private boolean filtreModifie = false; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private DateFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public DateFiltreVue(ImageMediateur im) { |
| super(); |
| setPaddings(5); |
| setCollapsible(true); |
| setBorder(false); |
| iMediateur = im; |
| Label labelRecherche = new Label("Par date :"); |
| add(labelRecherche); |
| // on crée le calendrier et on définit le format de la date "jj/mm/aaaa" |
| filtreDate = new DateField(); |
| filtreDate.setAutoWidth(true); |
| filtreDate.setFormat("d/m/Y"); |
| add(filtreDate); |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners |
| */ |
| public void ajouterListeners() { |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| filtreModifie = false; |
| } |
| /** |
| * Méthode héritée de l'interface filtrable |
| */ |
| public void valider() { |
| filtreModifie = true; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| @SuppressWarnings("unused") |
| private ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Méthode héritée de l'interface filtrable |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Méthode héritée de l'interface filtrable |
| */ |
| public String renvoyerNomFiltre() { |
| return "Recherche par date"; |
| } |
| /** |
| * Méthode héritée de l'interface filtrable |
| */ |
| public String[] renvoyerValeursAFiltrer() { |
| // si la date est valide |
| if (filtreDate.isValid()) { |
| // on en sépare les composants |
| String dt = filtreDate.getRawValue(); |
| String[] dates = dt.split("/"); |
| if (dates.length == 3) { |
| // qu'on réassemble dans un autre format (américain) pour la |
| // base de donnée "aaaa-mm-jj" |
| String dateFormatee = dates[2] + "-" + dates[1] + "-" |
| + dates[0]; |
| String[] valeursFiltres = { "ci_meta_date", dateFormatee }; |
| return valeursFiltres; |
| } |
| } |
| // si la date n'estp as valide on renvoie une chaine vide (ce qui |
| // correspond à n'importe qu'elle date) |
| String dateFormatee = ""; |
| String[] valeursFiltres = { "ci_meta_date", dateFormatee }; |
| return valeursFiltres; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/ListeImageVue.java |
|---|
| New file |
| 0,0 → 1,595 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.interfaces.VueListable; |
| import org.tela_botanica.client.vues.BarrePaginationVue; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.IntegerFieldDef; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.dd.DropTarget; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.grid.CellMetadata; |
| import com.gwtext.client.widgets.grid.ColumnConfig; |
| import com.gwtext.client.widgets.grid.ColumnModel; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| import com.gwtext.client.widgets.grid.GridPanel; |
| import com.gwtext.client.widgets.grid.Renderer; |
| import com.gwtext.client.widgets.grid.RowSelectionModel; |
| import com.gwtext.client.widgets.grid.event.GridRowListener; |
| import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter; |
| /** |
| * Liste d'image composée de miniatures et d'information sur l'image, implémente |
| * l'interface rafraichissable et l'interface vueListable |
| * |
| * @author aurelien |
| */ |
| public class ListeImageVue extends GridPanel implements Rafraichissable, |
| VueListable, ListePaginable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig numImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig urlImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig lieImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig datImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig appImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig noteImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig nomImage; |
| /** |
| * Modele de colonnes |
| */ |
| private ColumnModel modeleColonnes; |
| /** |
| * Booleen d'instanciation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * Store qui contient les données à afficher |
| */ |
| private Store st = null; |
| /** |
| * Configuration des colonnes du store |
| */ |
| private ColumnConfig cl = null; |
| /** |
| * Barre de pagination |
| */ |
| private BarrePaginationVue bt = null; |
| /** |
| * Taille max des images dans la liste |
| */ |
| private int tailleOr = 50 ; |
| /** |
| * Garder ou non l'aspet original des images |
| */ |
| private boolean garderRatio = true; |
| /** |
| * Constructeur sans arguments (privé car ne doit pas être utilisé) |
| */ |
| private ListeImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ListeImageVue(ImageMediateur im) { |
| new ListeImageVue(); |
| this.setId("listeImageGrid"); |
| // on associe le médiateur |
| this.iMediateur = im; |
| // on place la barre de pagination |
| bt = new BarrePaginationVue(this); |
| bt.setLabelElement("Images"); |
| bt.setTaillePageParDefaut(50); |
| setBottomToolbar(bt); |
| // on construit le modèle de colonnes |
| numImage = new ColumnConfig("Numéro", "num_image", 30, true, |
| new Renderer() { |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| String ImgNum = record.getAsString("num_image"); |
| return "<div class=\"centered-list\">" + ImgNum |
| + "</div>"; |
| } |
| }); |
| datImage = new ColumnConfig("Date", "dat_image", 80, true, |
| new Renderer() { |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| String ImgDat = record.getAsString("dat_image"); |
| if (ImgDat == null) { |
| ImgDat = " "; |
| } |
| return "<div class=\"centered-list\">" + ImgDat |
| + "</div>"; |
| } |
| }); |
| lieImage = new ColumnConfig("Lieu", "lie_image", 120, true, |
| new Renderer() { |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| String ImgLie = record.getAsString("lie_image"); |
| if (ImgLie == null) { |
| ImgLie = " "; |
| } |
| return "<div class=\"centered-list\">" + ImgLie |
| + "</div>"; |
| } |
| }); |
| appImage = new ColumnConfig("Appareil", "app_image", 120, true, |
| new Renderer() { |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| String ImgApp = record.getAsString("app_image"); |
| if (ImgApp == null) { |
| ImgApp = " "; |
| } |
| return "<div class=\"centered-list\">" + ImgApp |
| + "</div>"; |
| } |
| }); |
| // la colonne url possède une méthode de rendu spéciale |
| urlImage = new ColumnConfig("Image", "url_image_S", 30, true, |
| new Renderer() { |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| // on affiche une div contenant l'image pointée par |
| // l'url |
| int[] XY = {record.getAsInteger("taille_x") ,record.getAsInteger("taille_y")} ; |
| int[] XYresize = {tailleOr,tailleOr} ; |
| if(garderRatio) { |
| XYresize = calculerDimensions(XY); |
| } |
| String ImgUrl = record.getAsString("url_image_S"); |
| String ImgNum = record.getAsString("num_image"); |
| return "<div class=\"img-list centered-list\"> <img src=\"" |
| + ImgUrl + "\" title='" + ImgNum + "' width=\""+XYresize[0]+" px\" height=\""+XYresize[1]+" px\"> </div>"; |
| } |
| }); |
| noteImage = new ColumnConfig("Note", "note_image", 80, true, |
| new Renderer() { |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| String htmlImage = ""; |
| int noteImg = record.getAsInteger("note_image"); |
| if (noteImg >= 0) { |
| htmlImage += "<div class=\"img-note centered-list\">"; |
| for (int i = 0; i <= noteImg; i++) { |
| htmlImage += "<img src=\"note-on.gif\">"; |
| } |
| htmlImage += "</div>"; |
| } |
| return htmlImage; |
| } |
| }); |
| nomImage = new ColumnConfig("Nom", "nom_original", 120, true, |
| new Renderer() { |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| String imgNomOr = record.getAsString("nom_original"); |
| if (imgNomOr == null) { |
| imgNomOr = " "; |
| } |
| return "<div class=\"centered-list\">" + imgNomOr |
| + "</div>"; |
| } |
| }); |
| // on associe le modèle de colonnes |
| ColumnConfig[] cm = { numImage, urlImage, nomImage, datImage, lieImage, appImage, |
| noteImage }; |
| modeleColonnes = new ColumnModel(cm); |
| this.setColumnModel(modeleColonnes); |
| this.setAutoScroll(true); |
| this.setAutoWidth(true); |
| this.setEnableColumnResize(true); |
| // creation du store |
| FieldDef defNumImage = new IntegerFieldDef("num_image"); |
| FieldDef defNomImage = new StringFieldDef("nom_original"); |
| FieldDef defDatImage = new StringFieldDef("dat_image"); |
| FieldDef defLieImage = new StringFieldDef("lie_image"); |
| FieldDef defAppImage = new StringFieldDef("app_image"); |
| FieldDef defUrlImageS = new StringFieldDef("url_image_S"); |
| FieldDef defUrlImageM = new StringFieldDef("url_image_M"); |
| FieldDef defUrlImage = new StringFieldDef("url_image"); |
| FieldDef defNoteImage = new StringFieldDef("note_image"); |
| FieldDef defTailleX = new IntegerFieldDef("taille_x"); |
| FieldDef defTailleY = new IntegerFieldDef("taille_y"); |
| FieldDef[] defTab = { defNumImage,defNomImage, defDatImage, defLieImage, |
| defAppImage, defUrlImageS, defUrlImageM, defUrlImage, |
| defNoteImage, defTailleX, defTailleY }; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| // on associe le store |
| this.setStore(st); |
| this.getView().setAutoFill(true); |
| // on crée un masque de chargement qui s'affichera lors des mises à jour |
| this.setLoadMask("chargement"); |
| //Enable drag and drop |
| this.setEnableDragDrop(true); |
| //You need to set the same group for both grids |
| this.setDdGroup("DragGroupName"); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new ContainerListenerAdapter() { |
| public void onHide(Component component) { |
| } |
| // lors du premier rendu on demande les données qui sont déjà |
| // contenues dans la galerie qui est le premier élément affiché |
| public void onRender(Component component) { |
| if (!isEstInstancie()) { |
| setEstInstancie(true); |
| setDragDropText("Glissez les images sur la liste d'observation pour les lier") ; |
| getIMediateur().synchroniserSelection("galerie"); |
| } |
| } |
| public void onShow(Component component) { |
| } |
| }); |
| this.addGridRowListener(new GridRowListener() { |
| // gestion du clic sur une ligne |
| public void onRowClick(GridPanel grid, int rowIndex, EventObject e) { |
| // on notifie le médiateur et on lui passe le nuémro de ligne |
| getIMediateur().clicListeImage(rowIndex); |
| } |
| // gestion du clic droit |
| public void onRowContextMenu(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on stoppe l'évenement pour empecher le navigateur d'afficher |
| // son propre menu |
| e.stopEvent(); |
| // on notifie le médiateur en lui passant l'évenement |
| getIMediateur().montrerContextMenu(e); |
| } |
| // gestion du double clic |
| public void onRowDblClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur en lui passant le numéro de ligne |
| getIMediateur().doubleClicListeImage(rowIndex); |
| } |
| }); |
| this.getSelectionModel().addListener(new RowSelectionListenerAdapter() { |
| // gestion de la sélection |
| public void onSelectionChange(RowSelectionModel sm) { |
| // si on a rien de sélectionné |
| if (sm.getCount() <= 0) { |
| // on notifie le médiateur (qui désactive notamment l'accès |
| // à certaines infos) |
| getIMediateur().aucuneSelection(); |
| } else { |
| // sinon on notifie le médiateur |
| getIMediateur().selection(); |
| // et on lui demande de synchroniser la selection avec les |
| // autres vues |
| getIMediateur().synchroniserSelection("liste"); |
| } |
| } |
| }); |
| //Enable drag and drop |
| this.setEnableDragDrop(true); |
| //Same name in destination |
| this.setDdGroup("DragGroupName"); |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("DragGroupName"); |
| //Now this is the important part, you need a drop target |
| @SuppressWarnings("unused") |
| DropTarget tg = new DropTarget(this, dtc) |
| { |
| public boolean notifyDrop(DragSource source, EventObject e, DragData data){ |
| if(data instanceof GridDragData) |
| { |
| GridDragData gdd = (GridDragData)data ; |
| if(gdd.getGrid().getId().equals("listeImageGrid")) |
| { |
| return false ; |
| } |
| else |
| { |
| return iMediateur.lierObsDD(source, e, data, getId()) ; |
| } |
| } |
| else |
| { |
| return false ; |
| } |
| } |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface VueListable Sélectionne les images dans la |
| * galerie suivant les identifiants donnés en paramètres |
| */ |
| public String[] getIdSelectionnees() { |
| Record[] selection = this.getSelectionModel().getSelections(); |
| int taille = selection.length; |
| String id_selection[] = new String[taille]; |
| for (int i = 0; i < selection.length; i++) { |
| id_selection[i] = selection[i].getAsString("num_image"); |
| } |
| return id_selection; |
| } |
| /** |
| * Accesseur pour la config de colonnes |
| * |
| * @return la config de colonnes |
| */ |
| public ColumnConfig getCl() { |
| return cl; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Accesseur pour le modèle de colonnes |
| * |
| * @return le modèle de colonnes |
| */ |
| public ColumnModel getModeleColonnes() { |
| return modeleColonnes; |
| } |
| /** |
| * Accesseur pour le store |
| * |
| * @return le store contenant les données |
| */ |
| public Store getSt() { |
| return st; |
| } |
| /** |
| * Accesseur pour le booleen d'instanciation |
| * |
| * @return le booleen d'instanciation |
| */ |
| public boolean isEstInstancie() { |
| return estInstancie; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen de notification du rafraichissement |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit un store |
| if (nouvelleDonnees instanceof Store) { |
| // on affecte celui-ci comme gestionnaire de données |
| st = (Store) nouvelleDonnees; |
| st.load(); |
| // et on reconfigure et rafraichit la vue |
| this.reconfigure(st, this.getColumnModel()); |
| } |
| // si on doit répandre l'évenement |
| if (repandreRafraichissement) { |
| // on notifie le médiateur avec une copie des données |
| getIMediateur().synchroniserDonneesZoomListeGalerie( |
| nouvelleDonnees, this); |
| } |
| } |
| /** |
| * Sélectionne des enregistrements donné |
| * |
| * @param sel |
| * un tableau d'enregistrement à selectionner |
| */ |
| public void selectionnerEnregistrements(Record[] sel) { |
| if (isEstInstancie()) { |
| getSelectionModel().clearSelections(); |
| getSelectionModel().selectRecords(sel); |
| } |
| } |
| /** |
| * Accesseur pour la toolbar de pagination |
| * |
| * @return la toolbar de pagination |
| */ |
| public BarrePaginationVue getToolBarVue() { |
| return bt; |
| } |
| /** |
| * Setteur pour le booleen d'instanciation |
| * |
| * @param estInstancie |
| * la nouvelle valeur du booleen |
| */ |
| public void setEstInstancie(boolean estInstancie) { |
| this.estInstancie = estInstancie; |
| } |
| public void mettreAjourInfos(String commentaires, String date, String note) { |
| for (int i = 0; i < getSelectionModel().getCount(); i++) { |
| getSelectionModel().getSelections()[i].set("note_image", note); |
| getSelectionModel().getSelections()[i].set("dat_image", date); |
| } |
| } |
| public void changerNumeroPage(int pageCourante) { |
| iMediateur.changerNumeroPage(pageCourante) ; |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| iMediateur.changerTaillePage(nouvelleTaillePage) ; |
| } |
| public int[] calculerDimensions(int[] tailleXY) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = this.tailleOr ; |
| float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ; |
| float[] XYresize = new float[2]; |
| if(maxTaille == tailleXY[0]) { |
| float rapport = tailleXYf[1]/tailleXYf[0] ; |
| XYresize[0] = tailleOr ; |
| XYresize[1] = tailleOr*rapport ; |
| }else { |
| float rapport = tailleXYf[0]/tailleXYf[1] ; |
| XYresize[1] = tailleOr ; |
| XYresize[0] = tailleOr*rapport ; |
| } |
| int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ; |
| return res; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/image/MenuLiaisonVue.java |
|---|
| New file |
| 0,0 → 1,134 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| import com.gwtext.client.core.EventObject;; |
| /** |
| * Menu de gestion des images |
| * |
| * @author aurelien |
| * |
| */ |
| public class MenuLiaisonVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour lier la selection d'images aux observations selectionnées |
| */ |
| private Item lierSelection = null ; |
| /** |
| * Item pour afficher la selection d'images |
| */ |
| private Item afficherSelection = null; |
| /** |
| * Item pour supprimer la liaison entre une observation et une image |
| */ |
| private Item supprimerLiaison = null ; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuLiaisonVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuLiaisonVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| // on construit le menu |
| lierSelection = new Item("Lier le tampon à la sélection d'observation"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(lierSelection); |
| addItem(afficherSelection); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| public MenuLiaisonVue(ImageMediateur mediateur, boolean liaison) { |
| iMediateur = mediateur; |
| lierSelection = new Item("Lier le tampon à la sélection d'observation"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(lierSelection); |
| addItem(afficherSelection); |
| iMediateur = mediateur; |
| if(liaison) { |
| supprimerLiaison = new Item("Supprimer la liaison") ; |
| addItem(supprimerLiaison); |
| } |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(lierSelection)) { |
| // on notifie le médiateur |
| getIMediateur().LierTamponObservations(); |
| } |
| // si c'est la liaison |
| if (item.equals(afficherSelection)) { |
| getIMediateur().afficherIdSelectionImages(); |
| } |
| if(item.equals(supprimerLiaison)) { |
| getIMediateur().supprimerLiaisonObsImage() ; |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java |
|---|
| New file |
| 0,0 → 1,183 |
| package org.tela_botanica.client.vues; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.google.gwt.user.client.ui.Button; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.ArrayReader; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.MemoryProxy; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListener; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.Field; |
| import com.gwtext.client.widgets.form.event.ComboBoxCallback; |
| import com.gwtext.client.widgets.form.event.ComboBoxListener; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.menu.Menu; |
| public class ListeUtilisateurAdminVue extends Window implements Rafraichissable { |
| private CarnetEnLigneMediateur cMediateur = null ; |
| private ComboBox listeUtil = null ; |
| private Store storeUtil = null ; |
| private com.gwtext.client.widgets.Button OK = null; |
| private boolean selectionUtilisateur =false; |
| private final int KEY_ALT = 18; |
| private final int KEY_BACKSPACE = 8; |
| private final int KEY_CTRL = 17; |
| private final int KEY_DELETE = 46; |
| private final int KEY_DOWN = 40; |
| private final int KEY_END = 35; |
| private final int KEY_ENTER = 13; |
| private final int KEY_ESCAPE = 27; |
| private final int KEY_HOME = 36; |
| private final int KEY_LEFT = 37; |
| private final int KEY_PAGEDOWN = 34; |
| private final int KEY_PAGEUP = 33; |
| private final int KEY_RIGHT = 39; |
| private final int KEY_SHIFT = 16; |
| private final int KEY_TAB = 9; |
| private final int KEY_UP = 38; |
| public ListeUtilisateurAdminVue(CarnetEnLigneMediateur cMed) { |
| super("Choisissez un utilisateur") ; |
| this.cMediateur = cMed; |
| listeUtil=new ComboBox("Utilisateurs","utilisateur",280); |
| final String resultTplUtil = "<div class=\"search-item-utilisateur\">{utilisateur}</div>"; |
| listeUtil.setTpl(resultTplUtil); |
| listeUtil.setMode(ComboBox.REMOTE); |
| // commune.setPageSize(10); // Ne fonctionne pas |
| listeUtil.setItemSelector("div.search-item-utilisateur"); |
| listeUtil.setTypeAhead(true); |
| listeUtil.setHideTrigger(true); |
| listeUtil.setLoadingText("Recherche..."); |
| OK= new com.gwtext.client.widgets.Button("OK"); |
| add(listeUtil); |
| add(OK); |
| this.setSize(300, 75); |
| OK.addListener(new ButtonListenerAdapter() { |
| public void onClick(com.gwtext.client.widgets.Button button, |
| EventObject e) { |
| cMediateur.changerIdentite(listeUtil.getValue()); |
| } |
| }); |
| final ListeUtilisateurAdminVue l = this ; |
| listeUtil.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| if(selectionUtilisateur) { |
| selectionUtilisateur=false; |
| } |
| else { |
| cMediateur.changerIdentite(listeUtil.getText()); |
| close(); |
| } |
| break; |
| default: |
| obtenirListeUtilisateur(); |
| break; |
| } |
| } |
| }); |
| listeUtil.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| String util = record.getAsString("utilisateur"); |
| listeUtil.setValue(util); |
| } |
| }); |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof String[][]) { |
| Object[][] utilData = (Object[][])nouvelleDonnees ; |
| FieldDef defUtil = new StringFieldDef("utilisateur"); |
| FieldDef[] defTab = {defUtil}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(utilData); |
| final ArrayReader reader = new ArrayReader(rd); |
| storeUtil =new Store(dataProxy,reader); |
| storeUtil.load() ; |
| listeUtil.setStore(storeUtil); |
| listeUtil.expand(); |
| } |
| } |
| public void obtenirListeUtilisateur() { |
| String valeur = listeUtil.getRawValue(); |
| cMediateur.obtenirListeUtilisateurs(valeur,this) ; |
| /* |
| String esp=espece.getText().replaceAll(" ","/"); |
| esp=esp.replaceAll("%",""); |
| observationMediateur.obtenirListeReferentielNom(this,esp); |
| */ |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,519 |
| 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 = 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; |
| /** |
| * 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(true); |
| 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 considè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()); |
| } |
| }); |
| /*this.addListener(new PanelListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| if(!arbreCharge) { |
| //obtenirArbreMotsCles(); |
| } |
| } |
| });*/ |
| } |
| /** |
| * 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) { |
| getArbreMotsCles().getNodeById(node.getId()) |
| .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 |
| String usObject[] = (String[]) node |
| .getUserObject(); |
| String nodeId = usObject[1]; |
| if (nodeId.equals(motsClesIds[i])) { |
| getArbreMotsCles().getNodeById(nodeId) |
| .getUI().toggleCheck(true); |
| 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 |
| */ |
| 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; |
| } |
| // 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; |
| } |
| if(motsClesEnAttente.length > 0) { |
| cocherMotsCles(motsClesEnAttente); |
| } |
| } |
| // 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 (arbreCharge) { |
| // 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; |
| Window.alert("des mots clés en attente : "+motsClesEnAttente[0]); |
| } |
| } |
| } |
| private String genererIdMotCle(TreeNode nd) { |
| return "" + (nd.hashCode() + (Math.random() * 10000)); |
| } |
| /** |
| * 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); |
| } |
| } |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/BarrePaginationVue.java |
|---|
| New file |
| 0,0 → 1,481 |
| package org.tela_botanica.client.vues; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Template; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.SimpleStore; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.ToolbarTextItem; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.Field; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter; |
| /** |
| * Barre de pagination asynchrone avec filtrage des touches et accès directs et |
| * séquentiels à une page |
| * |
| * @author aurelien |
| * |
| */ |
| public class BarrePaginationVue extends Toolbar implements Rafraichissable { |
| /** |
| * Instance du médiateur à qui on notifie les évnènements |
| */ |
| private ListePaginable listePaginable = null; |
| /** |
| * Bouton précédent |
| */ |
| private ToolbarButton prevPage = new ToolbarButton(); |
| /** |
| * Bouton suivant |
| */ |
| private ToolbarButton suivPage = new ToolbarButton(); |
| /** |
| * Numéro de la page courante (attention, commence à zéro pour des raisons |
| * pratiques) |
| */ |
| private int pageCourante = 0; |
| /** |
| * Nombre de page total |
| */ |
| private int pageTotale = 1; |
| /** |
| * Nombre d'élements total |
| */ |
| private int nbElement = 0; |
| /** |
| * Nombre d'élément par page |
| */ |
| private int taillePage = 0; |
| /** |
| * Texte statique de la toolbar 1 |
| */ |
| private ToolbarTextItem page = new ToolbarTextItem("Page "); |
| /** |
| * Affichage de la page courante |
| */ |
| private TextField champPage = new TextField("" + (pageCourante + 1)); |
| /** |
| * Affichage de "sur pageTotale " |
| */ |
| private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur " |
| + pageTotale); |
| /** |
| * Texte statique de la toolbar 2 |
| */ |
| private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher "); |
| /** |
| * Combobox permettant de selectionner le nombre d'élements à afficher par |
| * page et donc de changer la variable taillePage |
| */ |
| private ComboBox selecteurTaillePage = new ComboBox(); |
| /** |
| * Les différents intervalles de page possibles (intialisé par défaut) |
| */ |
| String[] pages = { "200","100","50", "20", "10" }; |
| Store storeIntervalle = null ; |
| /** |
| * Label indiquant le type d'element affiché |
| * |
| */ |
| private String labelElement="Elements"; |
| /** |
| * taille de la page par defaut |
| * |
| */ |
| private int taillePageDefaut = 50; |
| /** |
| * Texte statique de la toolbar 3 |
| */ |
| private ToolbarTextItem nbElemParPage = new ToolbarTextItem( |
| labelElement + " par page "); |
| /** |
| * Affiche l'intervalle des éléments contenus dans la page |
| */ |
| private ToolbarTextItem intervalleElements = new ToolbarTextItem(labelElement + " " |
| + pageCourante * taillePage + " sur " + nbElement); |
| /** |
| * retourne la liste associé à la barre |
| */ |
| public ListePaginable getlistePaginable() { |
| return listePaginable; |
| } |
| /*************************************************************************** |
| * constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private BarrePaginationVue() { |
| super(); |
| } |
| /** |
| * constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer à la barre |
| */ |
| public BarrePaginationVue(ListePaginable lst) { |
| super(); |
| listePaginable = lst; |
| // on remplit l'espace pour que l'intervalle d'élement se place à droite |
| // de la barre |
| addItem(intervalleElements); |
| addSpacer(); |
| // on remplit l'espace pour que l'intervalle d'élement se place à droite |
| // de la barre |
| addFill(); |
| // on dispose un peu de texte et quelques espaces pour séparer les |
| // éléments |
| addButton(prevPage); |
| addSpacer(); |
| addItem(page); |
| addField(champPage); |
| addItem(surTotalPage); |
| addSpacer(); |
| addButton(suivPage); |
| champPage.setWidth(30); |
| addSpacer(); |
| addItem(afficherNbElem); |
| prevPage.setIcon("page_prev.png"); |
| suivPage.setIcon("page_suiv.png"); |
| setIntervallesPages(pages) ; |
| // le template definit ce que l'on affiche pour chaque element du store |
| // dans la combobox |
| final Template tp = new Template("<div class=\"x-combo-list-item\">" |
| + "{nb_page}" + "<div class=\"x-clear\"></div></div>"); |
| tp.compile(); |
| selecteurTaillePage.setTpl(tp); |
| selecteurTaillePage.setStore(storeIntervalle); |
| selecteurTaillePage.setEditable(false); |
| addField(selecteurTaillePage); |
| selecteurTaillePage.setValue(""+taillePageDefaut); |
| selecteurTaillePage.setWidth(50); |
| addItem(nbElemParPage); |
| // on ajoute les différents listeners |
| ajouterListeners(); |
| } |
| /** |
| * Texte nommant les elements pagines (Images, Observation, truc, machin etc...). |
| * @param label |
| */ |
| public void setLabelElement(String label) { |
| this.labelElement = label; |
| nbElemParPage.setText(labelElement + " par page "); |
| intervalleElements.setText(labelElement + " " + pageCourante * taillePage + " sur " + nbElement); |
| } |
| public void setTaillePageParDefaut(int taille) { |
| this.taillePageDefaut = taille; |
| selecteurTaillePage.setValue(""+taillePageDefaut); |
| } |
| public void setIntervallesPages(String[] intervalle) |
| { |
| String[][] intervallesPages = new String[intervalle.length][1] ; |
| for(int i = 0 ; i < intervalle.length ; i++) |
| { |
| intervallesPages[i][0] = intervalle[i] ; |
| } |
| storeIntervalle = new SimpleStore(new String[] { "nb_page" }, |
| intervallesPages ); |
| storeIntervalle.load(); |
| selecteurTaillePage.setStore(storeIntervalle); |
| } |
| /** |
| * ajoute les différents listeners nécessaires au bon fonctionnement des |
| * éléments de la barre de pagination |
| */ |
| private void ajouterListeners() { |
| // boutons suivants et précédents |
| prevPage.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| // si la page courante n'est pas la première |
| if (pageCourante > 0) { |
| // on décrémente la page courante de 1 |
| pageCourante--; |
| // on rafraichit l'affichage |
| rafraichirNumeroPage(); |
| // et on notifie le médiateur de l'évenement |
| listePaginable.changerNumeroPage(pageCourante); |
| } |
| } |
| }); |
| suivPage.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| // si la page courante n'est pas la dernière |
| if (pageCourante < pageTotale - 1) { |
| // on incrémente la page courante de 1 |
| pageCourante++; |
| // on rafraichit l'affichage |
| rafraichirNumeroPage(); |
| // et on notifie le médiateur de l'évenement |
| listePaginable.changerNumeroPage(pageCourante); |
| } |
| } |
| }); |
| champPage.addListener(new TextFieldListenerAdapter() { |
| public void onSpecialKey(Field field, EventObject e) { |
| // on teste si la touche entrée a été pressée |
| if (e.getKey() == EventObject.ENTER) { |
| int nouvellePage = pageCourante; |
| // on teste avec parseInt si la valeur entrée est un entier |
| try { |
| nouvellePage = Integer |
| .parseInt(champPage.getRawValue()); |
| } |
| // si ce n'est pas le cas alors on remet le numéro de page |
| // correct |
| catch (NumberFormatException nfe) { |
| rafraichirNumeroPage(); |
| champPage.focus(true); |
| return; |
| } |
| // si la conversion reussit on verifie s'il est nécessaire |
| // de changer de page |
| // et si la nouvelle est comprise dans l'intervalle des |
| // pages existantes (0..pageTotale) |
| if (nouvellePage != pageCourante + 1 && nouvellePage > 0 |
| && nouvellePage <= pageTotale) { |
| // le cas échéant, on charge la nouvelle page et on |
| // notifie le médiateur |
| changerPageCourante(nouvellePage - 1); |
| listePaginable.changerNumeroPage(pageCourante); |
| } else { |
| // sinon on reaffiche l'ancien numero de page sans rien |
| // changer |
| rafraichirNumeroPage(); |
| champPage.focus(true); |
| } |
| } |
| } |
| public void onFocus(Field field) { |
| champPage.focus(true); |
| } |
| }); |
| // pour éviter de se compliquer la vie, on filtre tous les charactères |
| // non numériques |
| champPage.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // si c'est un numerique |
| if (Character.isDigit((char) e.getCharCode())) { |
| // on laisse passer |
| return; |
| } |
| // si c'est la touche entrée ou backspace (valider ou effacer) |
| if (e.getKey() == EventObject.ENTER |
| || e.getKey() == EventObject.BACKSPACE) { |
| // on laisse passer |
| return; |
| } else { |
| // sinon on remet le numero de page correct et on annule |
| // l'évenement |
| rafraichirNumeroPage(); |
| e.stopEvent(); |
| } |
| } |
| }); |
| // listener pour la selection dans la combobox |
| selecteurTaillePage.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| String nouvelleTaillePageString = comboBox.getStore() |
| .getRecordAt(index).getAsString("nb_page"); |
| int nouvelleTaillePage = Integer |
| .parseInt(nouvelleTaillePageString); |
| // si la taille de page est différente de l'ancienne |
| if (nouvelleTaillePage != taillePage) { |
| // on la change |
| changerTaillePage(nouvelleTaillePage); |
| } |
| // et on met la valeur à jour dans la combobox |
| comboBox.setValue(nouvelleTaillePageString); |
| } |
| }); |
| } |
| /** |
| * Met à jour les affichage sur les numéros de pages et d'intervalle |
| * d'éléments à partir des variables de classes |
| */ |
| public void rafraichirNumeroPage() { |
| surTotalPage.setText(" sur " + pageTotale); |
| if (nbElement == 0) { |
| champPage.setValue("" + (0)); |
| // on met simplement à jour l'intervalle qui contient toujours le |
| // même nombre d'éléments |
| intervalleElements.setText(labelElement + " 0 - 0 sur 0"); |
| } else { |
| champPage.setValue("" + (pageCourante + 1)); |
| // si la page n'est pas la dernière |
| if (pageCourante + 1 != pageTotale) { |
| // sauf pour la dernière page qui contient souvent moins |
| // d'élements que le nombre d'élements par page |
| intervalleElements.setText(labelElement + " " + pageCourante |
| * taillePage + " - " + (pageCourante + 1) * taillePage |
| + " sur " + nbElement); |
| } else { |
| // on met simplement à jour l'intervalle qui contient toujours |
| // le même nombre d'éléments |
| intervalleElements.setText(labelElement + " " + pageCourante |
| * taillePage + " - " + nbElement + " sur " + nbElement); |
| } |
| } |
| } |
| /** |
| * Met à jour la page en cours |
| * |
| * @param nouvellePageCourante |
| * la nouvelle page en cours |
| */ |
| public void changerPageCourante(int nouvellePageCourante) { |
| pageCourante = nouvellePageCourante; |
| } |
| /** |
| * Methode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| // si on reçoit un tableau de int |
| if (nouvelleDonnees instanceof int[]) { |
| int[] page = (int[]) nouvelleDonnees; |
| // le premier élement est le nombre de pages totales |
| pageTotale = page[0]; |
| // le second la page en cours |
| pageCourante = page[1]; |
| // le troisième la taille de la page |
| taillePage = page[2]; |
| // et le dernier le nombre total d'éléments |
| nbElement = page[3]; |
| // si la page courante dépasse la page totale (cas normalement |
| // improbable car géré en amont) |
| // on met le numéro de page à la page courante -1 (car la page |
| // courante est comptée à partir |
| // de zéro) |
| if (pageCourante >= pageTotale && pageCourante != 0) { |
| pageCourante = pageTotale - 1; |
| // le cas échéant on en notifie le médiateur |
| listePaginable.changerNumeroPage(pageCourante); |
| } |
| } |
| // enfin on rafraichit les informations affichées à partir des nouvelles |
| // variables de classes mises à jour |
| rafraichirNumeroPage(); |
| } |
| /** |
| * Renvoie les différents intervalles de pages possibles |
| * |
| * @return un tableau de string qui contient les différentes |
| * taille de pages |
| */ |
| public String[] getNbPages() { |
| return pages; |
| } |
| /** |
| * Envoie au médiateur une demande pour modifier la taille de la page (qui |
| * va à son tour faire les modifications nécessaires) |
| * |
| * @param nouvelleTaillePage |
| * la nouvelle taille de page (élement appartenant au tableau |
| * renvoyé par getNbPages()) |
| */ |
| public void changerTaillePage(int nouvelleTaillePage) { |
| listePaginable.changerTaillePage(nouvelleTaillePage); |
| } |
| /** |
| * Selectionne la valeur correspond à celle passée en paramètre dans la |
| * combobox (si elle existe) |
| * |
| * @param nouvelleTaillePage |
| * la nouvelle taille de page |
| */ |
| public void selectionnerTaillePage(int nouvelleTaillePage) { |
| selecteurTaillePage.setValue("" + nouvelleTaillePage); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |