| /trunk/src/org/tela_botanica/client/vues/image/filtres/ArbreDateImageFiltreVue.java |
|---|
| New file |
| 0,0 → 1,548 |
| package org.tela_botanica.client.vues.image.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| 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.modeles.DateObservation; |
| import org.tela_botanica.client.modeles.ListeDate; |
| import org.tela_botanica.client.modeles.Observation; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.user.client.Window; |
| 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 ArbreDateImageFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur imageMediateur = 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 = "" ; |
| private String prefixeId = "date_image_"; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreDateImageFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreDateImageFiltreVue(ImageMediateur imgMed) { |
| // on crée le panel |
| super("Dates"); |
| this.imageMediateur = imgMed; |
| arbreDonneesDates = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(true); |
| this.setBorder(false); |
| arbreDonneesDates.setBorder(false); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| estInstancie = false; |
| } |
| /** |
| * Ajoute les listeners pour le rendu du panel |
| */ |
| private void ajouterListenersPanel() { |
| // on interdit le drag and drop dans l'arbre |
| arbreDonneesDates.setEnableDD(false); |
| arbreDonneesDates.setId("x-view-tree-filter-date-image"); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Dates"); |
| root.addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages(); |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.setRootVisible(true); |
| setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreDonneesDates); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| public 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) { |
| nomFiltre = ""; |
| donneesDateEnCours = ""; |
| } |
| break; |
| 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 ; |
| imageMediateur.obtenirPhotoGalerie() ; |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages(); |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| donneesDateEnCours = ""; |
| arbreDonneesDates.collapseAll(); |
| arbreDonneesDates.purgeListeners(); |
| // 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) |
| { |
| obtenirDatesImages() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeDate) { |
| String annee=null; |
| String mois=null; |
| String jour=null; |
| ListeDate data = (ListeDate) nouvelleDonnees ; |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine_date"); |
| root.setText("Dates"); |
| String[] usObjRoot = { "Dates", "Dates", prefixeId+"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(prefixeId+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = nouvelArbre.getNodeById(prefixeId+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = nouvelArbre.getNodeById(prefixeId+(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(prefixeId+(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(prefixeId+(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(prefixeId+(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(prefixeId+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(prefixeId+(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(prefixeId+(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(); |
| } |
| } |
| /** |
| * 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 = new String[0]; |
| if(!nomFiltre.trim().equals("") && !donneesDateEnCours.trim().equals("")) { |
| valeursFiltrees = new String[2]; |
| valeursFiltrees[0] = nomFiltre; |
| valeursFiltrees[1] = 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(prefixeId+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", prefixeId+"racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| donneesDateEnCours = ""; |
| } |
| public void obtenirDatesImages() { |
| imageMediateur.obtenirDatesImages(this); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/image/filtres/DateFiltreVue.java |
|---|
| New file |
| 0,0 → 1,179 |
| package org.tela_botanica.client.vues.image.filtres; |
| 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.EventCallback; |
| 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.form.DateField; |
| import com.gwtext.client.widgets.layout.HorizontalLayout; |
| /** |
| * 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; |
| private Button boutonRechercher = null; |
| private final int KEY_ENTER = 13; |
| /** |
| * 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(); |
| setLayout(new HorizontalLayout(3)); |
| setPaddings(5); |
| setCollapsible(true); |
| setBorder(false); |
| iMediateur = im; |
| boutonRechercher = new Button("OK"); |
| // 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); |
| add(boutonRechercher); |
| } |
| /** |
| * Ajoute les listeners |
| */ |
| public void ajouterListeners() { |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| } |
| }); |
| filtreDate.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| break; |
| } |
| } |
| }); |
| } |
| /** |
| * 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 |
| /trunk/src/org/tela_botanica/client/vues/image/filtres/RechercheFiltreTaxonVue.java |
|---|
| New file |
| 0,0 → 1,111 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListener; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| public class RechercheFiltreTaxonVue extends Panel implements Filtrable { |
| private ImageMediateur iMediateur = null; |
| private TextField champRecherche = null; |
| private static String titrePanneau = "Recherche libre"; |
| private String valeurRecherchee= ""; |
| private Button boutonRechercher = null; |
| private boolean estModifie = true; |
| private final int KEY_ENTER = 13; |
| public RechercheFiltreTaxonVue(ImageMediateur im) { |
| super(titrePanneau); |
| iMediateur = im; |
| champRecherche = new TextField(); |
| champRecherche.setWidth("90%"); |
| boutonRechercher = new Button("Rechercher"); |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| break; |
| } |
| } |
| }); |
| add(champRecherche); |
| add(boutonRechercher); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setPaddings(5); |
| } |
| public boolean renvoyerEtatFiltre() { |
| return estModifie; |
| } |
| public String renvoyerNomFiltre() { |
| return "Taxon"; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| String nom = ""; |
| if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) { |
| valeurRecherchee = champRecherche.getValueAsString(); |
| nom = "nom_taxon"; |
| } else { |
| nom = "nom_taxon"; |
| valeurRecherchee = ""; |
| } |
| String[] valeurs = {nom,valeurRecherchee}; |
| return valeurs; |
| } |
| public void valider() { |
| if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) { |
| estModifie = true; |
| iMediateur.obtenirNombreMiniListeObservations(); |
| } else { |
| estModifie = false; |
| } |
| } |
| public void raz() { |
| if(champRecherche.isCreated()) { |
| champRecherche.reset(); |
| valeurRecherchee = ""; |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/image/filtres/PanneauFiltresImagesVues.java |
|---|
| New file |
| 0,0 → 1,186 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreDateObservationFiltreVue; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| 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.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListener; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| 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; |
| /** |
| * L'arbre pour la recherche par mots clés |
| */ |
| private ArbreDateImageFiltreVue arbreDateImageFiltreVue = null; |
| /** |
| * La barre de recherche par commentaires |
| */ |
| private BarreRechercheFiltreVue rechercheLibreFiltreVue = 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 RowLayout()); |
| rechercheLibreFiltreVue = new BarreRechercheFiltreVue(im); |
| rechercheLibreFiltreVue.setTitle("Recherche libre"); |
| rechercheLibreFiltreVue.setCollapsible(true); |
| add(rechercheLibreFiltreVue, new RowLayoutData()); |
| if(Ext.isIE()) { |
| add(rechercheLibreFiltreVue); |
| rechercheLibreFiltreVue.setHeight(110); |
| } else { |
| add(rechercheLibreFiltreVue,new RowLayoutData(100)); |
| } |
| arbreDateImageFiltreVue = new ArbreDateImageFiltreVue(im) ; |
| arbreDateImageFiltreVue.setWidth("100%") ; |
| arbreDateImageFiltreVue.setBorder(false); |
| add(arbreDateImageFiltreVue, new RowLayoutData()); |
| motsClesFiltres = new ArbreMotsClesFiltreVue(im); |
| motsClesFiltres.setTitle("Mots clés"); |
| motsClesFiltres.setAutoScroll(true); |
| add(motsClesFiltres, new RowLayoutData()); |
| selectionFiltreVue = new SelectionFiltreVue(im); |
| addListener(new ContainerListenerAdapter() { |
| public void onRender(Component component) { |
| // TODO Auto-generated method stub |
| rechercheLibreFiltreVue.ajouterListeners(); |
| arbreDateImageFiltreVue.ajouterListeners(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le filtre des mots clés |
| * |
| * @return le filtre des mots clés |
| */ |
| public ArbreMotsClesFiltreVue getMotsClesFiltre() { |
| return motsClesFiltres; |
| } |
| /** |
| * Accesseur pour le filtre général |
| * |
| * @return le filtre général |
| */ |
| public BarreRechercheFiltreVue getBarreRecherche() { |
| return rechercheLibreFiltreVue; |
| } |
| /** |
| * 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() |
| || rechercheLibreFiltreVue.renvoyerEtatFiltre() |
| || arbreDateImageFiltreVue.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[] filtresDates = arbreDateImageFiltreVue.renvoyerValeursAFiltrer(); |
| int lgSup = 0; |
| if(filtresDates.length > 0) { |
| String[] nomFiltresDates = filtresDates[0].split(","); |
| String[] valFiltresDates = filtresDates[1].split(","); |
| lgSup = Math.max(nomFiltresDates.length, valFiltresDates.length); |
| } |
| String[][] filtres = new String[3 + lgSup][2]; |
| for(int i=3; i < filtres.length; i++) { |
| filtres[i][0] = filtresDates[0].split(",")[i - 3]; |
| filtres[i][1] = filtresDates[1].split(",")[i -3]; |
| } |
| filtres[0] = motsClesFiltres.renvoyerValeursAFiltrer(); |
| filtres[1] = rechercheLibreFiltreVue.renvoyerValeursAFiltrer(); |
| filtres[2] = selectionFiltreVue.renvoyerValeursAFiltrer(); |
| return filtres; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/image/filtres/BarreRechercheFiltreVue.java |
|---|
| New file |
| 0,0 → 1,193 |
| package org.tela_botanica.client.vues.image.filtres; |
| 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.core.client.GWT; |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| 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.Panel; |
| import com.gwtext.client.widgets.event.ButtonListener; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListener; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.KeyListener; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.HorizontalLayout; |
| import com.gwtext.client.widgets.menu.Menu; |
| /** |
| * 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; |
| private Button boutonRechercher = null; |
| /** |
| * mot(s) à chercher |
| */ |
| private String motsAChercher = ""; |
| private final int KEY_ENTER = 13; |
| /** |
| * 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(); |
| setLayout(new HorizontalLayout(3)); |
| iMediateur = im; |
| champRecherche = new TextField(); |
| boutonRechercher = new Button("OK"); |
| add(champRecherche); |
| add(boutonRechercher); |
| setPaddings(5); |
| setBorder(false); |
| setAutoWidth(true); |
| setCollapsible(true); |
| ajouterListeners(); |
| } |
| /** |
| * ajoute des listeners |
| */ |
| public void ajouterListeners() { |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| break; |
| } |
| } |
| }); |
| } |
| /** |
| * 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_recherche_generale", 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 |
| /trunk/src/org/tela_botanica/client/vues/image/filtres/MenuFiltreVue.java |
|---|
| New file |
| 0,0 → 1,96 |
| package org.tela_botanica.client.vues.image.filtres; |
| 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 |
| /trunk/src/org/tela_botanica/client/vues/image/filtres/SelectionFiltreVue.java |
|---|
| New file |
| 0,0 → 1,89 |
| package org.tela_botanica.client.vues.image.filtres; |
| 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 |