| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/CarnetEnLigneMediateur.java |
|---|
| New file |
| 0,0 → 1,498 |
| package org.tela_botanica.client; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.vues.EtatConnexionVue; |
| import org.tela_botanica.client.vues.FenetreLicenceVue; |
| import org.tela_botanica.client.vues.FormulaireDeConnexionVue; |
| import org.tela_botanica.client.vues.ListeUtilisateurAdminVue; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.user.client.Timer; |
| 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.BoxComponent; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.TabPanel; |
| import com.gwtext.client.widgets.Tool; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.TabPanelListenerAdapter; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| /** |
| * Mediateur gérant les interactions entre vues et les echanges de données |
| * C'est un singleton. |
| * @author david delon |
| * |
| */ |
| public class CarnetEnLigneMediateur implements Rafraichissable { |
| /** |
| * booleen qui verifie l'unicite de l'instance |
| */ |
| private static boolean estInstancie = false ; |
| /** |
| * pointeur vers le médiateur lui même (pour le pattern singleton) |
| */ |
| private static CarnetEnLigneMediateur thisMediateur = null ; |
| /** |
| * modele de données |
| */ |
| private CarnetEnLigneModele carnetEnLigneModele=null; |
| /** |
| * panneau principal de l'application "Carnet en ligne" |
| */ |
| private Panel panneauPrincipalCarnetEnLigne= null ; |
| /** |
| * panneau a onglet pour les observation et les images |
| */ |
| private com.gwtext.client.widgets.TabPanel ongletsObservationsImages=null; |
| /** |
| * Indicateur d'etat de la connexion utilisateur |
| */ |
| private EtatConnexionVue etatConnexionVue=null; |
| /** |
| * Texte d'invite connexion |
| */ |
| private final String texteDeconnexion="Utilisez ce carnet en ligne pour saisir vos observations, <u>identifiez-vous</u> pour les transmettre à Tela Botanica"; |
| /** |
| * Boolean indiquant un essai de connexion |
| */ |
| private boolean tentativeConnection=false; |
| /** |
| * Booleen indique que la licence a été acceptée |
| */ |
| private boolean licenceUtilisateurAcceptee = false; |
| /** |
| * Formulaire de connexion (lazy instantiation) |
| * |
| */ |
| private FormulaireDeConnexionVue formulaireDeConnexionVue=null; |
| /** |
| * |
| */ |
| private Panel bandeau = null ; |
| private Panel panneauAdmin = null ; |
| Tool cacherPanneau = null ; |
| private FenetreLicenceVue fenetreAcceptationLicence = null; |
| /** |
| * Mediateur Gestion des images |
| */ |
| private ImageMediateur imageMediateur=null; |
| /** |
| * Mediateur Gestion des observations |
| */ |
| private ObservationMediateur observationMediateur=null; |
| /** |
| * Utilisateur en cours |
| */ |
| private Utilisateur utilisateur=null; |
| public static CarnetEnLigneMediateur Instance() |
| { |
| if(!estInstancie || thisMediateur==null) |
| { |
| estInstancie = true ; |
| thisMediateur = new CarnetEnLigneMediateur() ; |
| } |
| return thisMediateur ; |
| } |
| /** |
| * constructeur privé (on accède a la classe par la méthode getInstance |
| */ |
| private CarnetEnLigneMediateur() { |
| panneauPrincipalCarnetEnLigne = new Panel("Carnet en ligne"); |
| // Disposition |
| panneauPrincipalCarnetEnLigne.setLayout(new RowLayout()); |
| // Pourrait etre fait plus loin ... |
| carnetEnLigneModele=CarnetEnLigneModele.Instance(); |
| bandeau = new Panel(); |
| bandeau.setId("x-up-bandeau") ; |
| etatConnexionVue=new EtatConnexionVue(this); |
| etatConnexionVue.setLayout(new FitLayout()) ; |
| // Le panneau à onglet qui contient les 2 applications Observation et Images |
| ongletsObservationsImages = new TabPanel(); |
| panneauPrincipalCarnetEnLigne.add(etatConnexionVue,new RowLayoutData(16)); |
| panneauAdmin = new Panel(); |
| panneauAdmin.setId("panneau_admin"); |
| panneauPrincipalCarnetEnLigne.add(panneauAdmin, new RowLayoutData(16)); |
| panneauAdmin.setBorder(false); |
| panneauAdmin.hide(); |
| panneauPrincipalCarnetEnLigne.add(ongletsObservationsImages,new RowLayoutData()); |
| //panneauPrincipalCarnetEnLigne.addTool(cacherPanneau) ; |
| // On ajoute les applications |
| observationMediateur = ObservationMediateur.Instance(this); |
| imageMediateur= ImageMediateur.Instance(this); |
| if(!GWT.isScript()) { |
| //temp dd viewport desactive ajout de cette ligne |
| getPanneauPrincipalCarnetEnLigne().setHeight(Window.getClientHeight()) ; |
| } |
| panneauPrincipalCarnetEnLigne.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, |
| int adjHeight, int rawWidth, int rawHeight) { |
| CarnetEnLigneMediateur.fireResize(); |
| observationMediateur.redimensionnerPanneaux(adjHeight, adjWidth); |
| } |
| }); |
| ongletsObservationsImages.addListener(new TabPanelListenerAdapter() { |
| @Override |
| public void onTabChange(TabPanel source, Panel tab) { |
| if(tab.equals(imageMediateur.getPanneauPrincipalImage())) { |
| Timer t = new Timer() { |
| @Override |
| public void run() { |
| imageMediateur.obtenirNombreMiniListeObservations(); |
| imageMediateur.rafraichirToutesVues(); |
| } |
| }; |
| t.schedule(150); |
| } |
| } |
| }); |
| // on ajoute les panneaux principaux des applications au panneau à onglets |
| ongletsObservationsImages.add(observationMediateur.getPanneauPrincipalObservation()); |
| ongletsObservationsImages.add(imageMediateur.getPanneauPrincipalImage()); |
| } |
| public void getEtatUtilisateur() { |
| carnetEnLigneModele.getEtatUtilisateur(this); |
| } |
| // Methode publiques |
| /** |
| * Recherche Identifiant utilisateur en cours et etat de connection |
| * @return Utilisateur |
| */ |
| public Utilisateur getUtilisateur() { |
| return utilisateur; |
| } |
| /** |
| * Deconnecte l'utilisateur passe en parametre |
| */ |
| public void deconnecterUtilisateur() { |
| licenceUtilisateurAcceptee = false; |
| // TODO: vider proprement toutes les vues (méthode à voir) |
| carnetEnLigneModele.deconnecterUtilisateur(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| observationMediateur.deconnecterUtilisateur() ; |
| imageMediateur.deconnecterUtilisateur(); |
| panneauAdmin.setVisible(false); |
| } |
| public void connecterUtilisateur(String login, String password) { |
| tentativeConnection=true; |
| carnetEnLigneModele.connecterUtilisateur(this, login, password); |
| } |
| /** |
| * Affichage etat de la connexion |
| */ |
| private void afficheEtatConnexion() { |
| if (!utilisateur.isIdentifie()) { |
| etatConnexionVue.setEtat("",false); |
| } |
| else { |
| if(utilisateur.isAdmin()) { |
| afficherLienAdmin(); |
| panneauAdmin.setVisible(true); |
| } else { |
| cacherLienAdmin(); |
| } |
| etatConnexionVue.setEtat(Utilisateur.getInstance().getLoginUtilisateurConsulte(),true); |
| } |
| } |
| private void afficherFenetreAcceptationLicence() { |
| fenetreAcceptationLicence = new FenetreLicenceVue(this); |
| // On le positionne à peu près au milieu de l'écran |
| int left = (Window.getClientWidth() - 512) / 2; |
| int top = (Window.getClientHeight() - 256) / 5; |
| fenetreAcceptationLicence.setPosition(left, top); |
| fenetreAcceptationLicence.setHeight(350); |
| fenetreAcceptationLicence.setWidth(550); |
| fenetreAcceptationLicence.setModal(true); |
| fenetreAcceptationLicence.show(); |
| } |
| /** |
| * |
| * Affichage boite de connexion |
| * |
| */ |
| public void afficherDialogueConnexion() { |
| if (formulaireDeConnexionVue==null) { |
| formulaireDeConnexionVue= new FormulaireDeConnexionVue(this); |
| } |
| // On le positionne à peu près au milieu de l'écran |
| int left = (Window.getClientWidth() - 512) / 2; |
| int top = (Window.getClientHeight() - 256) / 2; |
| formulaireDeConnexionVue.setPopupPosition(left, top); |
| formulaireDeConnexionVue.show(); |
| } |
| public Panel getPanneauPrincipalCarnetEnLigne() { |
| return panneauPrincipalCarnetEnLigne; |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof Utilisateur) { |
| utilisateur = (Utilisateur) nouvelleDonnees; |
| if ((tentativeConnection) && !utilisateur.isIdentifie()) { |
| panneauAdmin.setVisible(false); |
| formulaireDeConnexionVue.afficherMessageAlerte(); |
| } |
| else { |
| if ((tentativeConnection) && utilisateur.isIdentifie()) { |
| afficherLienAdmin(); |
| formulaireDeConnexionVue.cacher(); |
| } |
| } |
| if(utilisateur.isIdentifie() && !utilisateur.getLicenceAcceptee()) { |
| afficherFenetreAcceptationLicence(); |
| } else { |
| if(tentativeConnection && utilisateur.isIdentifie() && observationMediateur.listeAvoirObservations() && !utilisateur.isAdmin()) { |
| if(Window.confirm("Voulez vous importer vos observations déjà saisies dans votre compte une fois connecté ?")) { |
| observationMediateur.setImporterObservationsAnonymes(true); |
| } |
| } |
| afficheEtatConnexion(); |
| // On lance l'affichage des observations |
| observationMediateur.connecterUtilisateur(); |
| imageMediateur.connecterUtilisateur(); |
| } |
| } |
| if(nouvelleDonnees instanceof String) { |
| String evenement = (String)nouvelleDonnees; |
| if(evenement.equals("licence_acceptee")) { |
| licenceUtilisateurAcceptee = true; |
| accepterLicenceUtilisateur(); |
| } else { |
| if(utilisateur.isIdentifie()) { |
| deconnecterUtilisateur(); |
| return; |
| } |
| } |
| if(observationMediateur.listeAvoirObservations() && !utilisateur.isAdmin()) { |
| if(Window.confirm("Voulez vous importer vos observations déjà saisies dans votre compte une fois connecté ?")) { |
| observationMediateur.setImporterObservationsAnonymes(true); |
| } |
| } |
| afficheEtatConnexion(); |
| observationMediateur.connecterUtilisateur(); |
| imageMediateur.connecterUtilisateur(); |
| fenetreAcceptationLicence.close(); |
| } |
| } |
| private void accepterLicenceUtilisateur() { |
| utilisateur.setLicenceAcceptee(true); |
| carnetEnLigneModele.accepterLicenceUtilisateur(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| } |
| public void afficherListeUtilisateurs() { |
| ListeUtilisateurAdminVue listeUtilisateur = new ListeUtilisateurAdminVue(this) ; |
| listeUtilisateur.show(Ext.get("LienChangerUtilisateur").getDOM()); |
| listeUtilisateur.focusChampUtilisateur(); |
| } |
| public void afficherLienAdmin() { |
| String labelAdmin = "<div id=\"lienAdmin\">Vous consultez les données de "+Utilisateur.getInstance().getLoginUtilisateurConsulte()+" <a id=\"LienChangerUtilisateur\" href=\"#\">Changer d'utilisateur</a></div>" ; |
| panneauAdmin.setHtml(labelAdmin); |
| ExtElement lienChangerUt = Ext.get("LienChangerUtilisateur"); |
| if(lienChangerUt != null) |
| { |
| lienChangerUt.removeAllListeners(); |
| lienChangerUt.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| afficherListeUtilisateurs(); |
| } |
| }); |
| } |
| else |
| { |
| panneauAdmin.addListener(new ContainerListenerAdapter() |
| { |
| @Override |
| public void onAfterLayout(Container c) |
| { |
| ExtElement lienChangerUt = Ext.get("LienChangerUtilisateur"); |
| lienChangerUt.removeAllListeners(); |
| lienChangerUt.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| afficherListeUtilisateurs(); |
| } |
| }); |
| } |
| }); |
| } |
| } |
| public void cacherLienAdmin() { |
| panneauAdmin.hide(); |
| } |
| public void changerIdentite(String idNouvelleIdentite, String loginNouvelleIdentite) { |
| Utilisateur.getInstance().setUtilisateurConsulte(idNouvelleIdentite, loginNouvelleIdentite); |
| afficherLienAdmin(); |
| observationMediateur.connecterUtilisateur(); |
| imageMediateur.connecterUtilisateur(); |
| } |
| public void obtenirListeUtilisateurs(String rech, Rafraichissable r) { |
| carnetEnLigneModele.obtenirListeUtilisateur(r,rech,Utilisateur.getInstance().getIdentifiantUtilisateurConnecte()); |
| } |
| public void donneesImagesVersObs(Object o) { |
| observationMediateur.donneesExterieures(o); |
| } |
| public void donneesObsVersImages(Object o) { |
| imageMediateur.donneesExterieures(o); |
| } |
| public void obtenirListeObservations(Rafraichissable r) { |
| observationMediateur.obtenirCacheObservation(r) ; |
| } |
| public static native void fireResize() /*-{ |
| $wnd.Ext.EventManager.fireResize(); |
| }-*/; |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/i18n/I18n.java |
|---|
| New file |
| 0,0 → 1,19 |
| package org.tela_botanica.client.i18n; |
| import com.google.gwt.core.client.GWT; |
| public class I18n { |
| public I18n() { |
| } |
| public static VocabulaireMetadonnees getVocabulaireMetadonnees() { |
| return (VocabulaireMetadonnees) GWT.create(VocabulaireMetadonnees.class); |
| } |
| public static Messages getMessages() { |
| return (Messages) GWT.create(Messages.class); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/i18n/VocabulaireMetadonnees.java |
|---|
| New file |
| 0,0 → 1,23 |
| package org.tela_botanica.client.i18n; |
| import com.google.gwt.i18n.client.Dictionary; |
| /** |
| * Interface to represent the constants contained in resource bundle: |
| * '/home/aurelien/web/cel_GWT2/src/org/tela_botanica/client/i18n/VocabulaireMetadonnees.properties'. |
| */ |
| public class VocabulaireMetadonnees { |
| private static Dictionary traductionMetadonnees = Dictionary.getDictionary("traductionMetadonnees"); |
| public static String getTraduction(String terme) { |
| String traduction = null; |
| terme = terme.toLowerCase(); |
| terme = terme.replaceAll("-", ""); |
| terme = terme.replaceAll(" ", ""); |
| if(traductionMetadonnees.keySet().contains(terme)) { |
| traduction = traductionMetadonnees.get(terme); |
| } |
| return traduction != null ? traduction : terme; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/i18n/Messages.java |
|---|
| New file |
| 0,0 → 1,9 |
| package org.tela_botanica.client.i18n; |
| /** |
| * Interface to represent the constants contained in resource bundle: |
| * '/home/aurelien/web/cel_GWT2/src/org/tela_botanica/client/i18n/Messages.properties'. |
| */ |
| public interface Messages extends com.google.gwt.i18n.client.Constants { |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/image/ImageMediateur.java |
|---|
| New file |
| 0,0 → 1,1823 |
| package org.tela_botanica.client.image; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.IdVue; |
| 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.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.vues.image.BarreOutilsVue; |
| import org.tela_botanica.client.vues.image.FenetreGestionMotsCles; |
| import org.tela_botanica.client.vues.image.GalerieImageVue; |
| import org.tela_botanica.client.vues.image.ListeImageVue; |
| import org.tela_botanica.client.vues.image.MenuImageVue; |
| import org.tela_botanica.client.vues.image.MiniListeObservationVue; |
| import org.tela_botanica.client.vues.image.PanneauMetadonneesVue; |
| import org.tela_botanica.client.vues.image.ZoomImageVue; |
| import org.tela_botanica.client.vues.image.filtres.BarreRechercheFiltreVue; |
| import org.tela_botanica.client.vues.image.filtres.PanneauFiltresImagesVues; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Element; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| 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.data.Record; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.DataView; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.TabPanel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.event.WindowListenerAdapter; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| 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; |
| import com.gwtext.client.widgets.tree.TreeEditor; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| /** |
| * Mediateur gérant les interactions entre vues et les echanges de données C'est |
| * un singleton. |
| * |
| * @author aurelien |
| * |
| */ |
| // TODO : Deporter les methodes de ListePaginable dans la liste d'images |
| public class ImageMediateur implements ListePaginable{ |
| /** |
| * le mediateur des observations qui lie la partie images au carnet |
| */ |
| private CarnetEnLigneMediateur cMediateur = null; |
| private static ImageMediateur thisMediateur = null ; |
| /** |
| * booleen qui verifie l'unicite de l'instance (donc static) |
| */ |
| private static boolean estInstancie = false; |
| /** |
| * modele de données |
| */ |
| private ImageModele iModele = null; |
| /** |
| * L'identifiant utilisateur. Par défaut, il vaut 0 |
| */ |
| private String identifiant = "0"; |
| /** |
| * panneau principal des images (onglet "images") |
| */ |
| private Panel panneauPrincipalImage = null ; |
| /** |
| * panneau a onglet pour la liste, la galerie et la vue en grand |
| */ |
| private TabPanel ongletsImage = null; |
| /** |
| * panneau de filtrage |
| */ |
| private PanneauFiltresImagesVues filtres = null; |
| /** |
| * conteneur du panneau a onglets |
| */ |
| private Panel panneauMenuEtOngletsImage = null; |
| /** |
| * galerie de miniature |
| */ |
| private GalerieImageVue galerieImage = null; |
| /** |
| * liste détaillée des images |
| */ |
| private ListeImageVue listeImage = null; |
| /** |
| * vue agrandie de la l'image selectionnée |
| */ |
| private ZoomImageVue zoomImage = null; |
| /** |
| * panneau a onglets affichant les métadonnées et les mots clés |
| */ |
| private PanneauMetadonneesVue metadonneesIptcExif = null; |
| /** |
| * panneau conteneur pour le panneau a onglet des metadonnées |
| */ |
| private final Panel detailsEtMotsCles = new Panel("Détails et mots clés"); |
| /** |
| * menu contextuel de manipulation des images |
| */ |
| private MenuImageVue menuImageVue = null; |
| /** |
| * barre d'outils |
| */ |
| private BarreOutilsVue barreOutilsVue = null; |
| /** |
| * l'indice du dernier onglet sélectionné |
| */ |
| private int dernierIndexOnglet = 0; |
| /** |
| * booleen explicitant s'il y a une selection en cours |
| */ |
| private boolean selection = false; |
| /** |
| * Filtre pour les commentaires |
| */ |
| private BarreRechercheFiltreVue filtreCommentaires = null; |
| /** |
| * Fenetre modale de gestion des mots clés |
| */ |
| private FenetreGestionMotsCles fnMc = null; |
| /** |
| * Boolean indiquand si le médiateur a seulement été crée ou bien si tous |
| * les composants ont été crées |
| */ |
| private boolean estInitialise = false; |
| /** |
| * constructeur privé (on accède a la classe par la méthode getInstance) |
| */ |
| private ImageMediateur() { |
| initialiser() ; |
| } |
| /** |
| * constructeur avec paramètres privé (on accède a la classe par la méthode |
| * getInstance) |
| * |
| * @param cm |
| * le médiateur du carnet à associer à la partie image |
| */ |
| private ImageMediateur(CarnetEnLigneMediateur cm) { |
| cMediateur = cm; |
| panneauPrincipalImage = new Panel("Images") ; |
| panneauPrincipalImage.addListener(new PanelListenerAdapter() { |
| @Override |
| public boolean doBeforeRender(Component c) { |
| if(!estInitialise) { |
| initialiser() ; |
| } |
| return true; |
| } |
| }); |
| } |
| /** |
| * Change la valeur du booleen de selection |
| * |
| * @param selection |
| * la nouvelle valeur du booléen |
| */ |
| public void setSelection(boolean selection) { |
| this.selection = selection; |
| } |
| /** |
| * renvoie la valeur du booleen de selection |
| * |
| * @return la valeur du booleen de selection |
| */ |
| public boolean isSelection() { |
| return selection; |
| } |
| /** |
| * Retourne une instance de manière unique |
| * |
| * @return l'instance unique du médiateur |
| */ |
| public static ImageMediateur Instance() { |
| if (!estInstancie && thisMediateur == null) { |
| // on en crée un nouveau |
| estInstancie = true; |
| thisMediateur = new ImageMediateur(); |
| } |
| // sinon on retourne le "pointeur" vers le médiateur lui-même |
| return thisMediateur; |
| } |
| /** |
| * Retourne une instance de manière unique en lui associant un médiateur |
| * pour les observations |
| * |
| * @param cm le médiateur de carnet à associer |
| * @return l'instance unique du médiateur |
| */ |
| public static ImageMediateur Instance(CarnetEnLigneMediateur cm) { |
| if (!estInstancie && thisMediateur == null) { |
| // on en crée un nouveau |
| estInstancie = true; |
| thisMediateur = new ImageMediateur(cm); |
| } |
| // sinon on retourne le "pointeur" vers le médiateur lui-même |
| return thisMediateur; |
| } |
| private void initialiser() |
| { |
| // quelques variables de position pour les borderlayouts |
| final BorderLayoutData regionNord = new BorderLayoutData( |
| RegionPosition.NORTH); |
| final BorderLayoutData regionCentre = new BorderLayoutData( |
| RegionPosition.CENTER); |
| final BorderLayoutData regionEst = new BorderLayoutData( |
| RegionPosition.EAST); |
| regionEst.setSplit(true); |
| final BorderLayoutData regionOuest = new BorderLayoutData( |
| RegionPosition.WEST); |
| regionOuest.setSplit(true); |
| panneauPrincipalImage.setSize(cMediateur.getPanneauPrincipalCarnetEnLigne().getWidth(), cMediateur.getPanneauPrincipalCarnetEnLigne().getHeight()) ; |
| panneauPrincipalImage.setLayout(new BorderLayout()) ; |
| // on crée un modèle |
| iModele = ImageModele.Instance(this); |
| // on gère la mise en page du panneau principal |
| // on crée le panneau des filtres |
| filtres = new PanneauFiltresImagesVues(this); |
| filtres.setWidth("15%"); |
| // le panneau à onglet qui contient les trois vues |
| ongletsImage = new TabPanel(); |
| // la galerie |
| galerieImage = new GalerieImageVue(this); |
| // la liste des images |
| listeImage = new ListeImageVue(this); |
| listeImage.setTitle("Liste") ; |
| // le panneau zoom |
| zoomImage = new ZoomImageVue(this); |
| // on ajoute les panneaux au panneau à onglets |
| ongletsImage.add(galerieImage); |
| ongletsImage.add(listeImage); |
| ongletsImage.add(zoomImage); |
| // on crée les menu et la barre de vue |
| menuImageVue = new MenuImageVue(this); |
| barreOutilsVue = new BarreOutilsVue(this); |
| // on initialise le volet qui contient les mots clés |
| detailsEtMotsCles.setWidth("15%"); |
| detailsEtMotsCles.setAnimCollapse(true); |
| detailsEtMotsCles.setTitleCollapse(true); |
| detailsEtMotsCles.setCollapsible(true); |
| // on crée le panneau conteneur des métadonnées et infos |
| metadonneesIptcExif = new PanneauMetadonneesVue(this); |
| // et on l'inclut dans le volet approprié |
| detailsEtMotsCles.add(metadonneesIptcExif); |
| panneauMenuEtOngletsImage = new Panel() ; |
| panneauMenuEtOngletsImage.setLayout(new BorderLayout()) ; |
| // on ajoute la barre de vue au nord du panneau qui contient menu et |
| // onglets d'images |
| panneauMenuEtOngletsImage.add(barreOutilsVue, regionNord); |
| // les onglets au centre |
| panneauMenuEtOngletsImage.add(ongletsImage, regionCentre); |
| // et le panneau de métadonnées et d'info sur le coté droit |
| panneauPrincipalImage.add(detailsEtMotsCles, regionEst); |
| // on ajoute le panneau qui contient le menu et les onglets d'images au |
| // centre |
| panneauPrincipalImage.add(panneauMenuEtOngletsImage, regionCentre); |
| // on ajoute les filtres au panneau gauche |
| panneauPrincipalImage.add(filtres,regionOuest) ; |
| detailsEtMotsCles.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component,int adjWidth,int adjHeight,int rawWidth,int rawHeight) |
| { |
| if(detailsEtMotsCles != null && detailsEtMotsCles.isRendered() && metadonneesIptcExif != null && metadonneesIptcExif.isRendered()) { |
| metadonneesIptcExif.doLayout(); |
| } |
| } |
| }); |
| creerPanneauGestionMotsCles(); |
| // filtres.setCollapsed(false) ; |
| thisMediateur = this ; |
| estInitialise = true ; |
| changerUtilisateur() ; |
| } |
| /** |
| * Renvoie l'identifiant de l'utilisateur en cours |
| * |
| * @return l'identifiant de l'utilisateur |
| */ |
| public String getIdentifiant() { |
| return cMediateur.getUtilisateur().getIdentifiantUtilisateurConsulte(); |
| } |
| /** |
| * . Setteur pour l'identifiant de l'utilisateur en cours |
| * |
| * @param id |
| * le nouvel identifiant utilisateur |
| */ |
| public void setIdentifiant(String id) { |
| identifiant = id; |
| } |
| /** |
| * Appelle les fonctions de chargement de données, suit généralement un |
| * appel à setIdentifiant, pour obtenir l'arbre des mots clés et les images |
| * du nouvel utilisateur |
| */ |
| public void changerUtilisateur() { |
| getIModele().initialiserArbreMotsCles(); |
| obtenirPhotoGalerie(getGalerieImage()); |
| } |
| /** |
| * Accesseur pour le modèle associé au médiateur |
| * |
| * @return le modèle associé |
| */ |
| public ImageModele getIModele() { |
| return iModele; |
| } |
| /** |
| * Accesseur pour le panneau principal |
| * |
| * @return le panneau principal |
| */ |
| public Panel getPanneauPrincipalImage() { |
| return panneauPrincipalImage; |
| } |
| /** |
| * Accesseur pour le panneau à onglets |
| * |
| * @return le panneau à onglets |
| */ |
| public TabPanel getOngletsImage() { |
| return ongletsImage; |
| } |
| /** |
| * Accesseur pour la galerie d'images |
| * |
| * @return la galerie d'image |
| */ |
| public GalerieImageVue getGalerieImage() { |
| return galerieImage; |
| } |
| public ListeImageVue getListeImage() { |
| return listeImage; |
| } |
| /** |
| * Accesseur pour le panneau "zoom" |
| * |
| * @return le panneau zoom |
| */ |
| public ZoomImageVue getZoomImage() { |
| return zoomImage; |
| } |
| /** |
| * Accesseur pour le panneau détails et mot clés |
| * |
| * @return le panneau détails et mots clés |
| */ |
| public Panel getDetailsEtMotsCles() { |
| return detailsEtMotsCles; |
| } |
| /** |
| * Accesseur pour le booleen d'instanciation |
| * |
| * @return le booleen d'instanciation |
| */ |
| public static boolean isEstInstancie() { |
| return estInstancie; |
| } |
| /** |
| * Accesseur pour la panneau contenant le menu et les onglets images |
| * |
| * @return le panneauMenuEtOngletsImage |
| */ |
| public Panel getPanneauMenuEtOngletsImage() { |
| return panneauMenuEtOngletsImage; |
| } |
| /** |
| * Accesseur pour le menu image |
| * |
| * @return the menuImageVue |
| */ |
| public MenuImageVue getMenuImageVue() { |
| return menuImageVue; |
| } |
| /** |
| * Accesseur pour la barre d'outils |
| * |
| * @return the barreOutilsVue |
| */ |
| public BarreOutilsVue getBarreOutilsVue() { |
| return barreOutilsVue; |
| } |
| /** |
| * Accesseur pour le panneau infos et métadonnées |
| * |
| * @return the metadonneesIptcExif |
| */ |
| public PanneauMetadonneesVue getMetadonneesIptcExif() { |
| return metadonneesIptcExif; |
| } |
| /** |
| * Renvoie l'index du dernier onglet sélectionné |
| * |
| * @return l'index du dernier onglet |
| */ |
| public int getDernierIndexOnglet() { |
| return dernierIndexOnglet; |
| } |
| /** |
| * Accesseur pour la barre de recherche |
| * |
| * @return la barre de recherche pour filtrer les commentaires |
| */ |
| public BarreRechercheFiltreVue getFiltreCommentaires() { |
| return filtreCommentaires; |
| } |
| /** |
| * Renvoie la vue sélectionné par l'utilisateur |
| * |
| * @return la vue selectionnée par l'utilisateur |
| */ |
| public VueListable getVueSelectionnee() { |
| Panel active = ongletsImage.getActiveTab(); |
| if (active != zoomImage) { |
| if (active == galerieImage) { |
| return galerieImage; |
| } else { |
| return listeImage; |
| } |
| } else { |
| if (dernierIndexOnglet == 0) { |
| return galerieImage; |
| } else { |
| return listeImage; |
| } |
| } |
| } |
| /** |
| * Renvoie l'identifiant de la vue en cours |
| * |
| * @return l'identifiant de la vue en cours de visualisation |
| */ |
| public String getIdVueSelectionnee() { |
| Panel active = ongletsImage.getActiveTab(); |
| if (active != zoomImage) { |
| if (active == galerieImage) { |
| return galerieImage.getId(); |
| } else { |
| return listeImage.getId(); |
| } |
| } else { |
| if (dernierIndexOnglet == 0) { |
| return galerieImage.getId(); |
| } else { |
| return listeImage.getId(); |
| } |
| } |
| } |
| /** |
| * Met a jour les données provenant du modèle et synchronise les vues entre |
| * elles |
| * |
| * @param o |
| * données de mises a jour pour les vues |
| * @param r |
| * le refraichissable qui a demandé la mise a jour |
| */ |
| public void synchroniserDonneesZoomListeGalerie(Object o, Rafraichissable r) { |
| if (o instanceof Store) { |
| Store li = (Store) o; |
| if (li.getCount() <= 0) { |
| aucuneSelection(); |
| if (ongletsImage.getActiveTab().getId() == getZoomImage().getId()) { |
| ongletsImage.activate(0); |
| } |
| } else { |
| selection(); |
| } |
| if (r != getGalerieImage()) { |
| getGalerieImage().rafraichir(o, false); |
| } |
| if (r != getZoomImage()) { |
| getZoomImage().rafraichir(o, false); |
| } |
| if (r != getListeImage()) { |
| getListeImage().rafraichir(o, false); |
| } |
| demasquerChargement(); |
| } |
| } |
| public void obtenirPhotoGalerie() { |
| obtenirPhotoGalerie(getGalerieImage()); |
| } |
| /** |
| * envoie au modèle une demande de mise a jour |
| * |
| * @param r |
| * la vue demandeuse de mise a jour |
| */ |
| public void obtenirPhotoGalerie(Rafraichissable r) { |
| masquerChargement(); |
| getIModele().obtenirNombrePhotoGalerie(r); |
| } |
| /** |
| * demande au modèle les métadonnées associées a une image |
| * |
| * @param r |
| * la vue demandeuse de mise a jour |
| * @param id |
| * l'identifiant de l'image |
| */ |
| public void obtenirMetadonnees(Rafraichissable r, String id) { |
| getIModele().obtenirMetadonnees(r, id); |
| } |
| /** |
| * demande au modèle les ids des mots clés associés a une image |
| * |
| * @param r |
| * la vue demandeuse de mise a jour |
| * @param id |
| * l'identifiant de l'image |
| */ |
| public void obtenirMotsClesId(Rafraichissable r, String id) { |
| getIModele().obtenirMotsClesId(r, id); |
| } |
| public void obtenirMotsClesTexte(Rafraichissable r, String id) { |
| String[] texteMotsCles = getTexteMotsCles(getIModele().getMotsClesId(id)); |
| r.rafraichir(texteMotsCles, false); |
| } |
| //TODO: devrait être dans le modèle |
| public String[] getTexteMotsCles(String idsMotsCles[]) { |
| String[] tableauMotsClesTexte = new String[idsMotsCles.length]; |
| for(int i=0; i< idsMotsCles.length; i++) { |
| tableauMotsClesTexte[i] = iModele.obtenirTexteMotCle(idsMotsCles[i]); |
| } |
| return tableauMotsClesTexte; |
| } |
| /** |
| * Envoie au modèle une demande pour obtenir l'arbre des mots clés |
| * |
| * @param r |
| * le raffraichissable qui a demandé la mise à jour |
| */ |
| public void obtenirArbreMotsCles(Rafraichissable r) { |
| getIModele().initialiserArbreMotsCles(); |
| } |
| /** |
| * envoie au modèle une demande de mise a jour des informations modifiables |
| * associées a une image |
| * |
| * @param commentaires |
| * le commentaire de l'image |
| * @param date |
| * la date modifiée par l'utilisateur |
| */ |
| public void mettreAJourInfo(String commentaires, String date, String note) { |
| String ids[] = getVueSelectionnee().getIdSelectionnees(); |
| getIModele().mettreAJourCacheImage(commentaires, date, note, ids); |
| getListeImage().mettreAjourInfos(commentaires, date, note); |
| } |
| /** |
| * Met à jour l'arbre des mots clés affichés dans le volet de droite à |
| * partir de l'arbre passé en paramètre |
| * |
| * @param arbreMC |
| * le nouvel arbre des mots clés |
| */ |
| public void rafraichirArbreMotsCles(Tree arbreMC) { |
| metadonneesIptcExif.getPanneauMotsCles().rafraichir(arbreMC, false); |
| filtres.getMotsClesFiltre().rafraichir(arbreMC, false); |
| if(fnMc != null) { |
| fnMc.rafraichir(arbreMC, false); |
| } |
| } |
| /** |
| * envoie au modèle une demande pour lancer le formulaire ou l'application |
| * d'upload |
| */ |
| public void uploaderImages(boolean multiple) { |
| if(cMediateur.getUtilisateur().isIdentifie()) { |
| getIModele().uploaderImages(multiple); |
| } |
| else |
| { |
| if(Window.confirm("L'envoi d'images nécéssite d'être identifié. Voulez-vous vous identifier maintenant ?")) { |
| cMediateur.afficherDialogueConnexion(); |
| } |
| else |
| { |
| } |
| } |
| } |
| /** |
| * Envoie une demande au modèle pour obtenir toutes les données annexes de |
| * l'image (métadonnées, note, etc ...), on y centralise tous les appels a |
| * obtenirQuelqueChose |
| * |
| * @param imgNum |
| * l'identifiant de l'image |
| */ |
| public void obtenirDonnes(String imgNum) { |
| if(metadonneesIptcExif.isVisible()) { |
| if(imgNum == null) { |
| return; |
| } |
| // si on est en mode liaison, on demande la liste des obs |
| if(getMetadonneesIptcExif().getMiniListeObservation().getMode()) |
| { |
| obtenirObservationsAssociees() ; |
| } |
| obtenirMetadonnees(metadonneesIptcExif, imgNum); |
| obtenirMotsClesId(fnMc, imgNum); |
| obtenirMotsClesTexte(metadonneesIptcExif.getPanneauMotsCles(), imgNum); |
| obtenirNote(metadonneesIptcExif.getNoteVue(), imgNum); |
| } |
| } |
| public void changerModeLiaison(boolean mode) { |
| if(mode) { |
| obtenirObservationsAssociees() ; |
| metadonneesIptcExif.getRechercheFiltreTaxonVue().disable(); |
| } |
| else { |
| obtenirNombreMiniListeObservations() ; |
| metadonneesIptcExif.getRechercheFiltreTaxonVue().enable(); |
| } |
| } |
| /** |
| * Envoie une demande au modèle pour obtenir la note associée à une image |
| * |
| * @param noteVue |
| * le rafraichissable à qui est destiné cette information |
| * @param imgNum |
| * l'identifiant de l'image |
| */ |
| private void obtenirNote(Rafraichissable r, String imgNum) { |
| getIModele().obtenirNote(r, imgNum); |
| } |
| /** |
| * est appelé lors d'un clic de souris sur une vignette dans la galerie le |
| * médiateur gère alors les conséquences |
| * |
| * @param index |
| * l'index du noeud dans la galerie |
| * @param node |
| * le noeud selectionné |
| * @param e |
| * l'object source de l'évenement |
| */ |
| public void clicGalerieImage(int index, Element node, EventObject e) { |
| Record rd = getGalerieImage().getDView().getRecord(node); |
| String imgUrl = rd.getAsString("url_image"); |
| String imgNum = rd.getAsString("num_image"); |
| String imgTaxon = rd.getAsString("obs_associees"); |
| String[] imgXY = getIModele().obtenirTailleImage( |
| rd.getAsString("num_image")); |
| String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum, imgTaxon}; |
| getZoomImage().rafraichir(infosImage, false); |
| dernierIndexOnglet = 0; |
| if (DOM.eventGetType(e.getBrowserEvent()) == Event.ONDBLCLICK) { |
| getOngletsImage().setActiveTab(2); |
| } |
| obtenirDonnes(imgNum); |
| } |
| /** |
| * est appelé lors d'un clic de souris sur un enregistrement de la liste le |
| * médiateur gère alors les conséquences |
| * |
| * @param rowIndex |
| * le numéro de ligne selectionné |
| */ |
| public void clicListeImage(int rowIndex) { |
| Record rd = getListeImage().getSelectionModel().getSelected(); |
| String imgUrl = rd.getAsString("url_image"); |
| String imgNum = rd.getAsString("num_image"); |
| String imgTaxon = rd.getAsString("obs_associees"); |
| String[] imgXY = getIModele().obtenirTailleImage( |
| rd.getAsString("num_image")); |
| String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum, imgTaxon }; |
| getZoomImage().rafraichir(infosImage, false); |
| dernierIndexOnglet = 1; |
| obtenirDonnes(imgNum); |
| } |
| /** |
| * gestion du double clic dans la liste |
| * |
| * @param rowIndex |
| */ |
| public void doubleClicListeImage(int rowIndex) { |
| getOngletsImage().setActiveTab(2); |
| } |
| /** |
| * envoie une demande de mise a jour des données au modèle |
| */ |
| public void rafraichirToutesVues() { |
| obtenirPhotoGalerie(getIModele()); |
| } |
| /** |
| * montre le menu au coordonnées indiquées |
| * |
| * @param e |
| * l'objet source de l'évenement |
| */ |
| public void montrerContextMenu(EventObject e) { |
| menuImageVue.showAt(e.getXY()); |
| } |
| /** |
| * montre le menu au coordonnées indiquées |
| * |
| * @param e |
| * l'objet source de l'évenement |
| */ |
| public void montrerContextMenu(int[] XY) { |
| menuImageVue.showAt(XY); |
| } |
| /** |
| * appelé lors du double clic sur l'image agrandie |
| */ |
| public void doubleClicZoomImage() { |
| getOngletsImage().setActiveTab(dernierIndexOnglet); |
| } |
| /** |
| * appelé lors du clic sur un des boutons de la zone zoom |
| * |
| * @param arg |
| * le nom du bouton qui a cliqué |
| */ |
| public void clicBoutonZoomImage(String arg) { |
| Store st; |
| int selected; |
| int storeIndex; |
| Record nRec = null; |
| // tout d'abord on obtient les index selectionnés suivant la vue |
| if (getVueSelectionnee() == galerieImage) { |
| DataView dv = getGalerieImage().getDView(); |
| st = getGalerieImage().getSt(); |
| if (st.getCount() <= 0) { |
| return; |
| } |
| selected = st.indexOf(dv.getSelectedRecords()[0]); |
| storeIndex = dv.indexOf(selected); |
| } else { |
| st = listeImage.getSt(); |
| if (st.getCount() <= 0) { |
| return; |
| } |
| selected = st.indexOf(listeImage.getSelectionModel().getSelected()); |
| storeIndex = selected; |
| } |
| if (arg.equals("prev")) { |
| // si la photo séléctionnée est la première, on passe a la |
| // dernière |
| if (selected == 0) { |
| storeIndex = st.getCount() - 1; |
| nRec = st.getAt(storeIndex); |
| } else { |
| storeIndex = storeIndex - 1; |
| nRec = st.getAt(storeIndex); |
| } |
| } |
| if (arg.equals("suiv")) { |
| // si la photo selectionnée est la dernière on passe a la |
| // première |
| if (selected == st.getCount() - 1) { |
| storeIndex = 0; |
| nRec = st.getAt(0); |
| } else { |
| storeIndex = storeIndex + 1; |
| nRec = st.getAt(storeIndex); |
| } |
| } |
| if (nRec != null) { |
| String imgUrl = nRec.getAsString("url_image"); |
| String imgNum = nRec.getAsString("num_image"); |
| String[] imgXY = getIModele().obtenirTailleImage( |
| nRec.getAsString("num_image")); |
| String imgTaxon = nRec.getAsString("obs_associees"); |
| String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum, imgTaxon }; |
| getZoomImage().rafraichir(infosImage, false); |
| if (getGalerieImage().isRendered()) { |
| getGalerieImage().getDView().select(storeIndex); |
| } |
| if (getListeImage().isRendered()) { |
| getListeImage().getSelectionModel().selectRecords(nRec); |
| } |
| obtenirDonnes(imgNum); |
| } |
| } |
| /** |
| * synchronise la selection entre la galerie et la liste |
| * |
| * @param string |
| * le nom de la vue qui doit être synchronisee |
| */ |
| public void synchroniserSelection(String string) { |
| if (string.equals("galerie") && getDernierIndexOnglet() != 2) { |
| Record[] sel = getGalerieImage().getDView().getSelectedRecords(); |
| getListeImage().selectionnerEnregistrements(sel); |
| } |
| if (string.equals("liste") && getDernierIndexOnglet() != 0) { |
| Record[] sel = getListeImage().getSelectionModel().getSelections(); |
| int[] ids = new int[sel.length]; |
| for (int i = 0; i < sel.length; i++) { |
| ids[i] = getGalerieImage().getSt().indexOf(sel[i]); |
| } |
| getGalerieImage().selectionnerImages(ids); |
| } |
| } |
| /** |
| * fait une demande de suppression des images (en local et en distant) des |
| * images selectionnees |
| */ |
| public void supprimerImages() { |
| String[] ids = null; |
| if (dernierIndexOnglet == 0) { |
| ids = getGalerieImage().getIdSelectionnees(); |
| } else { |
| ids = getListeImage().getIdSelectionnees(); |
| } |
| if (ids.length > 0) { |
| if (com.google.gwt.user.client.Window |
| .confirm("Supprimer les images selectionnees ?")) { |
| masquerChargement(); |
| getIModele().supprimerImages(ids); |
| aucuneSelection(); |
| } |
| } else { |
| Window.alert("Impossible de supprimer : aucune image selectionnee"); |
| } |
| } |
| /** |
| * desactive les onglets de metadonnees et de zoom (dans le cas ou rien |
| * n'est selectionne) |
| */ |
| public void aucuneSelection() { |
| if (getListeImage().getSelectionModel().getCount() <= 0 |
| && getGalerieImage().getDView().getSelectionCount() <= 0) { |
| getZoomImage().disable(); |
| getMetadonneesIptcExif().desactiverPanneau(); |
| getZoomImage().desactiverPanneau(); |
| setSelection(false); |
| } |
| } |
| /** |
| * reactive les onglet metadonnees et zoom (lors d'une selection alors qu'il |
| * n'y en avait pas) |
| */ |
| public void selection() { |
| if (!isSelection()) { |
| getMetadonneesIptcExif().activerPanneau(); |
| getZoomImage().activerPanneau(); |
| getZoomImage().enable(); |
| setSelection(true); |
| } |
| } |
| /** |
| * Fait apparaitre le menu contextuel de l'arbre des mots clés au niveau |
| * d'un noeud donné |
| * |
| * @param n |
| * le noeud ou le menu doit apparaitre |
| * @param ev |
| * l'objet contenant les données sur l'évenement |
| * @param te |
| * l'éditeur associé à l'arbre qui permet de modifier les |
| * libellés des noeuds |
| */ |
| public void montrerContextMenuArbre(final TreeNode n, EventObject ev, |
| final TreeEditor te) { |
| Menu mn = new Menu(); |
| final com.gwtext.client.widgets.menu.Item ajoutN = new Item( |
| "Ajouter mot cle"); |
| final com.gwtext.client.widgets.menu.Item renommerN = new Item( |
| "Renommer mot cle"); |
| final com.gwtext.client.widgets.menu.Item suppN = new Item( |
| "Supprimer mot cle"); |
| mn.addItem(ajoutN); |
| mn.addItem(renommerN); |
| mn.addItem(suppN); |
| mn.addListener(new MenuListenerAdapter() { |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| if (item.equals(suppN)) { |
| fnMc.supprimerNoeud(n); |
| } |
| if (item.equals(renommerN)) { |
| fnMc.renommerNoeud(n); |
| } |
| if (item.equals(ajoutN)) { |
| fnMc.ajouterNoeud( |
| n); |
| } |
| } |
| }); |
| mn.showAt(ev.getXY()); |
| } |
| /** |
| * Appelle le modèle pour mettre à jour la paire mot-clé / identifiant du |
| * mot clé |
| * |
| * @param text |
| * le texte du mot clé |
| * @param id |
| * l'identifiant du mot clé |
| */ |
| public void mettreAjourMotsClesId(String text, String id) { |
| getIModele().mettreAjourMotsClesId(text, id); |
| } |
| /** |
| * Récupère les identifiants des images selectionnés et appelle le modèle |
| * pour qu'il mette à jour les associations mots clés/images |
| * |
| * @param motsClesEnCours |
| * les mots clés à associer aux images selectionnés séparés par |
| * une ',' |
| * @param arbreMC |
| * l'arbre des mots clés à mettre à jour |
| */ |
| public void mettreAjourMotsCles(String motsClesEnCours, Tree arbreMC) { |
| String[] ids = getGalerieImage().getIdSelectionnees(); |
| if(ids.length > 0) { |
| getIModele().mettreAjourMotsCles(ids, motsClesEnCours, arbreMC); |
| obtenirMotsClesTexte(metadonneesIptcExif.getPanneauMotsCles(), ids[ids.length - 1]); |
| } |
| } |
| /** |
| * Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots |
| * clés |
| * |
| * @param n |
| * le noeud à ajouter à l'arbre |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| getIModele().ajouterMotCleDansArbre(n, arbreMC); |
| filtres.getMotsClesFiltre().rafraichir(arbreMC, false); |
| mettreAJourListeMotsClesAffiches(); |
| } |
| /** |
| * Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre |
| * dans l'arbre des mots clés |
| * |
| * @param n |
| * le noeud à supprimer |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| getIModele().supprimerMotCleDansArbre(n, arbreMC); |
| filtres.getMotsClesFiltre().rafraichir(arbreMC, false); |
| mettreAJourListeMotsClesAffiches(); |
| } |
| /** |
| * Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots |
| * clés |
| * |
| * @param n |
| * le noeud à modifier |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| getIModele().modifierMotCleDansArbre(n, arbreMC); |
| getIModele().mettreAjourMotsClesId(n.getText(), n.getId()); |
| filtres.getMotsClesFiltre().rafraichir(arbreMC, false); |
| mettreAJourListeMotsClesAffiches(); |
| } |
| /** |
| * Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans |
| * l'arbre des mots clés |
| * |
| * @param n |
| * le noeud à déplacer |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| getIModele().deplacerMotCleDansArbre(n, arbreMC); |
| filtres.getMotsClesFiltre().rafraichir(arbreMC, false); |
| mettreAJourListeMotsClesAffiches(); |
| } |
| public void mettreAJourListeMotsClesAffiches() { |
| String[] ids = getGalerieImage().getIdSelectionnees(); |
| if(ids.length > 0) { |
| obtenirMotsClesTexte(metadonneesIptcExif.getPanneauMotsCles(), ids[ids.length - 1]); |
| } |
| } |
| /** |
| * initialise les mots clés cochés par rapport aux images sélectionnées |
| */ |
| public void initialiserMotsCleCoches() { |
| obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(),getGalerieImage().getIdSelectionnees()[0]); |
| } |
| /** |
| * Appelle le modèle pour lui demander les données d'une page à afficher |
| * |
| * @param pageCourante |
| * le numéro de page à affciher |
| */ |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| // on met le mesage d'attente |
| masquerChargement(); |
| // on appelle le modèle |
| getIModele().changerNumeroPage(pageCourante); |
| // et met à jour les numéros de page dans les barre d'outils |
| getGalerieImage().getToolBarVue().changerPageCourante(pageCourante); |
| getListeImage().getToolBarVue().changerPageCourante(pageCourante); |
| } |
| /** |
| * Appelle le modèle pour qu'il change la taille de page utilisée |
| * |
| * @param nouvelleTaillePage |
| * la nouvelle taille de page |
| */ |
| @Override |
| public void changerTaillePage(int nouvelleTaillePage) { |
| // on met le message d'attente |
| masquerChargement(); |
| // on appelle le modèle |
| getIModele().changerTaillePage(nouvelleTaillePage); |
| // et on met à jour la taille de page dans les barres d'outils |
| getGalerieImage().getToolBarVue().selectionnerTaillePage( |
| nouvelleTaillePage); |
| getListeImage().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 }; |
| getGalerieImage().getToolBarVue().rafraichir(pages, false); |
| getListeImage().getToolBarVue().rafraichir(pages, false); |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de |
| * chargement |
| */ |
| public void masquerChargement() { |
| if(GWT.isScript()) { |
| ExtElement masked = Ext.get(getIdVueSelectionnee()); |
| if (masked != null && !masked.isMasked()) { |
| masked.mask("Chargement", true); |
| } |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de |
| * chargement si l'était affiché |
| */ |
| public void demasquerChargement() { |
| if(GWT.isScript()) { |
| ExtElement masked = Ext.get(getIdVueSelectionnee()); |
| if (masked != null && masked.isMasked()) { |
| masked.unmask(); |
| } |
| } |
| } |
| public void afficherMenuId() { |
| IdVue i = new IdVue(this); |
| i.show(); |
| } |
| /** |
| * C'est dans cette fonction que doivent être renvoyé les valeurs des |
| * filtres sous forme de tableau [nom, valeur] |
| * |
| * @return Les noms et valeurs des filtres |
| */ |
| public String[][] renvoyerFiltres() { |
| String[][] valeursFiltres = filtres.renvoyerValeursAFiltrer(); |
| barreOutilsVue.setFiltresEnCours(valeursFiltres); |
| return valeursFiltres; |
| } |
| /** |
| * Indique si les filtres ont changés depuis la dernière requête (il faut |
| * faire un OR sur le résultat de toutes les fonctions renvoyerEtatFiltre |
| * s'il y a plus d'un filtre) |
| * |
| * @return true si au moins un des filtres a changé, false sinon |
| */ |
| public boolean getEtatFiltres() { |
| return (filtres.renvoyerEtatFiltre()); |
| } |
| /** |
| * Accesseur pour le panneau de droite contenant les filtres |
| * |
| * @return le panneau contenant les filtres |
| */ |
| public PanneauFiltresImagesVues getPanneauFiltres() { |
| return filtres; |
| } |
| /** |
| * Réinitialise tous les filtres en cours |
| * |
| */ |
| public void viderFiltres() { |
| filtres.viderFiltres(); |
| obtenirPhotoGalerie(); |
| } |
| /** |
| * Réinitialise un filtre en cours suivant le nom donné |
| * |
| * @param String le nom du filtre |
| */ |
| public void viderFiltre(String nom) { |
| filtres.viderFiltre(nom); |
| obtenirPhotoGalerie(); |
| } |
| /** |
| * ajoute les images séléctionnées dans la vue courante au tampon |
| */ |
| public void ajouterImagesSelection() { |
| String[] ids = getVueSelectionnee().getIdSelectionnees(); |
| String id = ""; |
| for (int i = 0; i < ids.length; i++) { |
| id += " - " + ids[i]; |
| } |
| getIModele().ajouterImagesSelection(ids); |
| Window.alert(ids.length + " image(s) ajoutées au tampon "); |
| } |
| /** |
| * Affiche les ids des images contenues dans le tampon |
| */ |
| public void afficherIdSelectionImages() { |
| Window.alert("Contenu du tampon : " + getIModele().renvoyerSelection()); |
| } |
| /** |
| * Renvoie les ids des images contenues dans le tampon en une seule string |
| * @return une string de la forme id1, id2, id3 |
| */ |
| public String renvoyerSelection() { |
| return getIModele().renvoyerSelection(); |
| } |
| /** |
| * Vide le tampon d'images |
| */ |
| public void viderSelection() { |
| getIModele().viderSelection(); |
| Window.alert("Le tampon a été vidé "); |
| } |
| public int getCompteSelection() { |
| return getIModele().getCompteSelection(); |
| } |
| /** |
| * Fonction appelée lors du drag 'n drop d'une image sur une observation |
| * @param source la source du drag |
| * @param e l'objet sur lequel on a fait le drop |
| * @param data les données |
| * @return une booleen indiquant le succès ou l'échec de l'opération |
| */ |
| public boolean lierImagesDD(DragSource source, EventObject e, DragData data) { |
| // on peut convertir directement les données car on a testé avant le type de données |
| GridDragData gdd = (GridDragData)data ; |
| // les ids des images sont initialisées |
| String idsImg = "" ; |
| // on obtient la liste des selections dans la source |
| Record[] aLier = gdd.getSelections() ; |
| for (int i = 0; i < aLier.length; i++) |
| { |
| // on les concatènes en une seule chaine |
| idsImg += aLier[i].getAsString("id_image")+"," ; |
| } |
| MiniListeObservationVue mv = getMetadonneesIptcExif().getMiniListeObservation() ; |
| // on cherche quel est la ligne sur laquelle on a fait le drop dans la la liste des observations |
| int index = mv.getView().findRowIndex(e) ; |
| Record rddrop = mv.getStore().getRecordAt(index) ; |
| // SI l'enregistrement existe bel et bien |
| if(rddrop != null) |
| { |
| String idObss = ""; |
| Record[] selection = mv.getSelectionModel().getSelections(); |
| boolean lierSelection = false; |
| // on itère sur toutes les observations selectionnées |
| for(int i=0; i<selection.length && lierSelection == false; i++) { |
| // si l'element sur lequel on a fait le drop fait partie |
| // de la selection alors on lie tout à la selection |
| if(selection[i].getId() == rddrop.getId()) { |
| lierSelection = true; |
| } |
| // si l'élement ne fait pas partie de la selection |
| //alors on ne lit qu'à celui sur lequel on a fait le drop |
| idObss += selection[i].getAsString("id_obs")+"," ; |
| } |
| String message = ""; |
| if(!lierSelection) { |
| idObss = rddrop.getAsString("id_obs")+","; |
| message = "Lier la selection d'images à l'observation pointée ?"; |
| } else { |
| message = "Lier la selection d'images aux observations selectionnées ?"; |
| } |
| if(Window.confirm(message)) { |
| lierImagesObservation(idObss, idsImg) ; |
| } |
| } |
| return true ; |
| } |
| /** |
| * Fonction appelée lors du drag 'n drop d'une observation sur une image |
| * @param source la source du drag |
| * @param e l'objet sur lequel on a fait le drop |
| * @param data les données |
| * @return une booleen indiquant le succès ou l'échec de l'opération |
| */ |
| public boolean lierObsDD(DragSource source, EventObject e, DragData data, String idDest) { |
| // on peut convertir directement les données car on a testé avant le type de données |
| GridDragData gdd = (GridDragData)data ; |
| // les ids des images sont initialisées |
| String idsObs = "" ; |
| // on obtient la liste des selections dans la source |
| Record[] aLier = gdd.getSelections() ; |
| for (int i = 0; i < aLier.length; i++) |
| { |
| // on les concatènes en une seule chaine |
| idsObs += aLier[i].getAsString("id_obs")+"," ; |
| } |
| Record rddrop = null ; |
| int index = -1; |
| // si la destination est la galerie d'images |
| if(idDest.equals(getGalerieImage().getId())) |
| { |
| GalerieImageVue gv = getGalerieImage() ; |
| // alors l'élément sur lequel on a fait le drop n'est pas le bon |
| index = gv.getDView().indexOf(e.getTarget()) ; |
| Element el = e.getTarget() ; |
| // alors on cherche son parent tant que celui-ci n'est pas présent dans la dataview |
| while(index == -1 && el != null) |
| { |
| index = gv.getDView().indexOf(el) ; |
| el = (Element) el.getParentElement() ; |
| } |
| // si on l'a trouvé, on obtient l'enregistrement qui correspond |
| if(index != -1) |
| { |
| rddrop = gv.getSt().getAt(index) ; |
| } |
| } |
| // si la destination est la liste d'images |
| if(idDest.equals(getListeImage().getId())) |
| { |
| // on obtient directement l'enregistrement correspondant à l'élément sur lequel on a fait le drop |
| ListeImageVue lv = getListeImage() ; |
| index = lv.getView().findRowIndex(e) ; |
| rddrop = lv.getSt().getAt(index) ; |
| } |
| // si on a bien obtenu un enregistrement |
| if(rddrop != null) |
| { |
| String idImgs = ""; |
| Record[] selection = galerieImage.getDView().getSelectedRecords(); |
| boolean lierSelection = false; |
| String message = ""; |
| // si l'element sur lequel on a fait le drop fait partie |
| // de la selection alors on lie tout à la selection |
| if(galerieImage.getDView().isSelected(index)) { |
| lierSelection = true; |
| // on itère sur toutes les images selectionnées |
| for(int i=0; i<selection.length; i++) { |
| // et on récupère leur ids |
| idImgs += selection[i].getAsString("id_image")+"," ; |
| } |
| } |
| if(!lierSelection) { |
| idImgs = rddrop.getAsString("id_image")+","; |
| message = "Lier la selection d'observations à l'image pointée ?"; |
| } else { |
| message = "Lier la selection d'observations aux images selectionnées ?"; |
| } |
| if(Window.confirm(message)) { |
| lierImagesObservation(idsObs, idImgs) ; |
| } |
| return true ; |
| } |
| // si la destination est l'image zoomée |
| if(idDest.equals(getZoomImage().getId())) |
| { |
| // on obtient directement l'id correspondant |
| ZoomImageVue zv = getZoomImage() ; |
| String idImg = zv.getIdImage() ; |
| lierImagesObservation(idsObs, idImg) ; |
| return true ; |
| } |
| return false ; |
| } |
| public void LierTamponObservations() { |
| Record[] obsRec = getMetadonneesIptcExif().getMiniListeObservation().getSelectionModel().getSelections() ; |
| String idsObs = "" ; |
| for(int i =0 ; i< obsRec.length ; i++) |
| { |
| idsObs += obsRec[i].getAsString("id_obs")+"," ; |
| } |
| if(getIModele().renvoyerSelection().equals("-255")) |
| { |
| Window.alert("Le tampon est vide") ; |
| return ; |
| } |
| if(obsRec.length == 0) |
| { |
| Window.alert("Aucune(s) observation(s) selectionnée(s)") ; |
| return ; |
| } |
| else |
| { |
| lierImagesObservation(idsObs, getIModele().renvoyerSelection()) ; |
| } |
| } |
| public void LierObservations() { |
| Record[] obsRec = getMetadonneesIptcExif().getMiniListeObservation().getSelectionModel().getSelections() ; |
| String idsObs = "" ; |
| String[] idsImg = getGalerieImage().getIdSelectionnees(); |
| String selectionImages = ""; |
| if(idsImg.length <= 0) |
| { |
| Window.alert("Aucune image selectionnée") ; |
| return ; |
| } else { |
| for (int i = 0; i < idsImg.length; i++) { |
| String idEncours = iModele.obtenirIdPourOrdre(idsImg[i]); |
| selectionImages += idEncours + ","; |
| } |
| } |
| if(obsRec.length == 0) |
| { |
| Window.alert("Aucune(s) observation(s) selectionnée(s)") ; |
| return ; |
| } else { |
| for(int i =0 ; i< obsRec.length ; i++) |
| { |
| idsObs += obsRec[i].getAsString("id_obs")+"," ; |
| } |
| } |
| String message = "Lier la selection d'images aux observations selectionnées ?"; |
| if(Window.confirm(message)) { |
| lierImagesObservation(idsObs, selectionImages) ; |
| } |
| } |
| /** |
| * Lie une ou plusieurs images à une ou plusieurs observations |
| * @param idsObs les identifiants des observations séparés par des "," |
| * @param idsImg les identifiants des images séparés par des "," |
| */ |
| public void lierImagesObservation(String idsObs, String idsImg) |
| { |
| getIModele().lierImagesObervations(idsObs,idsImg) ; |
| } |
| public void deconnecterUtilisateur() { |
| if(panneauPrincipalImage.isVisible()) |
| { |
| setIdentifiant(cMediateur.getUtilisateur().getIdentifiantUtilisateurConnecte()) ; |
| changerUtilisateur() ; |
| } |
| else |
| { |
| panneauPrincipalImage.addListener(new ContainerListenerAdapter() |
| { |
| @Override |
| public void onRender(Component component) |
| { |
| setIdentifiant(cMediateur.getUtilisateur().getIdentifiantUtilisateurConnecte()) ; |
| changerUtilisateur() ; |
| panneauPrincipalImage.purgeListeners() ; |
| } |
| }) ; |
| } |
| } |
| public void connecterUtilisateur() { |
| if(panneauPrincipalImage.isVisible()) { |
| setIdentifiant(cMediateur.getUtilisateur().getIdentifiantUtilisateurConnecte()); |
| getIModele().initialiserArbreMotsCles(); |
| filtres.getArbreDateRecherche().initialiser(); |
| obtenirPhotoGalerie(getGalerieImage()); |
| } |
| else |
| { |
| panneauPrincipalImage.addListener(new ContainerListenerAdapter() |
| { |
| @Override |
| public void onRender(Component c) |
| { |
| setIdentifiant(cMediateur.getUtilisateur().getIdentifiantUtilisateurConnecte()); |
| getIModele().initialiserArbreMotsCles(); |
| filtres.getArbreDateRecherche().initialiser(); |
| obtenirPhotoGalerie(getGalerieImage()); |
| panneauPrincipalImage.purgeListeners() ; |
| } |
| }) ; |
| } |
| } |
| public String[] renvoyerFiltresObservation() { |
| String[] rien = {"nom_taxon",""}; |
| if(getMetadonneesIptcExif() != null) { |
| return getMetadonneesIptcExif().getRechercheFiltreTaxonVue().renvoyerValeursAFiltrer(); |
| } else { |
| return rien; |
| } |
| } |
| public void obtenirNombreMiniListeObservations( |
| Rafraichissable r) { |
| iModele.obtenirNombreMiniListeObservations(r, renvoyerFiltresObservation()); |
| } |
| public void obtenirNombreMiniListeObservations() { |
| iModele.obtenirNombreMiniListeObservations(getMetadonneesIptcExif().getMiniListeObservation(), renvoyerFiltresObservation()); |
| } |
| public void obtenirMiniListeObservations( |
| Rafraichissable r, int taillePage, int numeroPage) { |
| iModele.obtenirMiniListeObservations(r, renvoyerFiltresObservation(), taillePage, numeroPage) ; |
| } |
| public void afficherAide() { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| public void soumettreBugRemarque() { |
| String suiviUrl = Configuration.getSuiviBugUrl() ; |
| Window.open(suiviUrl, "", "") ; |
| } |
| public void obtenirObservationsAssociees() { |
| String ids[] = getVueSelectionnee().getIdSelectionnees() ; |
| if(ids.length > 0) { |
| getMetadonneesIptcExif().getMiniListeObservation().masquerChargement() ; |
| getIModele().obtenirLiaisonObservations(this,ids[0]); |
| } |
| } |
| public void rafraichirMiniListeObservations(ListeObservation listeObs) { |
| if(getMetadonneesIptcExif() != null && getMetadonneesIptcExif().isCreated()) { |
| if(getMetadonneesIptcExif().getMiniListeObservation().isCreated()) |
| { |
| getMetadonneesIptcExif().getMiniListeObservation().rafraichir(listeObs, false) ; |
| } |
| } |
| } |
| public void supprimerLiaisonObsImage() { |
| String idsImg[] = getVueSelectionnee().getIdSelectionnees() ; |
| String idObs = getMetadonneesIptcExif().getMiniListeObservation().getIdSelectionnees() ; |
| if(Window.confirm("Supprimer le lien entre image(s) et observation(s) ?")) |
| { |
| getMetadonneesIptcExif().getMiniListeObservation().supprimerLiaison() ; |
| iModele.supprimerLiaisonImages(idsImg,idObs) ; |
| } |
| } |
| public boolean estInstancie() { |
| return estInstancie ; |
| } |
| public void donneesExterieures(Object o) { |
| if(estInitialise) { |
| iModele.rafraichir(o, true); |
| } |
| } |
| public void obtenirDatesImages(Rafraichissable r) { |
| iModele.obtenirDatesImages(r); |
| } |
| public void creerPanneauGestionMotsCles() { |
| fnMc = new FenetreGestionMotsCles() { |
| @Override |
| protected void surSuppressionMotCle(TreeNode node, Tree arbre) { |
| supprimerMotCleDansArbre(node, arbre); |
| } |
| @Override |
| protected void surDeplacementMotCle(TreeNode node, Tree arbre) { |
| deplacerMotCleDansArbre(node, arbre); |
| } |
| @Override |
| protected void surClicValider(String chaineMotsCles, Tree arbre) { |
| mettreAjourMotsCles(chaineMotsCles, arbre); |
| } |
| @Override |
| protected void surChangementTexte(TreeNode node, Tree arbre) { |
| modifierMotCleDansArbre(node, arbre); |
| } |
| @Override |
| protected void surAjoutMotCle(TreeNode node, Tree arbre) { |
| ajouterMotCleDansArbre(node, arbre); |
| } |
| @Override |
| protected void surAffichageMenuContextuel(TreeNode node, EventObject e, |
| TreeEditor te) { |
| montrerContextMenuArbre(node, e, te); |
| } |
| @Override |
| protected void demanderArbreMotsCles(Rafraichissable r) { |
| ImageMediateur.this.obtenirArbreMotsCles(r); |
| } |
| }; |
| fnMc.setModal(true); |
| fnMc.setHeight(420); |
| fnMc.setWidth(285); |
| fnMc.addListener(new WindowListenerAdapter() { |
| @Override |
| public void onClose(Panel panel) { |
| } |
| }); |
| //fnMc.activerBoutonValider(selection); |
| } |
| public void afficherFenetreGestionMotsCles() { |
| fnMc.show(); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/image/ImageModele.java |
|---|
| New file |
| 0,0 → 1,1001 |
| package org.tela_botanica.client.image; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Vector; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.modeles.objets.ListeImageCarnet; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.gwtext.client.data.ArrayReader; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.IntegerFieldDef; |
| import com.gwtext.client.data.MemoryProxy; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| /** |
| * Modèle d'accès aux données pour les images. C'est un singleton |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageModele implements Rafraichissable { |
| /** |
| * Booleen indiquant si le médiateur est instancié (l'instance doit être |
| * unique donc le booleen est static) |
| */ |
| private static boolean estInstancie = false; |
| /** |
| * le modèle lui même |
| */ |
| private static ImageModele thisModele = null; |
| /** |
| * Le médiateur associé au modèle |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * La configuration en cours |
| */ |
| private Configuration config = null; |
| /** |
| * La liste des image affichées en cours |
| */ |
| private ListeImageCarnet cacheImage = new ListeImageCarnet(0); |
| /** |
| * Table de correspondance entre les mots clés et leurs identifiants |
| */ |
| private HashMap<String, String> motsCles = new HashMap<String, String>(0); |
| /** |
| * Le store contenant les données à afficher, que le modèle transmet au |
| * médiateur quand il le demande |
| */ |
| private Store st = null; |
| /** |
| * Arbre des mots clés |
| */ |
| private com.gwtext.client.data.Tree arbreMotsCles = new Tree(); |
| /** |
| * Numéro de page en cours |
| */ |
| private int pageEncours = 0; |
| /** |
| * Nombre de pages totales |
| */ |
| private int pageMax = 1; |
| /** |
| * Taille de page (par défaut 50) |
| */ |
| private int taillePage = 50; |
| /** |
| * Nombre d'éléments total correspondant à la requete |
| */ |
| private int nbElements = 0; |
| /** |
| * "Presse papier" pour les images qui permet de garder en mémoire une |
| * sélection |
| */ |
| private Vector<String> selectionImages = new Vector<String>(0); |
| /** |
| * Retourne une instance de manière unique |
| * |
| * @param im |
| * le médiateur à associer |
| * @return l'instance du modèle |
| */ |
| static ImageModele Instance(ImageMediateur im) { |
| // si le modèle n'est pas encore instancié |
| if (!estInstancie) { |
| // on en crée un nouveau |
| estInstancie = true; |
| thisModele = new ImageModele(im); |
| } |
| // sinon on retourne le "pointeur" vers le modèle lui-même |
| return thisModele; |
| } |
| /** |
| * Le constructeur est privé et seule la méthode instance y accède |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| private ImageModele(ImageMediateur im) { |
| iMediateur = im; |
| config = new Configuration(); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Appelle le DAO asynchrone pour obtenir la liste des images |
| * |
| * @param r |
| * le rafraichissable auxquel on enverra les données |
| */ |
| public void obtenirNombrePhotoGalerie(Rafraichissable r) { |
| String valeursFiltres[][] = getIMediateur().renvoyerFiltres(); |
| int tailleFiltres = valeursFiltres.length; |
| String[][] criteres = new String[tailleFiltres][2]; |
| String[] utilisateur = { |
| "" + getIMediateur().getIdentifiant() }; |
| criteres[0] = utilisateur; |
| for (int i = 0; i < valeursFiltres.length; i++) { |
| criteres[i] = valeursFiltres[i]; |
| } |
| // on les crée un DAO auquel on les transmet et qui demande le nombre |
| // d'images correspondantes (pour les pages) |
| NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this); |
| niaDAO.obtenirNombreImages(this, criteres); |
| } |
| public void obtenirPhotoGalerie(Rafraichissable r) |
| { |
| String valeursFiltres[][] = getIMediateur().renvoyerFiltres(); |
| int tailleFiltres = valeursFiltres.length; |
| String[][] criteres2 = new String[tailleFiltres + 2][2]; |
| String[] limite = { "limite", "" + taillePage }; |
| String[] taillePage = { "numero_page", "" + pageEncours }; |
| criteres2[0] = limite; |
| criteres2[1] = taillePage; |
| for (int i = 0; i < valeursFiltres.length; i++) { |
| criteres2[i + 2] = valeursFiltres[i]; |
| } |
| // et on crée un DAO auquel on les transmet et qui envoie une requete |
| // pour recevoir les images |
| ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this); |
| liaDAO.ObtenirListeImages(this, criteres2); |
| } |
| /** |
| * Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et |
| * lancer l'interface appropriée |
| */ |
| @SuppressWarnings("static-access") |
| public void uploaderImages(boolean multiple) { |
| ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this); |
| if(multiple) { |
| IuADaO.appelerUploadMultiple(); |
| } |
| else |
| { |
| IuADaO.appelerUploadSimple(); |
| } |
| } |
| /** |
| * Met à jour la liste des images à partir d'un objet |
| * |
| * @param o |
| * la nouvelle liste d'image |
| */ |
| public void rafraichirListeImage(Object o) { |
| cacheImage = (ListeImageCarnet) o; |
| } |
| /** |
| * Met à jour l'arbre des mots clés à partir d'un objet |
| * |
| * @param o |
| * le nouvel arbre de mots clés |
| */ |
| public void rafraichirArbreMotsCles(Object o) { |
| arbreMotsCles = (com.gwtext.client.data.Tree) o; |
| } |
| /** |
| * Met à jour la table de correspondance mots clés / ids à partir d'un objet |
| * |
| * @param o |
| * la nouvelle table des mots clés |
| */ |
| @SuppressWarnings("unchecked") |
| public void rafraichirMotsCles(Object o) { |
| if (o instanceof HashMap) { |
| motsCles = (HashMap<String, String>) o; |
| } |
| } |
| /** |
| * Va chercher les métadonnées associées à une image dans la liste des |
| * images chargée dans le modèle |
| * |
| * @param r |
| * le rafraichissable auquel on enverra les informations |
| * @param id |
| * l'identifiant de l'image |
| */ |
| public void obtenirMetadonnees(Rafraichissable r, String id) { |
| ImageCarnet im = cacheImage.get(id); |
| Object meta[] = new Object[3]; |
| meta[0] = im.getMetadonnesExif(); |
| meta[1] = im.getMetadonnesIptc(); |
| meta[2] = im.getInfoGenerales(); |
| r.rafraichir(meta, false); |
| } |
| /** |
| * Va chercher les mots clés associés à une image dans la liste des images |
| * chargée dans le modèle |
| * |
| * @param r |
| * le rafraichissable auquel on enverra les informations |
| * @param id |
| * l'identifiant de l'image |
| */ |
| public void obtenirMotsClesId(Rafraichissable r, String id) { |
| String[] motsClesIdTab = getMotsClesId(id); |
| r.rafraichir(motsClesIdTab, false); |
| } |
| public String[] getMotsClesId(String idImage) { |
| ImageCarnet im = cacheImage.get(idImage); |
| String motsClesId = im.getMotsCles(); |
| String[] motsClesIdTab = motsClesId.split(","); |
| return motsClesIdTab; |
| } |
| /** |
| * Va chercher le nom du mot clé associé à un id dans le cache local |
| * |
| * @param String id |
| * id du mot clé |
| * @return le mot clé associé à l'identifiant |
| */ |
| public String obtenirTexteMotCle(String id) { |
| String correspondanceId = ""; |
| String motCleTexte = motsCles.get(id); |
| if(motCleTexte != null) { |
| correspondanceId = motCleTexte; |
| } |
| return correspondanceId; |
| } |
| /** |
| * Construit une chaine contenant le texte des mots clés séparés par des virgules |
| */ |
| public String renvoyerChaineMotClesTexte(ImageCarnet ic) { |
| String chaineMotsCles = ic.getMotsCles(); |
| String[] tabMotsCles = chaineMotsCles.split(","); |
| String chaineMotsClesTexte = ""; |
| for (int i = 0; i < tabMotsCles.length; i++) { |
| chaineMotsClesTexte += motsCles.get(tabMotsCles[i]); |
| chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : ""; |
| } |
| return chaineMotsClesTexte; |
| } |
| /** |
| * Met à jour la liste des images en local et appelle le DAO de mise à jour |
| * pour les commentaires et la date des images selectionnées |
| * |
| * @param commentaires |
| * le commentaire à appliquer |
| * @param date |
| * la date à appliquer |
| * @param ids |
| * les identifiants des images selectionnées |
| */ |
| public void mettreAJourCacheImage(String commentaires, String date, |
| String note, String ids[]) { |
| for (int i = 0; i < ids.length; i++) { |
| String key = ids[i]; |
| ImageCarnet ic = cacheImage.get(key); |
| ic.miseAJourInfoGenerales(commentaires, date, note); |
| mettreAjourBaseDeDonneesImageCarnet(ic); |
| } |
| } |
| /** |
| * Ajoute un nouveau mot clés à la liste des mots clés locale |
| * |
| * @param text |
| * le mot clé |
| * @param id |
| * l'identifiant du mot clé |
| */ |
| public void mettreAjourMotsClesId(String text, String id) { |
| motsCles.put(id, text); |
| } |
| /** |
| * Appelle le DAO chargé de mettre à jour la base de données avec les toutes |
| * les informations des images modifiées par l'utilisateur |
| */ |
| public void mettreAJourBaseDeDonneesListeImageCarnet() { |
| ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this); |
| liDaO.SynchroniserBaseDeDonnees(cacheImage); |
| } |
| /** |
| * Appelle le DAO chargé de mettre à jour la base de données avec les toutes |
| * les informations d'une image donnée |
| * |
| * @param ic |
| * l'image à synchroniser avec la base |
| */ |
| public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) { |
| ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this); |
| iaDaO.SynchroniserBaseDeDonnees(ic); |
| } |
| /** |
| * Supprime les images données du cache local et appelle le DAO qui les |
| * supprime de la base de données |
| * |
| * @param ids |
| * les identifiants des images selectionnées |
| */ |
| public void supprimerImages(String[] ids) { |
| String rids[] = new String[ids.length]; |
| ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this); |
| for (int i = 0; i < ids.length; i++) { |
| String key = ids[i]; |
| ImageCarnet ic = cacheImage.get(key); |
| rids[i] = ic.getId(); |
| cacheImage.remove(key); |
| } |
| if (rids.length != 0) { |
| liDao.supprimerBaseDeDonnees(rids); |
| } |
| } |
| /** |
| * Met à jour les données locales suivant le type des nouvelles données et |
| * appelle le médiateur pour le notifier de la mise à jour |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si l'on a reçu une liste d'images |
| if (nouvelleDonnees instanceof ListeImageCarnet) { |
| ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees; |
| Object[][] photoData = new Object[data.size()][13]; |
| int i = 0; |
| if (data.size() == 0) { |
| pageEncours = 0; |
| } |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) { |
| ImageCarnet im = data.get(it.next()); |
| photoData[i][0] = im.getOrdre(); |
| photoData[i][1] = im.getNomOriginal(); |
| photoData[i][2] = im.getDate(); |
| photoData[i][3] = im.getIptcCity(); |
| photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil(); |
| photoData[i][5] = im.getUrlFormatListe(); |
| photoData[i][6] = im.getUrlFormatGalerie(); |
| photoData[i][7] = im.getUrlFormatZoom(); |
| photoData[i][8] = im.getNote(); |
| photoData[i][9] = im.getId(); |
| photoData[i][10] = im.getTailleImage()[1]; |
| photoData[i][11] = im.getTailleImage()[0]; |
| photoData[i][12] = im.getIdsObsAssociees(); |
| i++; |
| } |
| // creation du store qui les contient |
| 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 IntegerFieldDef("note_image"); |
| FieldDef defIdImage = new IntegerFieldDef("id_image"); |
| FieldDef defTailleX = new IntegerFieldDef("taille_x"); |
| FieldDef defTailleY = new IntegerFieldDef("taille_y"); |
| FieldDef defObsAssociees = new StringFieldDef("obs_associees"); |
| FieldDef[] defTab = { defNumImage,defNomImage, defDatImage, defLieImage, |
| defAppImage, defUrlImageS, defUrlImageM, defUrlImage, |
| defNoteImage, defIdImage, defTailleX, defTailleY, defObsAssociees }; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(photoData); |
| final ArrayReader reader = new ArrayReader(rd); |
| final Store photoStore = new Store(dataProxy, reader); |
| rafraichirListeImage(nouvelleDonnees); |
| st = photoStore; |
| st.load(); |
| // par défaut le store est trié sur le numéro d'image |
| st.sort("num_image"); |
| // si on doit répandre les données, on notifie le médiateur qui les |
| // distribuera à son tour |
| if (repandreRafraichissement) { |
| getIMediateur().synchroniserDonneesZoomListeGalerie(st, this); |
| } |
| } |
| // si on reçoit un tableau JSON |
| if (nouvelleDonnees instanceof JSONArray) { |
| // alors on a reçu les informations sur les mots clés |
| JSONArray reponse = (JSONArray) nouvelleDonnees; |
| final int taillemax = reponse.size(); |
| // si le tableau est vide |
| if (taillemax == 0) { |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine"); |
| root.setText("Tags"); |
| String[] usObj = { "Tags", "racine" }; |
| root.setUserObject(usObj); |
| arbreMotsCles.setRootNode(root); |
| } |
| HashMap<String, String> motsCles = new HashMap<String, String>(taillemax); |
| // pour chacun des élements du tableau |
| for (int j = 0; j < taillemax; j++) { |
| // on extrait les élements du tableau |
| if (reponse.get(j).isObject() != null) { |
| JSONObject noeud = (JSONObject) reponse.get(j); |
| String id_noeud = noeud.get("id_mot_cle_image") |
| .isString().stringValue(); |
| String mot_cle = noeud.get("mot_cle").isString() |
| .stringValue(); |
| String parent = noeud.get("ce_mot_cle_image_parent").isString() |
| .stringValue(); |
| String[] usObj = { mot_cle, id_noeud }; |
| // et on construit l'arbre à partir de la racine (qui est |
| // toujours le premier élément) |
| if (id_noeud.equals("racine")) { |
| TreeNode root = new TreeNode(); |
| root.setId(id_noeud); |
| root.setText(mot_cle); |
| root.setUserObject(usObj); |
| arbreMotsCles.setRootNode(root); |
| } else { |
| // et en ajoutant les noeuds un à un (qui sont renvoyé |
| // dans l'ordre hierarchique de leur niveau |
| // ce qui permet de les traiter séquentiellement) |
| TreeNode node = new TreeNode(); |
| node.setId(id_noeud); |
| node.setText(mot_cle); |
| node.setChecked(false); |
| Node parentNode = arbreMotsCles.getNodeById(parent); |
| node.setUserObject(usObj); |
| parentNode.appendChild(node); |
| } |
| motsCles.put(id_noeud, mot_cle); |
| } |
| } |
| // enfin on met à jour l'arbre des mots clés contenu dans le modèle |
| rafraichirArbreMotsCles(arbreMotsCles); |
| // la table de hachage |
| rafraichirMotsCles(motsCles); |
| // et on notifie le médiateur de la mise à jour en lui passant une |
| // copie des données |
| getIMediateur().rafraichirArbreMotsCles(arbreMotsCles); |
| } |
| // Si on reçoit un tableau d'entiers |
| // c'est un tableau d'un seul entier qui est le nombre d'images |
| // 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 |
| getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours, |
| taillePage, pages[0]); |
| obtenirPhotoGalerie(this) ; |
| } |
| if(nouvelleDonnees instanceof ListeObservation) { |
| getIMediateur().rafraichirMiniListeObservations((ListeObservation)nouvelleDonnees) ; |
| } |
| if(nouvelleDonnees instanceof Tree) { |
| rafraichirArbreMotsCles(nouvelleDonnees); |
| getIMediateur().rafraichirArbreMotsCles((Tree)nouvelleDonnees); |
| } |
| } |
| /** |
| * Affiche les paires / valeur de tous les mots clés stockés |
| */ |
| public void afficherMotsCles() { |
| for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) { |
| String key = it.next(); |
| String valeur = motsCles.get(key); |
| System.out.println("clé : " + key + " valeur : " + valeur); |
| } |
| } |
| /** |
| * Met à jour les mots clés associés à une image et appelle le DAO pour |
| * synchroniser la base de données |
| * |
| * @param ids |
| * les identifiants des images selectionnées |
| * @param motsClesEnCours |
| * les mots clés à appliquer aux images |
| * @param arbreMC |
| * l'arbre de mots clés en cours |
| */ |
| public void mettreAjourMotsCles(String[] ids, String motsClesEnCours, |
| com.gwtext.client.data.Tree arbreMC) { |
| String idImgs = ""; |
| for (int i = 0; i < ids.length; i++) { |
| String idImageEnCours = ""; |
| if (cacheImage.containsKey(ids[i])) { |
| ImageCarnet ic = cacheImage.get(ids[i]); |
| idImageEnCours = ic.getId(); |
| ic.mettreAjourMotsCles(motsClesEnCours); |
| } |
| idImgs += idImageEnCours; |
| idImgs += (i < (ids.length - 1)) ? ",": ""; |
| } |
| LiaisonMotsClesImageAsynchroneDAO liMcDao = new LiaisonMotsClesImageAsynchroneDAO(this); |
| liMcDao.modifier(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idImgs, motsClesEnCours); |
| rafraichirArbreMotsCles(arbreMC); |
| } |
| /** |
| * Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la |
| * base de données |
| */ |
| public void initialiserArbreMotsCles() { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images"); |
| MCDao.obtenirListeMotsCles(this); |
| } |
| /** |
| * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable |
| * donné, qui le demande |
| * |
| * @param r |
| * le rafraichissable demandeur de l'arbre |
| */ |
| public void obtenirArbreMotCle(Rafraichissable r) { |
| r.rafraichir(arbreMotsCles, false); |
| } |
| /** |
| * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui |
| * fait la mise à jour de l'arbre des mots clés dans la base |
| * |
| * @param n |
| * le nouveau noeud contenant le mot clé |
| * @param arbreMC |
| * l'arbre des mots cles en cours |
| */ |
| public void ajouterMotCleDansArbre(TreeNode n, |
| com.gwtext.client.data.Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| if (!id.equals("racine")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| parentId = parentUsObj[1]; |
| } else { |
| parentId = "racine"; |
| } |
| rafraichirArbreMotsCles(arbreMC); |
| mettreAjourMotsClesId(motCle, id); |
| String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle=" |
| + motCle + "&id=" + id + "&parent=" + parentId; |
| MCDao.ajouterBaseDeDonnees(nouveauMotCle); |
| } |
| /** |
| * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va |
| * supprimer les mots clés associés dans la base |
| * |
| * @param n |
| * le noeud à supprimer |
| * @param arbreMC |
| * l'arbre des mots clés en cours |
| */ |
| public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String id = usObj[1]; |
| MCDao.supprimerBaseDeDonnees(id); |
| } |
| /** |
| * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le |
| * DAO qui synchronise la modification dans la base de données |
| * |
| * @param n |
| * le noeud modifié |
| * @param arbreMC |
| * l'arbre des mots clés en cours |
| */ |
| public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| if (!id.equals("racine")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| parentId = parentUsObj[1]; |
| } else { |
| parentId = "racine"; |
| } |
| rafraichirArbreMotsCles(arbreMC); |
| String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent=" |
| + parentId; |
| MCDao.modifierBaseDeDonnees(motCleModifie); |
| } |
| /** |
| * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui |
| * reorganise l'arbre dans la base de donnees suivant le changement |
| * |
| * @param n |
| * le noeud deplace (et son sous arbre associe) |
| * @param arbreMC |
| * l'arbre des mots cles en cours |
| */ |
| public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| if (!id.equals("racine")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| parentId = parentUsObj[1]; |
| } else { |
| parentId = "racine"; |
| } |
| rafraichirArbreMotsCles(arbreMC); |
| String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent=" |
| + parentId; |
| MCDao.deplacerBaseDeDonnees(motCleModifie); |
| } |
| /** |
| * Change le numéro de la page en cours et envoie une demande de mise à jour |
| * des données |
| * |
| * @param nouvellePageCourante |
| * la nouvelle page à afficher |
| */ |
| public void changerNumeroPage(int nouvellePageCourante) { |
| pageEncours = nouvellePageCourante; |
| obtenirNombrePhotoGalerie(this); |
| } |
| /** |
| * 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()); |
| } |
| /** |
| * Change la taille de page et recalcule la page encours |
| * |
| * @param nouvelleTaillePage |
| * la nouvelle taille de page à utiliser |
| */ |
| public void changerTaillePage(int nouvelleTaillePage) { |
| taillePage = nouvelleTaillePage; |
| pageEncours = calculerPageCourante(nbElements); |
| obtenirNombrePhotoGalerie(this); |
| } |
| /** |
| * Met la valeur de la page en cours à la dernière |
| */ |
| public void setDernierePage() { |
| changerNumeroPage(pageMax); |
| } |
| /** |
| * Notifie le mediateur que l'upload ou le download est termine et qu'il |
| * faut rafraichir les vues avec les nouvelles données |
| */ |
| public void requeteTerminee() { |
| getIMediateur().demasquerChargement(); |
| getIMediateur().rafraichirToutesVues(); |
| } |
| /** |
| * Obtient l'identifiant de l'utilisateur auprès du médiateur |
| * |
| * @return id de l'utilisateur |
| */ |
| public String getIdentifiant() { |
| return getIMediateur().getIdentifiant(); |
| } |
| /** |
| * renvoie la taille d'une image grâce à son identifiant |
| * |
| * @param id |
| * l'identifiant de l'image |
| * @return un tableau contenant la longueur et la hauteur de l'image |
| */ |
| public String[] obtenirTailleImage(String id) { |
| return (cacheImage.get(id)).getTailleImage(); |
| } |
| /** |
| * Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il |
| * renvoie la note associée au rafrachissable qui la demande |
| * |
| * @param r |
| * le rafraichissable demandeur de l'information |
| * @param id |
| * l'identifiant del'image |
| */ |
| public void obtenirNote(Rafraichissable r, String id) { |
| r.rafraichir((cacheImage.get(id)).getNote(), true); |
| } |
| /** |
| * Accesseur pour la configuration en cours d'utilisation |
| * |
| * @return la configuration |
| */ |
| public Configuration getConfig() { |
| return config; |
| } |
| /** |
| * Ajoute des images à la selection en cours |
| * |
| * @param ids |
| * les identifiants des images à ajouter |
| */ |
| public void ajouterImagesSelection(String[] ids) { |
| for (int i = 0; i < ids.length; i++) { |
| String idImg = cacheImage.get(ids[i]).getId(); |
| selectionImages.add(idImg); |
| } |
| } |
| public int getCompteSelection() { |
| return selectionImages.size(); |
| } |
| /** |
| * Vide la selection en cours |
| */ |
| public void viderSelection() { |
| selectionImages.clear(); |
| } |
| public String renvoyerSelection() { |
| String selection = ""; |
| if(selectionImages.size() <= 0) |
| { |
| selection += "-255" ; |
| } |
| else |
| { |
| for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) { |
| String idEncours = it.next(); |
| selection += idEncours + ","; |
| } |
| } |
| return selection; |
| } |
| public void lierImagesObervations(String idsObs, String idsImg) { |
| LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ; |
| lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ; |
| } |
| public void obtenirLiaisonObservations(ImageMediateur imageMediateur, |
| String id) { |
| String imgId = cacheImage.get(id).getId() ; |
| LienImageAsynchroneDAO lienDao = new LienImageAsynchroneDAO(this) ; |
| lienDao.obtenirLiaisonsImagesObservations(this, imgId) ; |
| } |
| public void supprimerLiaisonImages(String[] idsImg, String idObs) { |
| String chaineIdImg = ""; |
| for(int i = 0; i < idsImg.length; i++) { |
| String idImg = cacheImage.get(idsImg[i]).getId() ; |
| chaineIdImg += ","+idImg; |
| } |
| chaineIdImg = chaineIdImg.replaceFirst(",", ""); |
| LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ; |
| lienDAO.supprimerLienImageObservation(chaineIdImg, idObs) ; |
| } |
| public void obtenirMiniListeObservations(Rafraichissable r, String[] critere, int taillePage, int numeroPage) { |
| String[][] criteres = {{critere[0],critere[1]},{"limite",""+taillePage},{"numero_page",""+numeroPage}} ; |
| // et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images |
| ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this); |
| loaDAO.obtenirListeObservation(r, iMediateur.getIdentifiant(), criteres); |
| } |
| public void obtenirNombreMiniListeObservations(Rafraichissable r, String[] critere) { |
| String[][] criteres = {{critere[0],critere[1]}} ; |
| // et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images |
| NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this); |
| noaDAO.obtenirNombreObservation(r, iMediateur.getIdentifiant(), criteres); |
| } |
| public void obtenirDatesImages(Rafraichissable r) { |
| ListeDateImageAsynchroneDAO lDateDao = new ListeDateImageAsynchroneDAO(this); |
| lDateDao.obtenirListeDate(r, iMediateur.getIdentifiant()); |
| } |
| public String obtenirIdPourOrdre(String ordreImage) { |
| return cacheImage.get(ordreImage).getId(); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/MenuAideVue.java |
|---|
| New file |
| 0,0 → 1,94 |
| 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 |
| @Override |
| 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; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java |
|---|
| New file |
| 0,0 → 1,453 |
| 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.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.Node; |
| 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.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| import com.gwtext.client.widgets.tree.MultiSelectionModel; |
| 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; |
| /** |
| * 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; |
| 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); |
| MultiSelectionModel msModel = new MultiSelectionModel(); |
| arbreMotsCles.setSelectionModel(msModel); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Tags"); |
| root.setId("racine"+prefixe); |
| String[] usObject = { "Mots clés", "racine"+prefixe }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onClick(Node node, EventObject e) { |
| if(!arbreInitialise) { |
| expand(); |
| } |
| } |
| @Override |
| 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 |
| @Override |
| 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%")); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| //obtenirArbreMotsCles(); |
| } |
| }); |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des mots clés |
| */ |
| private void ajouterListeners() { |
| arbreMotsCles.addListener(new TreePanelListenerAdapter() { |
| // gestion du clic sur un noeud |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| boolean multi = false; |
| if(e.hasModifier()) { |
| multi = true; |
| } |
| gererClicNoeud(node,multi); |
| } |
| }); |
| } |
| /** |
| * Fonction de gestion sur le clic sur le noeud |
| * |
| * @param node |
| */ |
| public void gererClicNoeud(TreeNode node, boolean multi) { |
| if(!arbreInitialise) { |
| obtenirArbreMotsCles(); |
| } else { |
| if(node.equals(arbreMotsCles.getRootNode())) { |
| arbreMotsCles.getSelectionModel().clearSelections(); |
| } else { |
| ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi); |
| } |
| filtreModifie = true; |
| iMediateur.obtenirPhotoGalerie(); |
| } |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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() ; |
| } |
| } |
| /** |
| * 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String val = ""; |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| for(int i = 0; i< noeuds.length ; i++) { |
| if(noeuds[i].getDepth() > 0) { |
| String[] userObj = (String[])noeuds[i].getUserObject(); |
| String idMotCle = noeuds[i].getId(); |
| if(userObj != null && userObj[1] != null) { |
| idMotCle = userObj[1]; |
| } |
| val += ";"+idMotCle; |
| } |
| } |
| val = val.replaceFirst(";", ""); |
| String[] valeursFiltres = {"id_mots_cles", val}; |
| return valeursFiltres; |
| } |
| /** |
| * 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.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) |
| */ |
| @Override |
| 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); |
| } |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| // on vide les mots clés en cours |
| motsClesEncours = ""; |
| // on suppose que le filtre a change |
| filtreModifie = true; |
| } |
| } |
| public void raz() { |
| if(arbreInitialise) { |
| // on vide tous les noeuds de l'ancien arbre |
| Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreInitialise = false ; |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Tags"); |
| root.setId("racine"+prefixe); |
| String[] usObject = { "Mots clés", "racine"+prefixe }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onClick(Node node, EventObject e) { |
| if(!arbreInitialise) { |
| expand(); |
| } |
| } |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreInitialise) { |
| obtenirArbreMotsCles(); |
| arbreInitialise = true; |
| } |
| } |
| }); |
| } |
| } |
| @Override |
| public void viderFiltre() { |
| motsClesEncours = ""; |
| arbreMotsCles.getSelectionModel().clearSelections(); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/FenetreLicenceVue.java |
|---|
| New file |
| 0,0 → 1,143 |
| package org.tela_botanica.client.vues; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.event.logical.shared.ValueChangeEvent; |
| import com.google.gwt.event.logical.shared.ValueChangeHandler; |
| import com.google.gwt.user.client.ui.CheckBox; |
| import com.google.gwt.user.client.ui.HTML; |
| 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.form.FormPanel; |
| public class FenetreLicenceVue extends com.gwtext.client.widgets.Window implements Rafraichissable { |
| CarnetEnLigneMediateur cm = null; |
| private CheckBox accepterLicence = new CheckBox(); |
| private Button validerAcceptationLicence = new Button("Valider"); |
| private Button annulerAcceptationLicence = new Button("Refuser"); |
| // C'est moche mais ça évite de la transmettre du serveur ou de créer un fichier de config pour la licence |
| // Todo afficher un texte provenant d'une url |
| private String licence = "Le \"carnet en ligne\" (CEL) est un service proposé par Tela Botanica dans le but de vous aider à garder la trace de vos observations de terrain afin qu'elles ne restent plus prisonnière de votre \"petit carnet à spirale\"... La saisie des données est rapide, sure et précise et le CEL vous permet de les archiver et de les trier facilement. Si vous les publiez, ce que nous vous invitons vivement à faire, mais sans obligation, elles seront visibles sur les cartes de répartition des espèces du site de Tela Botanica. De même, vous pourrez faire partager vos meilleures photos de plantes avec les autres membres du réseau. Vous pourrez également exporter vos observations saisies dans le CEL dans une table Excel pour les traiter statistiquement ou les transférez à d'autres botanistes ou dans d'autres logiciels.<br>" |
| +"<br>" |
| +"Pour cela vous devez accepter les conditions suivantes :<br>" |
| +"<br>" |
| +"1. <b>Etre inscrit au réseau Tela Botanica</b> : cette inscription est gratuite et vous trouverez toutes explications à l'adresse <a href=\"http://www.tela-botanica.org/page:rejoindre_reseau\">http://www.tela-botanica.org/page:rejoindre_reseau</a><br>" |
| +" " |
| +"<br>" |
| +"2. <b>En publiant vos observations sur le site de Tela Botanica vous acceptez de céder :</b><br>" |
| +"- <u>un droit d'usage interne à Tela Botanica</u>, non exclusif, non limité dans le temps et à titre gratuit, sur l’ensemble des données publiées, notamment celui de les détenir, de les dupliquer, de les archiver, de les agréger avec des données provenant d’autres sources et d’effectuer tout type de calcul permettant d’en extraire des informations de niveau général, comme des statistiques par exemple.<br>" |
| +"- <u>le droit à Tela Botanica de les diffuser librement et gratuitement</u>, sans limite de temps, à condition que le nom de l'auteur de l'observation soient cité ainsi que celui de Tela Botanica. Cependant, dans le cas ou une publication comprendrait plus de 100 auteurs différents, seule la mention \"réseau Tela Botanica\" pourra être mentionnée.<br>" |
| +"<br>" |
| +"3. <b>Vous pouvez à tout moment retirer de la publication les données que vous désirez</b>. Dans ce cas les clauses de l'article précédent ne s'appliqueront plus aux données ainsi retirées de la publication, sans toute fois pouvoir revenir sur les droits cédés antérieurement lors de leur publication initiale dans le cas ou ces données ait déjà été utilisées par des tiers. <br>" |
| +" " |
| +"<br>" |
| +"4. <b>En publiant vos photos</b> sur le site de TB lors de la publication de vos observations, vous acceptez de les mettre à disposition de la communauté sous une licence <a href=\"http://www.tela-botanica.org/page:licence\">Creative Commons</a>. Cette mise à disposition sous licence Creative Commons n'est applicable que pour le format réduit de vos clichés présenté sur le site Tela Botanica. Elle ne s'applique pas aux clichés dans leur format original en haute définition dont vous gardez la propriété exclusive.<br>" |
| +"Selon cette licence <a href=\"http://www.tela-botanica.org/page:licence\">Creative Commons</a> toute personne sera libre de reproduire, modifier, distribuer et communiquer les photos au public selon les conditions suivantes :<br>" |
| +"- citer le nom de l'auteur original de l'oeuvre ainsi que celui de Tela Botanica qui l'édite,<br>" |
| +"- s'il y a modification, transformation ou adaptation des oeuvres, vous cédez le droit de distribuer la création qui en résulte que sous un contrat identique à celui-ci,<br>" |
| +" " |
| +"- à chaque réutilisation ou distribution, doit apparaître clairement les conditions contractuelles de mise à disposition de cette création,<br>" |
| +"- chacune de ces conditions peut être levée s'il y a autorisation du titulaire des droits.<br>" |
| +"<br>" |
| +"5. <b>En publiant vos données (photos et/ou observations) sur le site de Tela Botanica</b> vous acceptez que les membres du réseau puissent vous contacter via votre adresse électronique pour discuter avec vous de la pertinence de votre détermination, de son lieu d'observation ou de l'intitulé de vos clichés.<br>" |
| +"<br>" |
| +"6. <b>Affichage de votre identité et de votre adresse électronique</b>. L'affichage de votre identité pourra apparaître selon les noms et prénoms que vous aurez renseigné lors de votre inscription au réseau Tela Botanica. Seule la partie précédent le signe @ de votre adresse électronique sera affichée afin d'éviter son utilisation par des tiers. Les messages qui vous parviendront seront envoyés par Tela Botanica via un dispositif garantissant le non piratage de votre adresse.<br>" |
| +"<br/><br/>" |
| ; |
| public FenetreLicenceVue(CarnetEnLigneMediateur cm) { |
| super(); |
| this.cm = cm; |
| setTitle("Acceptation de la licence du carnet en ligne"); |
| Panel conteneurHtml = new Panel(); |
| conteneurHtml.setHtml(licence); |
| conteneurHtml.setHeight(230); |
| conteneurHtml.setAutoScroll(true); |
| HTML conteneurLicence = new HTML(); |
| conteneurHtml.add(conteneurLicence); |
| //licence = Configuration.getLicence(); |
| setConstrain(true); |
| conteneurLicence.setHTML(licence); |
| this.add(conteneurHtml); |
| Panel conteneurCheckbox = new Panel(); |
| conteneurCheckbox.setBorder(false); |
| conteneurCheckbox.setHeader(false); |
| Label labelCheckboxAccepterLicence = new Label(); |
| labelCheckboxAccepterLicence.setStyleName("display:inline"); |
| accepterLicence.setText(" J'ai lu et j'accepte la licence"); |
| accepterLicence.setStyleName("accepter_licence"); |
| FormPanel conteneurCheckboxEtValidation = new FormPanel(); |
| conteneurCheckboxEtValidation.setHeader(false); |
| conteneurCheckboxEtValidation.setHeight(70); |
| conteneurCheckboxEtValidation.add(accepterLicence); |
| conteneurCheckboxEtValidation.add(labelCheckboxAccepterLicence); |
| conteneurCheckboxEtValidation.addButton(validerAcceptationLicence); |
| validerAcceptationLicence.setDisabled(true); |
| conteneurCheckboxEtValidation.addButton(annulerAcceptationLicence); |
| this.add(conteneurCheckboxEtValidation); |
| this.setClosable(false); |
| this.setHeight(320); |
| ajouterListenerBoutons(); |
| } |
| public void ajouterListenerBoutons() { |
| accepterLicence.addValueChangeHandler(new ValueChangeHandler<Boolean>() { |
| @Override |
| public void onValueChange(ValueChangeEvent<Boolean> event) { |
| validerAcceptationLicence.setDisabled(!event.getValue()); |
| } |
| }); |
| validerAcceptationLicence.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| cm.rafraichir("licence_acceptee", false); |
| } |
| }); |
| annulerAcceptationLicence.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| cm.rafraichir("licence_refusee", false); |
| } |
| }); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| // TODO Auto-generated method stub |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java |
|---|
| New file |
| 0,0 → 1,105 |
| 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 |
| @Override |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/CartographieObservationVue.java |
|---|
| New file |
| 0,0 → 1,361 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.user.client.Timer; |
| 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; |
| import com.gwtext.client.widgets.form.Label; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| import com.google.maps.gwt.client.GoogleMap; |
| import com.google.maps.gwt.client.GoogleMap.ClickHandler; |
| import com.google.maps.gwt.client.GoogleMap.ZoomChangedHandler; |
| import com.google.maps.gwt.client.InfoWindow; |
| import com.google.maps.gwt.client.InfoWindowOptions; |
| import com.google.maps.gwt.client.LatLng; |
| import com.google.maps.gwt.client.MapOptions; |
| import com.google.maps.gwt.client.MapTypeId; |
| import com.google.maps.gwt.client.Marker; |
| import com.google.maps.gwt.client.MarkerOptions; |
| import com.google.maps.gwt.client.MouseEvent; |
| public class CartographieObservationVue extends Panel implements Rafraichissable { |
| private String id = "cartographie_observation"; |
| private ObservationMediateur oMediateur = null; |
| Panel panneauCarto = null; |
| GoogleMap map = null; |
| Marker nmk = null; |
| private boolean carteAjoutee = false; |
| private boolean infoOuverte = false; |
| String valeurCommune = "Bourges"; |
| LatLng centreFrance = null; |
| LatLng pointCommune = null; |
| String codeCommune = ""; |
| int niveauZoom = 6; |
| Label panneauExplication = new Label( |
| "Précisez le lieu de votre observation et cliquez sur OK. Les coordonnées sont données en degrés décimaux, comptés positivement vers le Nord pour la latitude, et vers l'Est pour la longitude"); |
| private InfoWindow info; |
| public CartographieObservationVue(ObservationMediateur om) { |
| oMediateur = om; |
| setHeader(false); |
| setAutoWidth(true); |
| setPaddings(10); |
| panneauCarto = new Panel(); |
| panneauCarto.setLayout(new FitLayout()); |
| setLayout(new RowLayout()); |
| panneauCarto.setAutoHeight(true); |
| add(panneauExplication, new RowLayoutData(12)); |
| add(panneauCarto, new RowLayoutData()); |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| initialiserCarte(false); |
| } |
| }); |
| } |
| public void setTailleCarte(int hauteur, int largeur) { |
| setSize(largeur, hauteur); |
| } |
| public void masquerChargement(boolean masquer) { |
| if(panneauCarto.isVisible()) { |
| if(masquer) { |
| panneauCarto.getEl().mask("Recherche des coordonnées et de la commune, veuillez patienter"); |
| } else { |
| panneauCarto.getEl().unmask(); |
| } |
| } |
| } |
| public void obtenirInfosCommunes(LatLng coord) { |
| oMediateur.obtenirInformationCoord(this, coord.lat(), coord.lng()); |
| } |
| public void mettreAJourInfos(final LatLng pointNouvelleCommune, String infosComplementaires, int zoom) { |
| GoogleMap mapNulle = null; |
| if(nmk != null) { |
| nmk.setMap(mapNulle); |
| } |
| pointCommune = pointNouvelleCommune; |
| nmk = fabriquerMarqueur(pointCommune, infosComplementaires); |
| nmk.setMap(map); |
| afficherInfoMarker(nmk); |
| recentrerCarte(nmk.getPosition()); |
| } |
| private void initialiserCarte(boolean commune) { |
| panneauCarto.clear(); |
| centreFrance = LatLng.create(47.0504, 2.2347); |
| pointCommune = centreFrance; |
| MapOptions options = MapOptions.create(); |
| options.setCenter(centreFrance); |
| options.setZoom(6) ; |
| options.setMapTypeId(MapTypeId.HYBRID); |
| options.setDraggable(true); |
| options.setMapTypeControl(true); |
| options.setScaleControl(true) ; |
| options.setScrollwheel(true) ; |
| map = GoogleMap.create(panneauCarto.getElement(), options ) ; |
| InfoWindowOptions infopts = InfoWindowOptions.create(); |
| info = InfoWindow.create(); |
| info.setOptions(infopts); |
| info.addCloseClickListener(new InfoWindow.CloseClickHandler() { |
| @Override |
| public void handle() { |
| infoOuverte = false; |
| } |
| }); |
| if(!commune) { |
| fabriquerMarqueurIndication(); |
| } |
| map.addClickListener(new ClickHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| obtenirInfosCommunes(event.getLatLng()); |
| } |
| }); |
| map.addZoomChangedListener(new ZoomChangedHandler() { |
| @Override |
| public void handle() { |
| niveauZoom = (int)map.getZoom(); |
| } |
| }); |
| panneauCarto.doLayout(); |
| panneauCarto.expand(); |
| panneauCarto.setHeight("100%"); |
| panneauCarto.setWidth("100%"); |
| expand(); |
| } |
| public void fabriquerMarqueurIndication() { |
| GoogleMap mapNulle = null; |
| if(nmk != null) { |
| nmk.setMap(mapNulle); |
| } |
| nmk = fabriquerMarqueur(pointCommune,""); |
| nmk.setMap(map); |
| info.setContent("<div id=\"info_contenu\">"+ |
| "Déplacez ce marqueur pour localiser votre observation (commune et coordonnées)<br />" |
| +"longitude=" |
| + nmk.getPosition().lng() + "<br />latitude=" |
| + nmk.getPosition().lat() + "</div>"); |
| infoOuverte = true; |
| info.open(map,nmk); |
| } |
| public void AfficherMessageAucuneInfos() { |
| mettreAJourInfos(centreFrance,"", niveauZoom); |
| Window.alert("Aucune information pour le nom donné"); |
| } |
| public int getNiveauZoom() { |
| return niveauZoom; |
| } |
| private void ajouterListenerBouton(final String idBouton) { |
| final ExtElement bouton = Ext.get(idBouton); |
| if(bouton == null) { |
| Timer t = new Timer() { |
| @Override |
| public void run() { |
| ajouterListenerBouton(idBouton); |
| } |
| }; |
| t.schedule(500); |
| return; |
| } else { |
| bouton.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| EntiteGeographiqueObservation infosCommune = new EntiteGeographiqueObservation(codeCommune,valeurCommune,null,null); |
| infosCommune.setLat(pointCommune.lat()+""); |
| infosCommune.setLon(pointCommune.lng()+""); |
| oMediateur.rafraichirSaisieCommuneObservation(infosCommune); |
| } |
| }); |
| bouton.focus(); |
| } |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof String) { |
| if(isVisible()) { |
| Window.alert((String)nouvelleDonnees); |
| } |
| } |
| if (nouvelleDonnees instanceof EntiteGeographiqueObservation) { |
| oMediateur.afficherFenetreCarto(); |
| EntiteGeographiqueObservation infos = (EntiteGeographiqueObservation) nouvelleDonnees; |
| Double lat = 0.0; |
| Double lon = 0.0; |
| try { |
| lat = Double.parseDouble(infos.getLat()); |
| lon = Double.parseDouble(infos.getLon()); |
| } catch (NumberFormatException nbe) { |
| } |
| LatLng coord = LatLng.create(lat, lon); |
| valeurCommune = infos.getZoneGeo(); |
| codeCommune = Util.convertirChaineZoneGeoVersDepartement(infos.getIdZoneGeo()); |
| pointCommune = coord; |
| mettreAJourInfos(coord, "", niveauZoom); |
| } |
| masquerChargement(false); |
| } |
| public Marker fabriquerMarqueur(LatLng pointMarqueur, final String texte) { |
| // ajout de marqueurs déplacables, qui affichent une bulle d'information |
| MarkerOptions options = MarkerOptions.create(); |
| options.setDraggable(true); |
| options.setPosition(pointMarqueur); |
| final Marker marker = Marker.create(options); |
| marker.addDragEndListener(new Marker.DragEndHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| obtenirInfosCommunes(event.getLatLng()); |
| } |
| }); |
| marker.addDragStartListener(new Marker.DragStartHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| info.close(); |
| } |
| }); |
| marker.addClickListener(new Marker.ClickHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| if(infoOuverte) { |
| info.close(); |
| infoOuverte = false; |
| } else { |
| afficherInfoMarker(marker); |
| infoOuverte = true; |
| } |
| } |
| }); |
| return marker; |
| } |
| public void recentrerCarte() { |
| if(nmk != null && nmk.getVisible()) { |
| recentrerCarte(nmk.getPosition()); |
| } |
| } |
| public void recentrerCarte(LatLng point) { |
| if(this.getWidth() > 12 && this.getHeight() > 24) { |
| panneauCarto.setSize((this.getWidth() - 12)+"px" , (this.getHeight() - 12)+"px"); |
| } |
| panneauCarto.doLayout(); |
| panneauCarto.expand(); |
| panneauCarto.setHeight("100%"); |
| panneauCarto.setWidth("100%"); |
| expand(); |
| map.setCenter(point); |
| } |
| public boolean isCarteAjoutee() { |
| return carteAjoutee; |
| } |
| public void afficherInfoMarker(Marker marker) { |
| final String htmlBoutonOk = "<br /><button id=\"okMap\" class=\"x-btn-text\" type=\"button\">OK</button>"; |
| String contenuMarker = ""; |
| if(valeurCommune == null || valeurCommune.trim().equals("")) { |
| if(marker.getPosition().lng() == 0 && marker.getPosition().lat() == 0) { |
| LatLng point = centreFrance; |
| marker.setPosition(point); |
| niveauZoom = 6; |
| } |
| contenuMarker = "<div id=\"info_contenu\">"+ |
| "Aucune commune française trouvée à cet emplacement <br />" |
| +"Déplacez ce marqueur pour localiser votre observation (commune et coordonnées)<br />" |
| +"longitude=" |
| + marker.getPosition().lng() + "<br />latitude=" |
| + marker.getPosition().lat() + "</div>"; |
| } else { |
| contenuMarker = "" |
| +valeurCommune+" ("+codeCommune+")<br />" |
| +"longitude=" |
| + marker.getPosition().lng() + "<br />latitude=" |
| + marker.getPosition().lat() ; |
| } |
| info.setContent(contenuMarker+ htmlBoutonOk); |
| info.open(map, marker); |
| info.addDomReadyListenerOnce(new InfoWindow.DomReadyHandler() { |
| @Override |
| public void handle() { |
| ajouterListenerBouton("okMap"); |
| } |
| }); |
| recentrerCarte(marker.getPosition()); |
| } |
| public double[] getCoordsCentreFrance() { |
| double[] coords = {47.0504, 2.2347}; |
| return coords; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,211 |
| 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() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| motsAAjouter = motsClesAjout.getText(); |
| //oMediateur.AjouterMotsClesEnMasse(motsAAjouter); |
| } |
| }); |
| voirCacherNuage.addListener(new ButtonListenerAdapter() { |
| @Override |
| 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 |
| } |
| @Override |
| 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) { |
| @Override |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java |
|---|
| New file |
| 0,0 → 1,764 |
| package org.tela_botanica.client.vues.observation.filtres; |
| 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.Window; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragDrop; |
| import com.gwtext.client.dd.DropTargetConfig; |
| 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.form.TextField; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| 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.widgets.tree.DropNodeCallback; |
| import com.gwtext.client.widgets.tree.MultiSelectionModel; |
| import com.gwtext.client.widgets.tree.TreeDragData; |
| 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, Filtrable { |
| /** |
| * 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 ajouterMotCle = 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 nécessaire pour l'affichage |
| * |
| */ |
| private boolean estInstancie = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu |
| */ |
| private boolean motsCleInitialises; |
| private Component livue = null; |
| MultiSelectionModel msModel = null; |
| /** |
| * 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("Projets"); |
| this.setLayout(new VerticalLayout()); |
| oMediateur = om; |
| setBorder(false); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setAutoScroll(true); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| } |
| /** |
| * 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 |
| @Override |
| public void onRender(Component component) { |
| livue = oMediateur.getListeObservation(); |
| // 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"); |
| msModel = new MultiSelectionModel(); |
| arbreMotsCles.setSelectionModel(msModel); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Projets"); |
| root.setId("racine_obs"); |
| String[] usObject = { "Projets", "racine_obs" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| // on crée l'éditeur pour l'arbre |
| tfEdit = new TextField(); |
| te = new TreeEditor(arbreMotsCles, tfEdit); |
| ajouterMotCle = new Button("Ajouter un projet"); |
| arbreMotsCles.add(te); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onClick(Node node, EventObject e) { |
| if(!arbreCharge) { |
| expand(); |
| } |
| } |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| arbreCharge = true; |
| } |
| } |
| }); |
| // on interdit le drag and drop dans l'arbre |
| arbreMotsCles.setRootVisible(true); |
| arbreMotsCles.setBorder(false); |
| // on met en forme le layout |
| add(arbreMotsCles); |
| add(ajouterMotCle); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| configDragAndDrop(); |
| // on ajoute les listeners d'évenements |
| 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 |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| boolean multi = false; |
| if(e.hasModifier()) { |
| multi = true; |
| } |
| gererClicNoeud(node,multi); |
| } |
| // gestion du clic droit sur un noeud |
| @Override |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| montrerContextMenuArbre(node, e, getTe()); |
| } |
| // gestion du double clic sur un noeud |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| public void onMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| // on notifie le médiateur et on lui passe l'arbre |
| getOMediateur().deplacerMotCleDansArbre(node, |
| getArbreMotsCles().getTree()); |
| } |
| @Override |
| public boolean doBeforeNodeDrop(TreePanel treePanel, |
| TreeNode target, DragData dragData, |
| String point, DragDrop source, |
| TreeNode dropNode, |
| DropNodeCallback dropNodeCallback) { |
| if(dragData instanceof TreeDragData) { |
| return true; |
| } |
| String idMotCle = ((String[])target.getUserObject())[1]; |
| if(oMediateur.gererDDObsSurMotCle(target, dragData)) { |
| cocherMotCle(idMotCle); |
| return true; |
| } |
| return false; |
| } |
| @Override |
| public void onNodeDrop(TreePanel treePanel, |
| TreeNode target, DragData dragData, |
| String point, DragDrop source, TreeNode dropNode) { |
| } |
| }); |
| // gestion de la validation |
| ajouterMotCle.addListener(new ButtonListenerAdapter() { |
| // lors du clic |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| TreeNode noeudAjout; |
| if(noeuds.length > 0) { |
| noeudAjout = noeuds[noeuds.length - 1]; |
| } else { |
| noeudAjout = arbreMotsCles.getRootNode(); |
| } |
| ajouterNoeud(noeudAjout); |
| } |
| }); |
| } |
| /** |
| * Configure le drag 'n drop pour la liste |
| */ |
| private 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 |
| arbreMotsCles.setDdGroup("ObsMotsClesGroup"); |
| //arbreMotsCles.setEnableDD(true); |
| arbreMotsCles.setEnableDrag(true); |
| arbreMotsCles.setEnableDrop(true); |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("ObsMotsClesGroup"); |
| } |
| /** |
| * 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())) { |
| if(Window.confirm("Etes vous sur de vouloir supprimer ce projet ?")) { |
| // 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"); |
| // 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); |
| } |
| /** |
| * Fonction de gestion sur le clic sur le noeud |
| * |
| * @param node |
| */ |
| public void gererClicNoeud(TreeNode node, boolean multi) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| } else { |
| if(multi) { |
| } |
| ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi); |
| oMediateur.obtenirNombreObservation(); |
| } |
| } |
| /** |
| * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots |
| * clés à cocher |
| * |
| * @param motsClesIds |
| * un tableau contenant les identifiants des mots clés à cocher |
| */ |
| public void cocherMotsCles(final String[] motsClesIds) { |
| if (getArbreMotsCles() != null |
| && getArbreMotsCles().getRootNode() != null) { |
| // à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // pour chaque noeud |
| @Override |
| public boolean execute(Node node) { |
| // 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().getTextEl().addClassName("x-tree-node-text-kw"); |
| return true; |
| } |
| } |
| if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) { |
| getArbreMotsCles().getNodeById(node.getId()) |
| .getUI().getTextEl().removeClassName("x-tree-node-text-kw"); |
| } |
| // et on passe au suivant |
| return true; |
| } |
| }); |
| } |
| else { |
| motsClesEnAttente = motsClesIds ; |
| } |
| } |
| public void cocherMotCle(String motCleId) { |
| getArbreMotsCles().getNodeById(motCleId) |
| .getUI().getTextEl().addClassName("x-tree-node-text-kw"); |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| motsClesEnCours = ""; |
| arbreMotsCles.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirArbreMotsCles() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données pour l'objet |
| * @param repandreRafraichissement |
| * booleen qui dit si on doit répandre l'évenement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| if(nouvelleDonnees instanceof Tree) { |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| // on prend sa racine et on l'attache à l'arbre des mots clés |
| Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!arbreCharge) { |
| // on signale que oui |
| arbreCharge = true; |
| } |
| // 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 obs) |
| if (nouvelleDonnees instanceof String) { |
| String chaineMc = (String)nouvelleDonnees; |
| String[] motsClesIds = chaineMc.split(";"); |
| // 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 |
| cocherMotsCles(motsClesIds); |
| } |
| // si l'arbre n'est pas encore instancié on met les mots clés en |
| // attente |
| else { |
| motsClesEnAttente = motsClesIds; |
| } |
| } |
| } |
| private String genererIdMotCle(TreeNode nd) { |
| double IdMC = (nd.hashCode() + ((Math.random() * 10000) + 1)); |
| return ""+IdMC; |
| } |
| /** |
| * 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.setUserObject(usObj); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreMotsCles.collapseAll(); |
| arbreMotsCles.clear() ; |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Projets"); |
| root.setId("racine_obs"); |
| String[] usObject = { "Projets", "racine_obs" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirArbreMotsCles() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| motsClesEnCours = ""; |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String val = ""; |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| for(int i = 0; i< noeuds.length ; i++) { |
| if(noeuds[i].getDepth() > 0) { |
| val += ";"+noeuds[i].getId(); |
| } |
| } |
| val = val.replaceFirst(";", ""); |
| String[] valeursFiltres = {"id_mots_cles", val}; |
| return valeursFiltres; |
| } |
| @Override |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void montrerContextMenuArbre(final TreeNode n, EventObject e, |
| TreeEditor te) { |
| Menu mn = new Menu(); |
| final com.gwtext.client.widgets.menu.Item ajoutN = new Item( |
| "Ajouter un projet"); |
| final com.gwtext.client.widgets.menu.Item suppN = new Item( |
| "Supprimer projet"); |
| mn.addItem(ajoutN); |
| mn.addItem(suppN); |
| mn.addListener(new MenuListenerAdapter() { |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| if (item.equals(suppN)) { |
| supprimerNoeud(n); |
| } |
| if (item.equals(ajoutN)) { |
| ajouterNoeud(n); |
| } |
| } |
| }); |
| mn.showAt(e.getXY()); |
| } |
| @Override |
| public void viderFiltre() { |
| arbreMotsCles.getSelectionModel().clearSelections(); |
| motsClesEnCours = ""; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/filtres/RechercheLibreVue.java |
|---|
| New file |
| 0,0 → 1,116 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| 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.TextField; |
| public class RechercheLibreVue extends Panel implements Filtrable { |
| private ObservationMediateur oMediateur = 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 RechercheLibreVue(ObservationMediateur om) { |
| super(titrePanneau); |
| oMediateur = om; |
| champRecherche = new TextField(); |
| champRecherche.setWidth("90%"); |
| boutonRechercher = new Button("Rechercher"); |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| break; |
| } |
| } |
| }); |
| add(champRecherche); |
| add(boutonRechercher); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setPaddings(5); |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return estModifie; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Recherche libre"; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String nom = "recherche"; |
| if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) { |
| valeurRecherchee = champRecherche.getValueAsString(); |
| } else { |
| valeurRecherchee = ""; |
| } |
| String[] valeurs = {nom,valeurRecherchee}; |
| return valeurs; |
| } |
| @Override |
| public void valider() { |
| if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) { |
| estModifie = true; |
| oMediateur.obtenirNombreObservation(); |
| } else { |
| estModifie = false; |
| } |
| } |
| public void raz() { |
| if(champRecherche.isCreated()) { |
| champRecherche.reset(); |
| valeurRecherchee = ""; |
| } |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| valeurRecherchee = ""; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.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.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| 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 |
| @Override |
| 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() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| nomFiltre = "" ; |
| entitesGeographiquesEncours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| String nomArriereGrandPere = ""; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(!arbreCharge) |
| { |
| arbreEntitesGeographiques.getRootNode().expand(); |
| } |
| else |
| { |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| return ; |
| case 4: nomFiltre += "station,lieudit,commune,departement"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
| nomArriereGrandPere = ((String[])node.getParentNode().getParentNode().getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere+","+nomArriereGrandPere ; |
| break; |
| case 3: nomFiltre += "lieudit,commune,departement"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ; |
| break; |
| case 2: nomFiltre += "commune,departement"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere ; |
| break; |
| case 1: nomFiltre += "departement"; |
| entitesGeographiquesEncours += node.getText() ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = true ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| entitesGeographiquesEncours = ""; |
| 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() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) { |
| 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 vide tous les noeuds |
| arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| EntiteGeographiqueObservation ent=data.get(it.next()); |
| creerHierarchieNoeud(nouvelArbre ,root, ent); |
| doLayout(); |
| } |
| copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode()); |
| arbreEntitesGeographiques.getRootNode().sort(comparerNoeuds()) ; |
| // 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 ; |
| EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(obs.getIdentifiantLocalite(),obs.getLocalite(),obs.getLieudit(),obs.getStation()); |
| creerHierarchieNoeud(arbreEntitesGeographiques.getTree(), arbreEntitesGeographiques.getRootNode(), ent); |
| doLayout(); |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| 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.getId() ; |
| String n2 = o2.getId() ; |
| return n1.compareToIgnoreCase(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() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| entitesGeographiquesEncours = ""; |
| } |
| private TreeNode creerNoeud(String id, String texte) { |
| TreeNode nouveauNoeud = new TreeNode(); |
| nouveauNoeud.setId(""+(id)); |
| nouveauNoeud.setText(texte); |
| String[] usObj = {texte,id+""}; |
| nouveauNoeud.setUserObject(usObj); |
| return nouveauNoeud; |
| } |
| /** |
| * |
| * @param arbre l'arbre dans lequel on recherche s'il faut créer les noeuds |
| * @param root le noeud racine auquel on concatène la hierarchie crée |
| * @param ent l'entité géographique qui doit être décomposée en arborescence |
| * @return |
| */ |
| private void creerHierarchieNoeud(Tree arbre, TreeNode root, EntiteGeographiqueObservation ent) { |
| String id_zone_geo=null; |
| String zone_geo=null; |
| String lieuDit=null; |
| String station=null; |
| // TODO creer une fonction plus efficace lors du passage au multi reférentiel |
| id_zone_geo = Util.convertirChaineZoneGeoVersDepartement(ent.getIdZoneGeo()); |
| id_zone_geo = id_zone_geo.replaceAll("\"", ""); |
| id_zone_geo = id_zone_geo.replace('\\',' '); |
| id_zone_geo = id_zone_geo.trim(); |
| zone_geo = ent.getZoneGeo(); |
| lieuDit = ent.getLieuDit(); |
| station = ent.getStation(); |
| if(id_zone_geo.contains("000null") || id_zone_geo.equals(null) || (id_zone_geo.trim()).equals("")) { |
| id_zone_geo="Inconnue" ; |
| } |
| if(zone_geo.contains("000null") || zone_geo.equals(null) || (zone_geo.trim().equals(""))) { |
| zone_geo="Inconnue" ; |
| } |
| if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) { |
| lieuDit="Inconnue" ; |
| } |
| if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) { |
| station="Inconnue" ; |
| } |
| Node noeudMemeId = arbre.getNodeById(""+id_zone_geo); |
| if(noeudMemeId == null) { |
| // on crée le noeud de l'identifiant zone_geo |
| noeudMemeId = creerNoeud(""+id_zone_geo,id_zone_geo); |
| root.appendChild(noeudMemeId) ; |
| } |
| // on teste si la localité existe |
| Node noeudMemeLoc = arbre.getNodeById(""+(id_zone_geo+zone_geo)); |
| if(noeudMemeLoc == null) |
| { |
| // on crée le noeud de la zone_geo |
| noeudMemeLoc = creerNoeud(""+id_zone_geo+zone_geo, zone_geo); |
| noeudMemeId.appendChild(noeudMemeLoc) ; |
| } |
| // on teste si le lieu dit existe |
| Node noeudMemeLieu = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit)); |
| if(noeudMemeLieu == null) |
| { |
| // on crée le noeud du lieu dit |
| noeudMemeLieu = creerNoeud(id_zone_geo+zone_geo+lieuDit, lieuDit); |
| noeudMemeLoc.appendChild(noeudMemeLieu) ; |
| } |
| // on teste si la station existe |
| Node noeudMemeStation = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit+station)); |
| if(noeudMemeStation == null) { |
| // on crée le noeud de la station |
| noeudMemeStation = creerNoeud(id_zone_geo+zone_geo+lieuDit+station,station); |
| noeudMemeLieu.appendChild(noeudMemeStation); |
| } |
| root.sort(comparerNoeuds()) ; |
| } |
| @Override |
| public void viderFiltre() { |
| arbreEntitesGeographiques.getSelectionModel().clearSelections(); |
| entitesGeographiquesEncours =""; |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreEntitesGeographiques.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreEntitesGeographiques.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreEntitesGeographiques.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("departement")) { |
| profondeur = 1; |
| } |
| if(nom.equals("commune")) { |
| profondeur = 2; |
| } |
| if(nom.equals("lieudit")) { |
| profondeur = 3; |
| } |
| if(nom.equals("station")) { |
| profondeur = 4; |
| } |
| return profondeur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,683 |
| 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.objets.DateObservation; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| 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 |
| @Override |
| 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() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| 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 ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| donneesDateEnCours = ""; |
| 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() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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", "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=data.get(it.next()); |
| annee= ent.getAnnee() ; |
| mois= ent.getMois() ; |
| String moisLettre = Util.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() { |
| @Override |
| 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 = Util.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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| public int compare(TreeNode o1, TreeNode o2) { |
| String n1 = ((String[])o1.getUserObject())[1] ; |
| String n2 = ((String[])o2.getUserObject())[1] ; |
| return n1.compareTo(n2) ; |
| } |
| } ; |
| } |
| 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() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| donneesDateEnCours = ""; |
| } |
| @Override |
| public void viderFiltre() { |
| arbreDonneesDates.getSelectionModel().clearSelections(); |
| donneesDateEnCours = ""; |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreDonneesDates.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("annee")) { |
| profondeur = 1; |
| } |
| if(nom.equals("mois")) { |
| profondeur = 2; |
| } |
| if(nom.equals("jour")) { |
| profondeur = 3; |
| } |
| return profondeur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java |
|---|
| New file |
| 0,0 → 1,209 |
| 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() { |
| @Override |
| 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); |
| imgZoom.setConstrain(true); |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| this.setCls("x-image-info-rep") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage carte de repartition |
| * |
| */ |
| @Override |
| 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 height="+Window.getClientHeight()*0.75+"px src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.show(this.getElement()) ; |
| } else { |
| imgZoom.hide(); |
| } |
| } |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java |
|---|
| New file |
| 0,0 → 1,215 |
| 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 String urlImageMax = "" ; |
| 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() { |
| @Override |
| 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") ; |
| imgZoom.setConstrain(true); |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| add(image); |
| image.setPixelSize(150, 150); |
| image.sinkEvents(Event.ONDBLCLICK); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage image generique |
| * |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String []) { |
| String [] lecteurDonnees = (String []) nouvelleDonnees; |
| urlImage=lecteurDonnees[0]; |
| urlImageMax=lecteurDonnees[1]; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0 || urlImage.equals("")) { |
| image.setUrl("ill_taxon.png") ; |
| image.setPixelSize(150, 150); |
| } |
| else { |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } else { |
| image.setUrl("ill_taxon.png") ; |
| image.setPixelSize(150, 150); |
| } |
| observationMediateur.deMasquerChargementInfosObservations() ; |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| imgZoom.setHtml("<img height="+Window.getClientHeight()*0.75+"px src=\""+urlImageMax+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.show(this.getElement()) ; |
| } else { |
| imgZoom.hide(); |
| } |
| } |
| /** |
| * 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/indicateurs/LienExterneVue.java |
|---|
| New file |
| 0,0 → 1,71 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| 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.widgets.Panel; |
| public class LienExterneVue extends Panel implements Rafraichissable { |
| private ObservationMediateur oMediateur = null; |
| private String refTax = ""; |
| private String refTaxVersion = ""; |
| private String numTax = ""; |
| private String efloreBaseUrl = ""; |
| private Label titreLien = new Label("Voir la fiche eflore"); |
| public LienExterneVue(ObservationMediateur om) { |
| oMediateur = om; |
| refTax = om.getRefTaxSelectionne().getCode(); |
| refTaxVersion = om.getRefTaxSelectionne().getVersionCourte(); |
| efloreBaseUrl = Configuration.getLienEfloreBaseUrl(); |
| titreLien.setVisible(false); |
| setBorder(false); |
| titreLien.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(!numTax.trim().equals("")) { |
| Window.open("http://"+efloreBaseUrl+"/"+refTax+"-nn-"+numTax,"",""); |
| } |
| } |
| }); |
| titreLien.setStyleName("lien_actif"); |
| add(titreLien); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof String && !((String)nouvelleDonnees).trim().equals("")) { |
| if(!titreLien.isVisible()) { |
| titreLien.setVisible(true); |
| } |
| numTax = (String)nouvelleDonnees; |
| } else { |
| titreLien.setVisible(false); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,597 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.event.dom.client.LoadEvent; |
| import com.google.gwt.event.dom.client.LoadHandler; |
| 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.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; |
| /** |
| * Le titre du panneau |
| */ |
| private static String titrePanneau = "Images liées"; |
| /** |
| * 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(titrePanneau); |
| 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) ; |
| imgZoom.setConstrain(true); |
| // on crée une image qui gère le double clic et la roulette de la souris |
| image = new Image() { |
| @Override |
| 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)) { |
| if(imgZoom.isVisible()) { |
| imgZoom.hide(); |
| } else { |
| 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 |
| */ |
| @Override |
| 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) |
| { |
| setTitle(titrePanneau+" "+(index+1)+" / "+infosImages.length); |
| getImage().setUrl(getUrlMiniature(index)); |
| imageWidth = Integer.parseInt(infosImages[index][1]); |
| imageHeight = Integer.parseInt(infosImages[index][2]); |
| verifierEtRetaillerImage(); |
| activerPanneau(true); |
| } else { |
| setTitle(titrePanneau); |
| getImage().setUrl("ill_liaison.png"); |
| imageWidth = getImage().getWidth(); |
| imageHeight = getImage().getHeight(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| activerPanneau(false); |
| } |
| if(infosImages != null && infosImages.length > 1) { |
| prev.setEnabled(true); |
| suiv.setEnabled(true); |
| } else { |
| prev.setEnabled(false); |
| suiv.setEnabled(false); |
| } |
| } |
| /** |
| * Active visuellement le panneau et les boutons |
| */ |
| public void activerPanneau(boolean activer) { |
| if(activer) { |
| this.getEl().unmask(); |
| } else { |
| this.getEl().mask(); |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| // gestion du clic sur le bouton précedent |
| prev.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(infosImages.length != 0) { |
| if(index == 0) |
| { |
| index = infosImages.length - 1 ; |
| } |
| else |
| { |
| index-- ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickHandler(new ClickHandler() { |
| // en cas de clic |
| @Override |
| public void onClick(ClickEvent event) { |
| 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() { |
| @Override |
| 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) ; |
| } |
| /** |
| * 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 = {(int)Math.round(XYresize[0]*0.85),(int)Math.round(XYresize[1]*0.85)} ; |
| return res; |
| } |
| protected void agrandirImage() { |
| String urlAgrandie = ""; |
| if(infosImages == null) { |
| urlAgrandie = "ill_liaison.png"; |
| setTailleImage(265, 270); |
| } else { |
| urlAgrandie = getUrlAgrandie(index); |
| } |
| if(imgAgrandie == null) { |
| imgAgrandie = new Image(urlAgrandie); |
| imgZoom.add(imgAgrandie); |
| imgAgrandie.addLoadHandler(new LoadHandler() { |
| @Override |
| public void onLoad(LoadEvent event) { |
| int[] tailleImage = calculerDimensions(getTailleImage(),getTailleImage()[1],Window.getClientHeight()*0.75); |
| ExtElement imgElement = Ext.get(imgAgrandie.getElement()); |
| if(animerTransition) { |
| AnimationConfig a = new AnimationConfig() ; |
| a.setDuration(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 String getUrlMiniature(int index) { |
| String[][] paramsImage = {{"id_image",infosImages[index][0]}}; |
| ImageCarnet ic = new ImageCarnet(paramsImage); |
| return ic.getUrlFormatGalerie(); |
| } |
| private String getUrlAgrandie(int index) { |
| String[][] paramsImage = {{"id_image",infosImages[index][0]}}; |
| ImageCarnet ic = new ImageCarnet(paramsImage); |
| return ic.getUrlFormatZoom(); |
| } |
| private void afficherPanneauAgrandi() { |
| agrandirImage(); |
| imgZoom.show(this.getElement()); |
| imgZoom.setPosition((int)(Window.getClientWidth() - Window.getClientWidth()*0.50),(int)(Window.getClientHeight() - Window.getClientHeight()*0.85)); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/FormulaireImportObservationVue.java |
|---|
| New file |
| 0,0 → 1,86 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.ui.FileUpload; |
| import com.google.gwt.user.client.ui.FormPanel; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteEvent; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteHandler; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.HasAlignment; |
| import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
| import com.google.gwt.user.client.ui.Hidden; |
| import com.google.gwt.user.client.ui.VerticalPanel; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| public class FormulaireImportObservationVue { |
| private ObservationMediateur oMediateur = null; |
| private Window nPan = null; |
| private Hidden identifiant = null; |
| public FormulaireImportObservationVue(ObservationMediateur om) { |
| this.oMediateur = om; |
| nPan = new Window("Import d'observations"); |
| identifiant = new Hidden(); |
| identifiant.setName("utilisateur"); |
| identifiant.setValue(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| final FormPanel form = new FormPanel(); |
| final Button boutonValidation = new Button("envoyer"); |
| form.setEncoding(FormPanel.ENCODING_MULTIPART); |
| form.setMethod(FormPanel.METHOD_POST); |
| form.setWidth("275px"); |
| nPan.setWidth("275px"); |
| VerticalPanel holder = new VerticalPanel(); |
| FileUpload upload = new FileUpload(); |
| upload.setName("upload"); |
| holder.add(upload); |
| holder.add(boutonValidation); |
| holder.add(identifiant); |
| HTML lienVersDocumentModele = new HTML("<a href=\"modele_import.xls\">Télécharger le modèle de document</a>"); |
| holder.add(lienVersDocumentModele); |
| holder.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT); |
| boutonValidation.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| form.submit(); |
| } |
| }); |
| form.add(holder); |
| nPan.add(form); |
| form.setAction(Configuration.getServiceBaseUrl() + "/ImportXLS"); |
| form.addSubmitCompleteHandler(new SubmitCompleteHandler() { |
| @Override |
| public void onSubmitComplete(SubmitCompleteEvent event) { |
| nPan.close(); |
| // TODO: le résultat est du texte, mais à l'avenir il faudrait utiliser du JSON |
| com.google.gwt.user.client.Window.alert(event.getResults()); |
| oMediateur.obtenirDernierePageObservation(); |
| } |
| }); |
| } |
| public void afficher() { |
| nPan.show(); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,972 |
| package org.tela_botanica.client.vues.observation; |
| import java.util.Iterator; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Ontologies; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| 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.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.core.SortDir; |
| import com.gwtext.client.data.ArrayReader; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.IntegerFieldDef; |
| import com.gwtext.client.data.MemoryProxy; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.SortState; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragDropConfig; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.dd.DropTarget; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| 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.GridHeaderListenerAdapter; |
| import com.gwtext.client.widgets.grid.event.GridListenerAdapter; |
| import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter; |
| import com.gwtext.client.widgets.tree.TreeDragData; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| /** |
| * 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; |
| private ColumnConfig referentielTaxoObservation; |
| private ColumnConfig nomSaisiObservation; |
| private ColumnConfig nomRetenuObservation; |
| private ColumnConfig familleObservation; |
| private ColumnConfig lieuObservation; |
| private ColumnConfig altitudeObservation; |
| private ColumnConfig dateObservation; |
| private ColumnConfig ordreObservation; |
| private ColumnConfig abondanceObservation; |
| private ColumnConfig certitudeObservation; |
| 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"; |
| private boolean tailleInitialisee = false ; |
| private ColumnConfig phenologieObservation; |
| private SortDir directionTri; |
| private String champTri; |
| private boolean triActif; |
| /** |
| * 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; |
| setId("x-list-obs"); |
| setHeader(true); |
| // on place la barre de pagination |
| bt = new BarrePaginationVue(this); |
| bt.setLabelElement("Observations"); |
| bt.setTaillePageParDefaut(20); |
| bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ; |
| Toolbar barreActions = new Toolbar(); |
| ToolbarButton publier = new ToolbarButton("Rendre publiques"); |
| publier.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(true); |
| } |
| }); |
| ToolbarButton privatiser = new ToolbarButton("Rendre privées"); |
| privatiser.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(false); |
| } |
| }); |
| ToolbarButton supprimer = new ToolbarButton("Supprimer"); |
| supprimer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.supprimerObservations(); |
| } |
| }); |
| ToolbarButton importer = new ToolbarButton("Importer"); |
| importer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.afficherFormulaireImportObservation(); |
| } |
| }); |
| ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>"); |
| ToolbarTextItem exporterFull = new ToolbarTextItem("<a href=\"#\" id=\"lienExportFull\" title=\"Export des noms communs, des champs étendus, des données baseflor et des syntaxon baseveg\"> Export Étendu </a>"); |
| ToolbarTextItem exporterPDF = new ToolbarTextItem("<a href=\"#\" id=\"lienExportPDF\" title=\"Génération d'étiquettes au format PDF pour la sélection\"> Étiquettes </a>"); |
| barreActions.addButton(publier); |
| barreActions.addButton(privatiser); |
| barreActions.addSpacer(); |
| barreActions.addButton(supprimer); |
| barreActions.addSpacer(); |
| barreActions.addButton(importer); |
| barreActions.addSpacer(); |
| barreActions.addItem(exporter); |
| barreActions.addItem(exporterFull); |
| barreActions.addItem(exporterPDF); |
| this.setTopToolbar(barreActions) ; |
| this.setBottomToolbar(bt); |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| this.setTitle("Observations") ; |
| modeleColonnes = new ColumnModel(getConfigColonnes()); |
| this.setColumnModel(modeleColonnes); |
| this.setAutoScroll(true); |
| this.setEnableColumnResize(true); |
| // creation du store |
| RecordDef rd = new RecordDef(getDefinitionChamps()); |
| 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(); |
| configDragAndDrop(); |
| } |
| private ColumnConfig[] getConfigColonnes() { |
| // 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() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| String valeur = ""; |
| if(value != null && !value.equals("null") && !value.equals("000null") && !value.equals("0000-00-00 00:00:00")) { |
| valeur = value.toString() ; |
| } |
| return valeur; |
| } |
| } ; |
| Renderer dateRend = new Renderer() { |
| @Override |
| 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() { |
| @Override |
| 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 "" ; |
| } |
| } |
| }); |
| referentielTaxoObservation = new ColumnConfig("Référentiel", "referentiel_taxo_observation", 15, true, colRend); |
| nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 130, true, colRend); |
| nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 130, true, colRend); |
| familleObservation = new ColumnConfig("Famille", "famille_observation", 50, true, colRend); |
| lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 130, true, colRend); |
| altitudeObservation = new ColumnConfig("Alt", "altitude_observation", 10, true, colRend); |
| dateObservation = new ColumnConfig("Date", "date_observation", 70, true, dateRend); |
| abondanceObservation = new ColumnConfig("Abondance", "abondance", 50, true, colRend); |
| certitudeObservation = new ColumnConfig("Identification", "certitude", 50, true, new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| return Ontologies.getCorrespondanceCertitude(record.getAsString("certitude")); |
| } |
| }); |
| phenologieObservation = new ColumnConfig("Phénologie", "phenologie", 40, true, colRend); |
| ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 70, true, colRend); |
| ColumnConfig[] cm = {etatObservation, referentielTaxoObservation, |
| nomSaisiObservation, certitudeObservation, |
| nomRetenuObservation, familleObservation, |
| abondanceObservation, phenologieObservation, |
| lieuObservation, altitudeObservation, |
| dateObservation, ordreObservation}; |
| return cm; |
| } |
| /** |
| * Ajoute les listeners pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| this.addGridHeaderListener(new GridHeaderListenerAdapter() { |
| @Override |
| public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) { |
| triActif = true; |
| } |
| }); |
| this.addGridRowListener(new GridRowListenerAdapter() { |
| // gestion du clic sur une ligne |
| @Override |
| 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 = st.getAt(rowIndex); |
| String ordreObservation = rd.getAsString("ordre_observation") ; |
| observationMediateur.onClicListeObservation(rowIndex,ordreObservation); |
| } |
| // gestion du clic droit |
| @Override |
| 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 |
| @Override |
| 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() { |
| @Override |
| 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() { |
| @Override |
| public void onRender(Component c) { |
| ExtElement lienExport = Ext.get("lienExport") ; |
| lienExport.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| observationMediateur.exporterObservations("xls", "standard"); |
| } |
| }); |
| ExtElement lienExportFull = Ext.get("lienExportFull") ; |
| lienExportFull.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| observationMediateur.exporterObservations("xls", "standard,avance,etendu,baseflor"); |
| } |
| }); |
| ExtElement lienExportPDF = Ext.get("lienExportPDF") ; |
| lienExportPDF.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| observationMediateur.exporterObservationsPDF(); |
| } |
| }); |
| } |
| }); |
| this.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onBodyResize(Panel panel, java.lang.String width, java.lang.String height) { |
| doLayout(); |
| } |
| }); |
| } |
| /** |
| * Configure le drag 'n drop pour la liste |
| */ |
| private void configDragAndDrop() |
| { |
| setDdGroup("ObsMotsClesGroup"); |
| setEnableDragDrop(true); |
| setDragDropText("Glissez les observations sélectionnées sur un projet pour les lier"); |
| // 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("ObsMotsClesGroup"); |
| dtc.setTarget(true); |
| DragDropConfig ddc = new DragDropConfig(); |
| //La drop target permet de gérer l'évenement onDrop sur l'élement courant |
| @SuppressWarnings("unused") |
| DropTarget tg = new DropTarget(this, dtc) |
| { |
| @Override |
| public boolean notifyDrop(DragSource source, EventObject e, DragData data){ |
| // si on reçoit des données provenant d'un arbre |
| // on les convertit |
| if(data instanceof TreeDragData) { |
| TreeDragData tdd = (TreeDragData)data ; |
| TreeNode treeNode = tdd.getTreeNode(); |
| String idMc = treeNode.getId(); |
| int index = getView().findRowIndex(e); |
| if(index < 0) { |
| return true; |
| } |
| Record obsRd = getStore().getRecordAt(index); |
| if(obsRd == null) { |
| return true; |
| } |
| String ordreObs = obsRd.getAsString("ordre_observation"); |
| if(ordreObs != null) { |
| observationMediateur.gererDDMotCleSurObs(ordreObs, idMc); |
| return true ; |
| } else { |
| return true; |
| } |
| } |
| return true; |
| } |
| @Override |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| if(data instanceof TreeDragData) { |
| TreeDragData tdd = (TreeDragData)data ; |
| TreeNode treeNode = tdd.getTreeNode(); |
| String idMc = treeNode.getId(); |
| int index = getView().findRowIndex(e); |
| if(index < 0) { |
| return "x-dd-drop-nodrop"; |
| } |
| Record obsRd = getStore().getRecordAt(index); |
| if(obsRd == null) { |
| return "x-dd-drop-nodrop"; |
| } |
| String ordreObs = obsRd.getAsString("ordre_observation"); |
| if(ordreObs != null) { |
| return observationMediateur.gererOverDDMotCleSurObs(ordreObs, idMc); |
| } |
| } |
| return "x-dd-drop-nodrop"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface VueListable |
| * Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres |
| */ |
| @Override |
| 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) { |
| 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 |
| */ |
| @Override |
| 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()][13]; |
| 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=data.get(it.next()); |
| observationData[i][0] = obs.getTransmis(); |
| observationData[i][1] = obs.getCodeCourtReferentielTaxo(); |
| observationData[i][2] = obs.getNomSaisi(); |
| observationData[i][3] = obs.getCertitude(); |
| observationData[i][4] = obs.getNomRetenu(); |
| observationData[i][5] = obs.getFamille(); |
| observationData[i][6] = obs.getAbondance(); |
| observationData[i][7] = obs.getPhenologie(); |
| observationData[i][8] = Util.formaterLieu(obs, modeleLieu); |
| observationData[i][9] = formaterAltitude(obs.getAltitude()); |
| observationData[i][10] = obs.getDate(); |
| observationData[i][11] = obs.getNumeroOrdre(); |
| observationData[i][12] = obs.getNumeroNomenclaturalSaisi(); |
| i++ ; |
| } |
| RecordDef rd = new RecordDef(getDefinitionChamps()); |
| 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]) ; |
| if(nbElements > 0) { |
| masquerChargement(); |
| observationMediateur.obtenirListeObservation(this); |
| } else { |
| this.rafraichir(new ListeObservation(0), false); |
| } |
| } |
| // si l'on a reçu une Observation |
| if(nouvelleDonnees instanceof Observation) { |
| // la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri |
| // on l'enregistre donc avant suppression |
| enregistrerEtatTri(); |
| 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) |
| { |
| // la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri |
| // on l'enregistre donc avant suppression |
| enregistrerEtatTri(); |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| if(!getTailleInitialisee()) { |
| if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) { |
| doLayout(); |
| setTailleInitialisee(); |
| } |
| } |
| // réaffectation du tri courant si nécessaire |
| if(directionTri != null && champTri != null) { |
| st.sort(champTri, directionTri); |
| } |
| } |
| private String formaterAltitude(String alt) { |
| String alfFmt = Util.formaterNombre(alt); |
| if(!alfFmt.isEmpty() && !Util.estZero(alfFmt)) { |
| alfFmt = alfFmt+" m."; |
| } |
| return alfFmt; |
| } |
| private FieldDef[] getDefinitionChamps() { |
| // creation du store qui les contient |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defRefTaxObservation = new StringFieldDef("referentiel_taxo_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defCertitudeObservation = new StringFieldDef("certitude"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defFamilleObservation = new StringFieldDef("famille_observation"); |
| FieldDef defAbondanceObservation = new StringFieldDef("abondance"); |
| FieldDef defPhenologieObservation = new StringFieldDef("phenologie"); |
| FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
| FieldDef defAltObservation = new StringFieldDef("altitude_observation"); |
| FieldDef defDateObservation = new StringFieldDef("date_observation"); |
| FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation"); |
| // Non affiches : |
| FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation"); |
| FieldDef[] defTab = {defEtatObservation, defRefTaxObservation,defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defFamilleObservation, defAbondanceObservation, |
| defPhenologieObservation, defLieuObservation, defAltObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation }; |
| return defTab; |
| } |
| // 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) arrondi à l'entier superieur |
| double nPage = (1.0*nbElements)/(1.0*taillePage) ; |
| double nPageRound = Math.ceil(nPage) ; |
| Double nPageInt = new Double(nPageRound) ; |
| 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) ; |
| 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 |
| */ |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| pageEncours = pageCourante ; |
| masquerChargement(); |
| enregistrerEtatTri(); |
| // 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 |
| */ |
| @Override |
| public void changerTaillePage(int nouvelleTaillePage) { |
| taillePage = nouvelleTaillePage ; |
| pageEncours = calculerPageCourante(nbElements) ; |
| enregistrerEtatTri(); |
| 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; |
| } |
| private void enregistrerEtatTri() { |
| if(triActif) { |
| this.directionTri = st.getSortState().getDirection(); |
| this.champTri = st.getSortState().getField(); |
| } |
| } |
| public void afficherFiltres(String[][] filtresEnCours) { |
| String texteFiltresEnCours = ""; |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours += " - "; |
| } |
| texteFiltresEnCours += "<span class=\"affichage_filtre\">"+ |
| transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+ |
| " <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_obs_"+filtresEnCours[i][0]+"\" />"+ |
| "</span>"; |
| } |
| } |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>"; |
| } |
| this.setTitle("Observations"+texteFiltresEnCours) ; |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]) != null) { |
| Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]).addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| e.stopEvent(); |
| observationMediateur.viderFiltre(e.getTarget().getAttribute("rel")); |
| } |
| }); |
| } |
| } |
| } |
| } |
| private String transformerNomFiltre(String nomFiltre) { |
| if(nomFiltre.equals("departement")) { |
| nomFiltre = "departement"; |
| } |
| if(nomFiltre.equals("commune")) { |
| nomFiltre = "commune"; |
| } |
| if(nomFiltre.equals("nom_taxon")) { |
| nomFiltre = "recherche"; |
| } |
| if(nomFiltre.equals("id_mots_cles")) { |
| nomFiltre = "projets"; |
| } |
| return nomFiltre; |
| } |
| private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) { |
| String valeurFiltreTransformee = valeurFiltre; |
| if(nomFiltre.equals("id_mots_cles")) { |
| String[] tabMotsCles = valeurFiltre.split(";"); |
| String[] tabMotsClesTexte = observationMediateur.obtenirTexteMotsCles(tabMotsCles); |
| if(tabMotsClesTexte.length > 1) { |
| valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte); |
| } else { |
| valeurFiltreTransformee = tabMotsClesTexte[0]; |
| } |
| } |
| if(nomFiltre.equals("mois")) { |
| valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre)); |
| } |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("000null", "inconnue"); |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", "inconnue"); |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", "inconnue"); |
| return valeurFiltreTransformee; |
| } |
| public void raz() { |
| RecordDef rd = new RecordDef(getDefinitionChamps()); |
| 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; |
| } |
| } |
| public boolean getTailleInitialisee() { |
| return tailleInitialisee ; |
| } |
| public void setTailleInitialisee() { |
| tailleInitialisee = true; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java |
|---|
| New file |
| 0,0 → 1,196 |
| 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() { |
| @Override |
| public void onKey(int key, EventObject e) { |
| valider(); |
| } |
| }); |
| ok.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| afficherNuage.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| // oMediateur.afficherNuageMotsCles(); |
| } |
| }); |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| oMediateur.obtenirNombreObservation(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| motsAChercher = ""; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java |
|---|
| New file |
| 0,0 → 1,2222 |
| package org.tela_botanica.client.vues.observation; |
| // TODO Detecter redim et supprimer ajuster |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.ChampEtendu; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielCommune; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielNom; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Ontologies; |
| import org.tela_botanica.client.modeles.objets.ReferentielCommune; |
| import org.tela_botanica.client.modeles.objets.ReferentielNom; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.AutoCompletionRefComboBox; |
| import org.tela_botanica.client.util.ChampSaisieEtendu; |
| import org.tela_botanica.client.util.FormulaireSaisieChampEtendu; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.PopupPanel; |
| 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.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.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.DatePicker; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| 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.Label; |
| import com.gwtext.client.widgets.form.MultiFieldPanel; |
| 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.form.event.TextFieldListenerAdapter; |
| 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 ComboBox lieudit = null; |
| private ComboBox station = null; |
| private ComboBox 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; |
| private String codeInseeCommune = null; |
| private String referentielTaxo = null; |
| private String referentielGeo = null; |
| // Pour remise a zero partielle lors d'une validation |
| private enum Champs { |
| DATE, LIEUDIT, STATION, MILIEU, COMMENT, COMMUNE, ESPECE, TOUT, LATITUDE, LONGITUDE, ALTITUDE, ABONDANCE, CERTITUDE, REFERENTIELTAXO, PHENOLOGIE; |
| @Override |
| 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 LATITUDE: |
| return "latitude"; |
| case LONGITUDE: |
| return "longitude"; |
| case ALTITUDE: |
| return "altitude"; |
| case ABONDANCE: |
| return "abondance"; |
| case CERTITUDE: |
| return "identification"; |
| case REFERENTIELTAXO: |
| return "referentiel"; |
| case PHENOLOGIE: |
| return "phenologie"; |
| case TOUT: |
| return "date, commune, lieu dit, station, milieu, espèce, commentaire, latitude, longitude, altitude, abondance, identification, referentiel, phenologie"; |
| } |
| return TOUT.toString(); |
| } |
| }; |
| private String formatDate = null ; |
| private Button boutonOK = new Button("Créer"); |
| private Button boutonModifier = new Button("Modifier"); |
| private Button boutonSupprimer = new Button("Supprimer"); |
| private Button boutonAnnuler = new Button("Réinitialiser"); |
| private boolean selectionCommune=false; |
| private boolean selectionEspece=false; |
| private boolean selectionAbondance = false; |
| private boolean selectionCertitude = false; |
| private boolean selectionPhenologie = false; |
| private Toolbar bt = null ; |
| private final String VALEURS_MULTIPLES = "(Valeurs multiples)"; |
| private final String modeleMessageModif = "commune:lieu-dit:station:milieu:latitude:longitude:altitude:date:espece:commentaire:abondance:identification:referentiel:phenologie"; |
| 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 boolean abondanceModifiee = false; |
| private boolean certitudeModifiee = false; |
| private boolean referentielTaxoModifie = false; |
| private boolean phenologieModifiee = 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; |
| /** |
| * Booleen d'instanciation |
| */ |
| boolean estInstancie = false ; |
| private Panel panneauIntermediaire; |
| private Panel panneauPremierColonne; |
| private Panel panneauSecondeColonne; |
| private TextField longitude; |
| private TextField latitude; |
| private TextField altitude; |
| private MultiFieldPanel htmlCommunePanel = null; |
| private MultiFieldPanel coordPanel; |
| private TextField coordonnees; |
| private Label lienSelectionCommune = null; |
| private HTML afficherFormulaireLatLon; |
| private HTML basculerverscarto; |
| private boolean longlatAjoutee; |
| private boolean latModifiee; |
| private boolean longModifiee; |
| private boolean altModifiee; |
| protected boolean rechercheCommuneEnCours = false; |
| private Timer tCoord; |
| final String resultTplRefPerso = "<div class=\"search-item-commune\">{element_referentiel}</div>"; |
| private ComboBox selecteurAbondance = null; |
| private ComboBox selecteurCertitude = null; |
| private ComboBox selecteurReferentielTaxo = null; |
| private ComboBox selecteurStadePheno = null; |
| private boolean selectionMultiple = false; |
| private HTML lienAfficherChampsEtendus = null; |
| private HTML lienAjouterChampsEtendus = null; |
| Panel conteneurChampEtenduGauche = null; |
| Panel conteneurChampEtenduDroite = null; |
| private boolean afficherChampsEtendus = false; |
| private boolean afficherLienAjoutChampsEtendus = false; |
| private boolean premierAffichage = true; |
| private PopupPanel popUpAjoutChampEtendu = new PopupPanel(); |
| private Map<String, ChampSaisieEtendu> listeChampsEtendus; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private FormulaireSaisieObservationVue() |
| { |
| super() ; |
| } |
| /** |
| * Constructeur avec argument |
| * @param im |
| */ |
| public FormulaireSaisieObservationVue(ObservationMediateur obs) |
| { |
| super("Saisie"); |
| // on associe le médiateur |
| observationMediateur = obs ; |
| referentielTaxo = obs.getRefTaxSelectionne().getCode(); |
| 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); |
| //création du panneau formulaire de gauche auquels on ajoute les champs |
| panneauPremierColonne = new Panel(); |
| panneauPremierColonne.setLayout(new FormLayout()); |
| panneauPremierColonne.setBorder(false); |
| //création du panneau formulaire de droite |
| 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.setItemSelector("div.search-item-commune"); |
| commune.setTypeAhead(true); |
| commune.setLoadingText("Recherche..."); |
| commune.setHideTrigger(true); |
| //création du lien "Accès carto" dans le formulaire |
| basculerverscarto = new HTML(" <a id=\"lien_carto\" href=\"#\" tabindex=\"2\">Localiser la commune</a>"); |
| basculerverscarto.addStyleName("lien_actif"); |
| //création info bulle sur le lien "accès carto" |
| ToolTip tip2 = new ToolTip(); |
| tip2.setHtml("Via une carte, obtenez les coordonnées (latitude/longitude) de votre observation "); |
| tip2.applyTo(basculerverscarto.getElement()); |
| //Sur une meme ligne, ajout de plusieurs champs |
| htmlCommunePanel = new MultiFieldPanel(); |
| int largeurCommune = Window.getClientWidth()/4; |
| htmlCommunePanel.addToRow(commune, largeurCommune); |
| htmlCommunePanel.addToRow(basculerverscarto, 160); |
| htmlCommunePanel.setBorder(false); |
| htmlCommunePanel.setId("x-commune-panel"); |
| panneauPremierColonne.add(htmlCommunePanel); |
| station = new AutoCompletionRefComboBox("Station", "station", observationMediateur, TypesReferentiels.REFERENTIEL_STATION) { |
| @Override |
| public void onModificationValeur() { |
| stationModifiee = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.STATION); |
| } |
| }; |
| panneauPremierColonne.add(station, new AnchorLayoutData("95%")); |
| latitude = new TextField("Lat", "lat"); |
| latitude.setGrowMax(70); |
| latitude.setAllowBlank(true); |
| longitude = new TextField("Lon", "lon"); |
| longitude.setGrowMax(70); |
| longitude.setAllowBlank(true); |
| altitude = new TextField("Alt (mètres)", "alt"); |
| altitude.setGrowMax(70); |
| altitude.setAllowBlank(true); |
| lienSelectionCommune = new Label(""); |
| lienSelectionCommune.setId("conteneur_selection_commune"); |
| lienSelectionCommune.setStyleName("conteneur_selection_commune"); |
| lienSelectionCommune.addStyleName("lien_actif"); |
| // Panneau de type plusieurs champs de formulaire sur une meme ligne, où seront renseignés Lat/Lon |
| coordPanel = new MultiFieldPanel(); |
| coordPanel.setPaddings(0, 0, 0, 10); |
| coordPanel.setVisible(false); |
| final double largeur ; |
| largeur = 120; |
| coordPanel.addToRow(latitude, new ColumnLayoutData(largeur)); |
| coordPanel.addToRow(longitude, new ColumnLayoutData(largeur)); |
| coordPanel.addToRow(lienSelectionCommune, new ColumnLayoutData(largeur)); |
| lienSelectionCommune.addClass("lien_decale"); |
| coordPanel.setBorder(false); |
| coordPanel.addToRow(altitude, new ColumnLayoutData(largeur)); |
| //création du champs coordonnées |
| referentielGeo = Configuration.getReferentielGeo(); |
| coordonnees = new TextField("Coordonnées", "", 0); |
| coordonnees.setMaxLength(0); |
| coordonnees.setReadOnly(true); |
| coordonnees.setCls("fieldname"); |
| //création du lien "saisie X/Y" dans le formulaire |
| afficherFormulaireLatLon = new HTML("<span style=\"padding-left:30px;\" class=\"conteneur_lien_afficher_lat_lon\">" + |
| "<a title=\"Lat / Lon sont les latitudes / longitudes, à remplir en degrés décimaux\" class=\"lien_actif\" id=\"lien_coord\" href=\"#\" tabindex=\"6\">Saisie Lat/Lon ("+referentielGeo+")</a>" + |
| "<span><span style=\"padding-left:20px\" class=\"conteneur_lien_localiser_lat_lon\">"+ |
| "<a title=\"Cliquez pour obtenir les coordonnées de votre observation à partir de la carte\" class=\"lien_actif\" id=\"lien_carto_coord\" href=\"#\" tabindex=\"7\">Localiser sur la carte</a>"+ |
| "</span>"); |
| //ajout d'un listener sur le lien "saisie X/Y" |
| coordPanel.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| surPremierAffichageCoordPanel(largeur); |
| } |
| }); |
| //Sur une meme ligne, ajout de plusieurs champs |
| final MultiFieldPanel htmlPanel = new MultiFieldPanel(); |
| htmlPanel.addToRow(coordonnees, 100); |
| htmlPanel.addToRow(afficherFormulaireLatLon, new ColumnLayoutData(0.9)); |
| htmlPanel.setBorder(false); |
| htmlPanel.setId("x-coord-panel"); |
| panneauPremierColonne.add(htmlPanel); |
| panneauPremierColonne.add(coordPanel); |
| date = new DateField("Date", "date", 250); |
| date.setAllowBlank(true); |
| formatDate = "d/m/Y"; |
| date.setFormat(formatDate) ; |
| date.setTitle("Date de l'observation au format jj/mm/aaaa"); |
| date.setMaxValue(new Date()); |
| //date.setTabIndex(5); |
| panneauPremierColonne.add(date, new AnchorLayoutData("55%")); |
| final String champsListeTpl = "<div class=\"x-combo-list-item search-item-tpl\" title=\"{label}\">{label}</div>"; |
| // Selection d'un référentiel par défaut (le premier spécifié dans la config) |
| referentielTaxo = Configuration.getReferentielsDispos().get(0).getCode(); |
| selecteurReferentielTaxo = new ComboBox(); |
| selecteurReferentielTaxo.setCls("champ-separation"); |
| selecteurReferentielTaxo.setLabel("Référentiel"); |
| selecteurReferentielTaxo.setStore(Ontologies.getValeursReferentiel()); |
| selecteurReferentielTaxo.setValue(referentielTaxo); |
| selecteurReferentielTaxo.setDisplayField("label") ; |
| selecteurReferentielTaxo.setValueField("valeur"); |
| selecteurReferentielTaxo.setEditable(false); |
| selecteurReferentielTaxo.setHideTrigger(false); |
| selecteurReferentielTaxo.setForceSelection(true); |
| selecteurReferentielTaxo.setTpl(champsListeTpl); |
| espece=new ComboBox("Espèce","nom"); |
| final String resultTplEspece = "<div class=\"search-item-espece {indicateurNomRetenu}\">{nom}</div>"; |
| espece.setTpl(resultTplEspece); |
| espece.setMode(ComboBox.REMOTE); |
| espece.setItemSelector("div.search-item-espece"); |
| espece.setTypeAhead(true); |
| espece.setLoadingText("Recherche..."); |
| espece.setHideTrigger(true); |
| Panel panelSeparationPp = new Panel(); |
| panelSeparationPp.setHeight(15); |
| panelSeparationPp.setBorder(false); |
| panneauPremierColonne.add(panelSeparationPp); |
| panneauPremierColonne.add(selecteurReferentielTaxo, new AnchorLayoutData("85%")); |
| panneauPremierColonne.add(espece, new AnchorLayoutData("95%")); |
| selecteurAbondance = new ComboBox(); |
| selecteurAbondance.setCls("champ-separation"); |
| selecteurAbondance.setLabel("Abondance"); |
| selecteurAbondance.setStore(Ontologies.getValeursAbondance()); |
| selecteurAbondance.setDisplayField("label") ; |
| selecteurAbondance.setValueField("valeur"); |
| selecteurAbondance.setEditable(true); |
| selecteurAbondance.setHideTrigger(false); |
| selecteurAbondance.setForceSelection(false); |
| selecteurAbondance.setTpl(champsListeTpl); |
| panneauPremierColonne.add(selecteurAbondance, new AnchorLayoutData("95%")); |
| lieudit = new AutoCompletionRefComboBox("Lieu-dit", "lieudit",observationMediateur,TypesReferentiels.REFERENTIEL_LIEU_DIT) { |
| @Override |
| public void onModificationValeur() { |
| lieuDitModifie = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.LIEUDIT); |
| } |
| }; |
| panneauSecondeColonne.add(lieudit, new AnchorLayoutData("95%")); |
| milieu = new AutoCompletionRefComboBox("Milieu","milieu",observationMediateur,TypesReferentiels.REFERENTIEL_MILIEU) { |
| @Override |
| public void onModificationValeur() { |
| milieuModifie = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.MILIEU); |
| } |
| }; |
| panneauSecondeColonne.add(milieu, new AnchorLayoutData("95%")); |
| comment = new TextArea("Notes", "comment"); |
| comment.setAllowBlank(true); |
| comment.setHeight(50); |
| panneauSecondeColonne.add(comment, new AnchorLayoutData("95%") ); |
| Panel panelSeparationPs = new Panel(); |
| panelSeparationPs.setHeight(39); |
| panelSeparationPs.setBorder(false); |
| panneauSecondeColonne.add(panelSeparationPs); |
| selecteurCertitude = new ComboBox(); |
| selecteurCertitude.setLabel("Identification"); |
| selecteurCertitude.setStore(Ontologies.getValeursCertitude()); |
| selecteurCertitude.setDisplayField("label") ; |
| selecteurCertitude.setValueField("valeur"); |
| selecteurCertitude.setEditable(true); |
| selecteurCertitude.setHideTrigger(false); |
| selecteurCertitude.setForceSelection(false); |
| selecteurCertitude.setTpl(champsListeTpl); |
| panneauSecondeColonne.add(selecteurCertitude, new AnchorLayoutData("95%")); |
| selecteurStadePheno = new ComboBox(); |
| selecteurStadePheno.setLabel("Phénologie"); |
| selecteurStadePheno.setStore(Ontologies.getValeursPhenologie()); |
| selecteurStadePheno.setDisplayField("label") ; |
| selecteurStadePheno.setValueField("valeur"); |
| selecteurStadePheno.setEditable(true); |
| selecteurStadePheno.setHideTrigger(false); |
| selecteurStadePheno.setForceSelection(false); |
| selecteurStadePheno.setTpl(champsListeTpl); |
| panneauSecondeColonne.add(selecteurStadePheno, new AnchorLayoutData("95%")); |
| if (Window.getClientWidth() > Window.getClientHeight() || Window.getClientWidth() < 800) { |
| panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5)); |
| panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5)); |
| } |
| else { |
| panneauIntermediaire.add(panneauPremierColonne); |
| panneauIntermediaire.add(panneauSecondeColonne); |
| } |
| panneauFormulaire.add(panneauIntermediaire); |
| if (Ext.isIE()) { |
| panneauPremierColonne.setButtonAlign(Position.RIGHT); |
| panneauPremierColonne.addButton(boutonOK); |
| panneauPremierColonne.addButton(boutonModifier); |
| panneauPremierColonne.addButton(boutonSupprimer); |
| panneauSecondeColonne.setButtonAlign(Position.LEFT); |
| panneauPremierColonne.addButton(boutonAnnuler); |
| } |
| else { |
| panneauFormulaire.addButton(boutonOK); |
| panneauFormulaire.addButton(boutonModifier); |
| panneauFormulaire.addButton(boutonSupprimer); |
| panneauFormulaire.addButton(boutonAnnuler); |
| } |
| this.add(panneauFormulaire) ; |
| this.setAutoScroll(true); |
| panneauFormulaire.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, int rawWidth, int rawHeight) { |
| panneauIntermediaire.setWidth(rawWidth); |
| panneauIntermediaire.setHeight(rawHeight); |
| panneauPremierColonne.doLayout(); |
| panneauSecondeColonne.doLayout(); |
| htmlCommunePanel.doLayout(); |
| htmlPanel.doLayout(); |
| doLayout(); |
| } |
| }); |
| lienAfficherChampsEtendus = new HTML("Afficher les champs étendus"); |
| lienAfficherChampsEtendus.setStyleName("img-curseur-depl"); |
| lienAfficherChampsEtendus.setStyleName("lienAfficherChampsEtendus"); |
| lienAfficherChampsEtendus.setVisible(false); |
| lienAfficherChampsEtendus.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(afficherChampsEtendus) { |
| afficherChampsEtendus = false; |
| if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) { |
| conteneurChampEtenduGauche.hide(); |
| conteneurChampEtenduDroite.hide(); |
| } |
| lienAfficherChampsEtendus.setText("Afficher les champs étendus"); |
| } else { |
| afficherChampsEtendus = true; |
| if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) { |
| conteneurChampEtenduGauche.show(); |
| conteneurChampEtenduDroite.show(); |
| } |
| lienAfficherChampsEtendus.setText("Cacher les champs étendus"); |
| } |
| } |
| }); |
| if(Configuration.saisieChampsEtendusActivee()) { |
| lienAjouterChampsEtendus = new HTML("Ajouter un champ étendu"); |
| lienAjouterChampsEtendus.addStyleName("lienAjouterChampEtendu"); |
| lienAjouterChampsEtendus.setVisible(true); |
| panneauPremierColonne.add(lienAjouterChampsEtendus); |
| gererLienAjoutChampsEtendus(); |
| } |
| panneauPremierColonne.add(lienAfficherChampsEtendus); |
| panneauPremierColonne.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| if(premierAffichage) { |
| lienAfficherChampsEtendus.setVisible(false); |
| premierAffichage = false; |
| } |
| } |
| }); |
| ajouterListeners() ; |
| ajouterToolTipsBoutons(); |
| saisieTabindex(); |
| } |
| private void gererLienAjoutChampsEtendus() { |
| popUpAjoutChampEtendu.setStylePrimaryName("popup_champ_etendu"); |
| lienAjouterChampsEtendus.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| FormulaireSaisieChampEtendu formChamp = new FormulaireSaisieChampEtendu() { |
| @Override |
| public void surValidation(ChampSaisieEtendu champ) { |
| ajouterChampEtenduAuFormulaire(champ, true); |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } |
| @Override |
| public void surAjout(ChampSaisieEtendu champ) { |
| ajouterChampEtenduAuFormulaire(champ, false); |
| } |
| @Override |
| public void surAnnulation() { |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } |
| @Override |
| public void surAjoutMultiple(List<ChampSaisieEtendu> champs) { |
| for (Iterator<ChampSaisieEtendu> iterator = champs.iterator(); iterator.hasNext();) { |
| ChampSaisieEtendu champSaisieEtendu = (ChampSaisieEtendu) iterator.next(); |
| ajouterChampEtenduAuFormulaire(champSaisieEtendu, false); |
| } |
| } |
| @Override |
| public void surValidationMultiple(List<ChampSaisieEtendu> champs) { |
| for (Iterator<ChampSaisieEtendu> iterator = champs.iterator(); iterator.hasNext();) { |
| ChampSaisieEtendu champSaisieEtendu = (ChampSaisieEtendu) iterator.next(); |
| ajouterChampEtenduAuFormulaire(champSaisieEtendu, false); |
| } |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } |
| }; |
| popUpAjoutChampEtendu.add(formChamp); |
| popUpAjoutChampEtendu.center(); |
| popUpAjoutChampEtendu.setModal(true); |
| popUpAjoutChampEtendu.show(); |
| } |
| }); |
| } |
| private void ajouterChampEtenduAuFormulaire(ChampSaisieEtendu nChamp, boolean fermerPopup) { |
| ChampEtendu chet = new ChampEtendu(nChamp.getName(), nChamp.getFieldLabel(), ""); |
| Map<String, ChampEtendu> champsEt = getValeursChampsEtendus(); |
| if(!champsEt.containsKey(chet.getCle())) { |
| champsEt.put(chet.getCle(), chet); |
| afficherChampsEtendus = true; |
| if(fermerPopup) { |
| afficherChampsEtendus(champsEt, chet); |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } else { |
| afficherChampsEtendus(champsEt, null); |
| } |
| } else { |
| Window.alert("Le champ "+chet.getLabel()+" est déjà présent dans le formulaire"); |
| } |
| } |
| private void ajouterToolTipsBoutons() { |
| boutonOK.setTitle("Crée une nouvelle observation à partir des champs saisis dans le formulaire"); |
| boutonModifier.setTitle("Modifie la ou les observations sélectionnées"); |
| boutonSupprimer.setTitle("Supprime la ou les observations sélectionnées"); |
| boutonAnnuler.setTitle("Vide tous les champs du formulaire"); |
| } |
| private void surPremierAffichageCoordPanel(final double largeur) { |
| ExtElement lienCoord = Ext.get("lien_coord"); |
| lienCoord.removeAllListeners(); |
| lienCoord.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| coordPanel.setVisible(!coordPanel.isVisible()); |
| if(Ext.isIE()) { |
| latitude.focus(); |
| } |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| }) ; |
| ExtElement lienCartoCoord = Ext.get("lien_carto_coord"); |
| lienCartoCoord.removeAllListeners(); |
| lienCartoCoord.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| obtenirInformationCoord(); |
| } |
| }) ; |
| ExtElement lienCarto = Ext.get("lien_carto"); |
| lienCarto.removeAllListeners(); |
| lienCarto.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| if(commune.getValue() != null && !commune.getValue().equals("") && !getDepartement().equals("")) { |
| obtenirInformationCommune(); |
| longlatAjoutee = true; |
| } else { |
| Window.alert("Veuillez renseigner une commune et un numéro de département sous la forme : Commune (departement)"); |
| } |
| } |
| }); |
| if(!Ext.isIE() && Window.getClientWidth() < 1200) { |
| int largeurN = (int)largeur; |
| latitude.setWidth(largeurN+"px"); |
| longitude.setWidth(largeurN+"px"); |
| lienSelectionCommune.setWidth(largeurN+"px"); |
| } |
| } |
| private void ajouterListeners() |
| { |
| // Listener completion communne |
| final Rafraichissable r = this; |
| ListenerConfig listenerConfigCommune=new ListenerConfig(); |
| listenerConfigCommune.setDelay(200); |
| listenerConfigCommune.setStopPropagation(false); |
| listenerConfigCommune.setStopEvent(false); |
| date.addListener(new DatePickerListenerAdapter() { |
| @Override |
| public void onSelect(DatePicker dataPicker, Date date) { |
| dateModifiee = true; |
| } |
| }); |
| ListenerConfig listenerConfigAutocompletion=new ListenerConfig(); |
| listenerConfigAutocompletion.setDelay(200); |
| listenerConfigAutocompletion.setStopPropagation(false); |
| listenerConfigAutocompletion.setStopEvent(false); |
| ListenerConfig listenerConfigEspece=new ListenerConfig(); |
| listenerConfigEspece.setDelay(10); |
| listenerConfigEspece.setStopPropagation(false); |
| listenerConfigEspece.setStopEvent(false); |
| tCoord = new Timer() { |
| @Override |
| public void run() { |
| double[] coord = coordonneesValides(); |
| if(!rechercheCommuneEnCours && coord != null && (longModifiee || latModifiee)) { |
| rechercheCommuneEnCours = true; |
| Ext.get(lienSelectionCommune.getElement()).mask("recherche"); |
| observationMediateur.obtenirInformationCoord(r,coord[0], coord[1]); |
| } |
| } |
| }; |
| ajouterListenerChampEvenementsClavier(commune, listenerConfigCommune); |
| ajouterListenerChampEvenementsClavier(date); |
| ajouterListenerChampEvenementsClavier(selecteurReferentielTaxo); |
| ajouterListenerChampEvenementsClavier(espece, listenerConfigEspece); |
| ajouterListenerChampEvenementsClavier(comment); |
| ajouterListenerChampEvenementsClavier(latitude); |
| ajouterListenerChampEvenementsClavier(longitude); |
| ajouterListenerChampEvenementsClavier(altitude); |
| ajouterListenerChampEvenementsClavier(selecteurAbondance); |
| ajouterListenerChampEvenementsClavier(selecteurCertitude); |
| ajouterListenerChampEvenementsClavier(selecteurStadePheno); |
| ajouterListenerChampsCombobox(); |
| boutonOK.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| ajouterObservation(); |
| } |
| }); |
| boutonModifier.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(selectionMultiple) { |
| modifierObservationEnMasse(null); |
| } else { |
| modifierObservation() ; |
| } |
| } |
| }); |
| boutonSupprimer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(!selectionMultiple) { |
| supprimerObservation(); |
| } else { |
| observationMediateur.supprimerObservations(); |
| } |
| } |
| }); |
| boutonAnnuler.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| setSelectionMultiple(false); |
| raz(); |
| } |
| }); |
| this.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container self) { |
| commune.focus(); |
| } |
| }); |
| } |
| private void ajouterListenerChampsCombobox() { |
| commune.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| commune.setValue(record.getAsString("commune")); |
| departement=record.getAsString("departement"); |
| codeInseeCommune=record.getAsString("codeInsee"); |
| selectionCommune=true; |
| commune.collapse(); |
| } |
| @Override |
| public void onExpand(ComboBox comboBox) { |
| comboBox.focus(); |
| } |
| }); |
| selecteurReferentielTaxo.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| referentielTaxo = record.getAsString("valeur"); |
| observationMediateur.setRefTaxSelectionne(index); |
| referentielTaxoModifie = true; |
| } |
| }); |
| espece.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| espece.setValue(record.getAsString("nom")); |
| numeroNom=record.getAsString("numeroNom"); |
| selectionEspece=true; |
| observationMediateur.obtenirImageInformationExternes(referentielTaxo, numeroNom); |
| } |
| }); |
| selecteurAbondance.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionAbondance=true; |
| abondanceModifiee = true; |
| } |
| }); |
| selecteurCertitude.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionCertitude=true; |
| certitudeModifiee = true; |
| } |
| }); |
| selecteurStadePheno.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionPhenologie=true; |
| phenologieModifiee = true; |
| } |
| }); |
| } |
| private void ajouterListenerChampEvenementsClavier(final TextField champ) { |
| champ.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| surEvenementClavier(e, champ); |
| } |
| }); |
| } |
| private void ajouterListenerChampEvenementsClavier(final TextField champ, final ListenerConfig config) { |
| champ.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| surEvenementClavier(e, champ); |
| } |
| }, config); |
| } |
| private void surEvenementClavier(EventObject e, TextField champ) { |
| 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: |
| surEvenementClavierToucheEntree(champ); |
| break; |
| default: |
| gererEvenementClavierDefaut(champ); |
| break; |
| } |
| } |
| private void surEvenementClavierToucheEntree(TextField champ) { |
| //TODO: faire un switch ou une enum |
| if(champ.equals(selecteurStadePheno)) { |
| if(!selectionPhenologie) { |
| validerSaisie(Champs.PHENOLOGIE); |
| } else { |
| selectionPhenologie = false; |
| } |
| } |
| if(champ.equals(selecteurCertitude)) { |
| if(!selectionCertitude) { |
| validerSaisie(Champs.CERTITUDE); |
| } else { |
| selectionCertitude = false; |
| } |
| } |
| if(champ.equals(selecteurAbondance)) { |
| if(!selectionAbondance) { |
| validerSaisie(Champs.ABONDANCE); |
| } else { |
| selectionAbondance = false; |
| } |
| } |
| if(champ.equals(longitude)) { |
| validerSaisie(Champs.LONGITUDE); |
| } |
| if(champ.equals(latitude)) { |
| validerSaisie(Champs.LATITUDE); |
| } |
| if(champ.equals(altitude)) { |
| validerSaisie(Champs.ALTITUDE); |
| } |
| if(champ.equals(espece)) { |
| if(selectionEspece) { |
| especeModifiee = true; |
| selectionEspece=false; |
| } |
| else { |
| validerSaisie(Champs.ESPECE); |
| } |
| } |
| if(champ.equals(selecteurReferentielTaxo)) { |
| validerSaisie(Champs.REFERENTIELTAXO); |
| } |
| if(champ.equals(date)) { |
| validerSaisie(Champs.DATE); |
| } |
| if(champ.equals(commune)) { |
| if(champ.equals(commune)) { |
| if (selectionCommune) { |
| communeModifiee= true; |
| selectionCommune=false; |
| } |
| else { |
| validerSaisie(Champs.COMMUNE); |
| } |
| } |
| } |
| } |
| private void gererEvenementClavierDefaut(TextField champ) { |
| //TODO: faire un switch ou une enum |
| if(champ.equals(selecteurStadePheno)) { |
| selecteurStadePheno.setRawValue(selecteurStadePheno.getRawValue()); |
| selecteurStadePheno.setValue(selecteurStadePheno.getRawValue()); |
| phenologieModifiee = true; |
| selectionPhenologie = false; |
| } |
| if(champ.equals(selecteurCertitude)) { |
| selecteurCertitude.setRawValue(selecteurCertitude.getRawValue()); |
| selecteurCertitude.setValue(selecteurCertitude.getRawValue()); |
| certitudeModifiee = true; |
| selectionCertitude = false; |
| } |
| if(champ.equals(selecteurAbondance)) { |
| selecteurAbondance.setRawValue(selecteurAbondance.getRawValue()); |
| selecteurAbondance.setValue(selecteurAbondance.getRawValue()); |
| abondanceModifiee = true; |
| selectionAbondance = false; |
| } |
| if(champ.equals(longitude)) { |
| longModifiee = true; |
| tCoord.cancel(); |
| tCoord.schedule(250); |
| } |
| if(champ.equals(latitude)) { |
| latModifiee = true; |
| tCoord.cancel(); |
| tCoord.schedule(250); |
| } |
| if(champ.equals(altitude)) { |
| altModifiee = true; |
| } |
| if(champ.equals(comment)) { |
| commModifie = true; |
| } |
| if(champ.equals(espece)) { |
| numeroNom=""; |
| obtenirListeReferentielNom(); |
| especeModifiee = true; |
| } |
| if(champ.equals(selecteurReferentielTaxo)) { |
| referentielTaxoModifie = true; |
| } |
| if(champ.equals(date)) { |
| dateModifiee = true; |
| } |
| if(champ.equals(commune)) { |
| departement=""; |
| commune.collapse(); |
| obtenirListeReferentielCommune(); |
| communeModifiee= true; |
| } |
| } |
| /** |
| * Validation de la saisie |
| */ |
| private void validerSaisie(Champs champs) { |
| if(!selectionMultiple) { |
| ajouterObservation(); |
| raz(champs); |
| } else { |
| modifierObservationEnMasse(champs); |
| } |
| } |
| /** |
| * Desactive visuellement ce panneau |
| */ |
| public void desactiverPanneau() |
| { |
| this.setDisabled(true) ; |
| } |
| /** |
| * Active visuellement ce panneau |
| */ |
| public void activerPanneau() |
| { |
| this.setDisabled(false) ; |
| } |
| @Override |
| 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()][3]; |
| 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=data.get(it.next()); |
| communeData[i][0]= ref.getCommune(); |
| communeData[i][1]= ref.getDepartement(); |
| communeData[i][2]= ref.getCodeInsee(); |
| i++ ; |
| } |
| // creation du store |
| FieldDef defCommune = new StringFieldDef("commune"); |
| FieldDef defDepartement = new StringFieldDef("departement"); |
| FieldDef defCodeInsee = new StringFieldDef("codeInsee"); |
| FieldDef[] defTab = { defCommune, defDepartement, defCodeInsee}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(communeData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| commune.setStore(store); |
| store.load(); |
| } |
| // 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()][3]; |
| 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=data.get(it.next()); |
| nomData[i][0]= ref.getNom(); |
| nomData[i][1]= ref.getNumeroNom(); |
| if (ref.getStatut().equals("3")) { |
| nomData[i][2]="nom_retenu"; |
| } |
| else { |
| nomData[i][2]=""; |
| } |
| i++ ; |
| } |
| FieldDef defNom = new StringFieldDef("nom"); |
| FieldDef defNumeroNom = new StringFieldDef("numeroNom"); |
| FieldDef indicateurNomRetenu = new StringFieldDef("indicateurNomRetenu"); |
| FieldDef[] defTab = { defNom, defNumeroNom, indicateurNomRetenu}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(nomData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| espece.setStore(store); |
| store.load() ; |
| } |
| // On recoit une observation dont on veut afficher le detail |
| if(nouvelleDonnees instanceof Observation) |
| { |
| Observation obs = (Observation)nouvelleDonnees ; |
| setSelectionMultiple(false); |
| afficherDetailsObservation(obs) ; |
| } |
| if(nouvelleDonnees instanceof ListeObservation) { |
| ListeObservation listeObs = (ListeObservation)nouvelleDonnees; |
| setSelectionMultiple(true); |
| calculerAfficherDifferences(listeObs); |
| } |
| 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]); |
| } |
| if(nouvelleDonnees instanceof EntiteGeographiqueObservation) |
| { |
| EntiteGeographiqueObservation infosComm = (EntiteGeographiqueObservation)nouvelleDonnees ; |
| if(rechercheCommuneEnCours) { |
| afficherIndicationCommune(infosComm); |
| } else { |
| rafraichirCommuneEtCoord(infosComm); |
| } |
| } |
| } |
| private void afficherIndicationCommune( |
| final EntiteGeographiqueObservation infosCom) { |
| String nCommune = ""; |
| if(infosCom != null && !infosCom.getZoneGeo().trim().equals("")){ |
| nCommune += infosCom.getZoneGeo(); |
| if(!infosCom.getIdZoneGeo().trim().equals("")) |
| nCommune += " ("+Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo())+")"; |
| lienSelectionCommune.setHtml("<a id=\"lien_selection_commune\" tabindex=\"9\">"+nCommune+"</a>"); |
| lienSelectionCommune.setStyleName("img-curseur-depl"); |
| Ext.get("lien_selection_commune").addListener("click",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| rafraichirCommune(infosCom); |
| } |
| }); |
| Ext.get("lien_selection_commune").addListener("keypress",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| if(e.getCharCode() == KEY_ENTER) { |
| rafraichirCommune(infosCom); |
| } |
| } |
| }); |
| Ext.get("lien_selection_commune").addListener("focus",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| Ext.get("lien_selection_commune").toggleClass("lien_sel"); |
| } |
| }); |
| Ext.get("lien_selection_commune").addListener("blur",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| Ext.get("lien_selection_commune").toggleClass("lien_sel"); |
| } |
| }); |
| } else { |
| if(rechercheCommuneEnCours) { |
| lienSelectionCommune.setHtml("<span id=\"aucune_selection_commune\"> Erreur de localisation </span>"); |
| } else { |
| lienSelectionCommune.setHtml("<span id=\"aucune_selection_commune\"> </span>"); |
| } |
| } |
| Ext.get(lienSelectionCommune.getElement()).unmask(); |
| rechercheCommuneEnCours = false; |
| } |
| private void rafraichirCommune(EntiteGeographiqueObservation infosCom) { |
| String nCommune = ""; |
| if(infosCom.getZoneGeo() != null && !infosCom.getZoneGeo().equals("")) { |
| nCommune += infosCom.getZoneGeo(); |
| } |
| if(infosCom.getIdZoneGeo() != null && !infosCom.getIdZoneGeo().equals("")) { |
| String codeGeoFormate = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo()); |
| nCommune += " ("+codeGeoFormate+")"; |
| departement = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo()); |
| } |
| commune.setValue(nCommune); |
| communeModifiee = true; |
| } |
| private void rafraichirCommuneEtCoord(EntiteGeographiqueObservation infosCom) { |
| // on ne remplace la commune que si le champ était vide |
| if(commune.getRawValue() == null || commune.getRawValue().equals("")) { |
| rafraichirCommune(infosCom); |
| } |
| if(infosCom.getLat() != null && !infosCom.getLat().equals("")) { |
| latitude.setValue(infosCom.getLat()); |
| } |
| if(infosCom.getLon() != null && !infosCom.getLon().equals("")) { |
| longitude.setValue(infosCom.getLon()); |
| } |
| latModifiee = true; |
| longModifiee = true; |
| coordPanel.setVisible(true); |
| } |
| public void obtenirListeReferentielCommune() { |
| String com=commune.getText(); |
| com=com.replaceAll("%",""); |
| observationMediateur.obtenirListeReferentielCommune(this,com); |
| } |
| public void obtenirListeReferentielNom() { |
| String esp=espece.getText().replaceAll(" ","/*"); |
| esp=esp.replaceAll("%",""); |
| String referentiel = this.referentielTaxo; |
| observationMediateur.obtenirListeReferentielNom(this,referentiel ,esp); |
| } |
| protected void obtenirReferentielStation() { |
| observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_STATION,station.getText()); |
| } |
| protected void obtenirListeReferentielMilieu() { |
| observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_MILIEU,milieu.getText()); |
| } |
| protected void obtenirReferentielLieuDit() { |
| observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_LIEU_DIT,lieudit.getText()); |
| } |
| public void ajouterObservation() { |
| if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) { |
| Window.alert("Attention la date saisie est invalide, la date doit être au format jj/mm/aaaa"); |
| date.setInvalidText("Date invalide"); |
| return; |
| } |
| if(departement != null) { |
| 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 = "" ; |
| } |
| } |
| } |
| } |
| String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue()); |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs); |
| String[] coords = getValeurCoordonnees(); |
| obs.setLatitude(coords[0]); |
| obs.setLongitude(coords[1]); |
| obs.setAltitude(altitude.getText()); |
| obs.setAbondance(getAbondance()); |
| obs.setCertitude(getCertitude()); |
| obs.setPhenologie(getPhenologie()); |
| obs.setReferentielTaxo(Ontologies.getInfosReferentielNomParCode(referentielTaxo).getCodeVersionComplet()); |
| obs.setChampsEtendus(getValeursChampsEtendus()); |
| observationMediateur.ajouterObservation(obs); |
| } |
| private void modifierObservation() { |
| if(!Window.confirm("Êtes-vous sur de vouloir modifier l'observation sélectionnée ?")) { |
| return; |
| } |
| if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) { |
| Window.alert("Attention la date saisie est invalide, la date doit être au format jj/mm/aaaa"); |
| date.setInvalidText("Date invalide"); |
| return; |
| } |
| 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 = "" ; |
| } |
| } |
| } |
| String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue()); |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs); |
| obs.setNumeroOrdre(numeroOrdre); |
| String[] coords = getValeurCoordonnees(); |
| obs.setLatitude(coords[0]); |
| obs.setLongitude(coords[1]); |
| obs.setAltitude(altitude.getText()); |
| obs.setAbondance(getAbondance()); |
| obs.setCertitude(getCertitude()); |
| obs.setPhenologie(getPhenologie()); |
| obs.setReferentielTaxo(getReferentielTaxo()); |
| obs.setChampsEtendus(getValeursChampsEtendus()); |
| observationMediateur.modifierObservation(obs); |
| } |
| private void modifierObservationEnMasse(Champs champModifie) { |
| //TODO: factoriser |
| 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 latM = null; |
| String longM = null; |
| String altM = null; |
| String abondanceM = null; |
| String certitudeM = null; |
| String referentielTaxoM = null; |
| String phenologieM = null; |
| String champs = modeleMessageModif; |
| if(communeModifiee && ! commune.getRawValue().equals(VALEURS_MULTIPLES)) { |
| 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 && ! lieudit.getRawValue().equals(VALEURS_MULTIPLES)) { |
| lieuDitM = lieudit.getText(); |
| } else { |
| champs = champs.replaceAll(":lieu-dit", ""); |
| } |
| if(stationModifiee && ! station.getRawValue().equals(VALEURS_MULTIPLES)) { |
| stationM = station.getText(); |
| } else { |
| champs = champs.replaceAll(":station", ""); |
| } |
| if(milieuModifie && ! milieu.getRawValue().equals(VALEURS_MULTIPLES)) { |
| milieuM = milieu.getText(); |
| } else { |
| champs = champs.replaceAll(":milieu", ""); |
| } |
| if(dateModifiee && ! date.getRawValue().equals(VALEURS_MULTIPLES)) { |
| dateM = date.getRawValue(); |
| dateM = Util.remplacerSeparateursDateFormatCel(dateM); |
| } else { |
| champs = champs.replaceAll(":date", ""); |
| } |
| if(especeModifiee && ! espece.getRawValue().equals(VALEURS_MULTIPLES)) { |
| especeM = espece.getText(); |
| numNomSelM = numeroNom; |
| } else { |
| champs = champs.replaceAll(":espece", ""); |
| } |
| if(commModifie && ! comment.getRawValue().equals(VALEURS_MULTIPLES)) { |
| commM = comment.getText(); |
| } else { |
| champs = champs.replaceAll(":commentaire", ""); |
| } |
| if(latModifiee && ! latitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| latM = latitude.getText(); |
| } else { |
| champs = champs.replaceAll(":latitude", ""); |
| } |
| if(altModifiee && ! altitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| altM = altitude.getText(); |
| } else { |
| champs = champs.replaceAll(":altitude", ""); |
| } |
| if(longModifiee && ! longitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| longM = longitude.getText(); |
| } else { |
| champs = champs.replaceAll(":longitude", ""); |
| } |
| if(abondanceModifiee && !selecteurAbondance.getRawValue().equals(VALEURS_MULTIPLES)) { |
| abondanceM = getAbondance(); |
| } else { |
| champs = champs.replaceAll(":abondance", ""); |
| } |
| if(certitudeModifiee && !selecteurCertitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| certitudeM = getCertitude(); |
| } else { |
| champs = champs.replaceAll(":identification", ""); |
| } |
| if(referentielTaxoModifie && !selecteurReferentielTaxo.getRawValue().equals(VALEURS_MULTIPLES)) { |
| referentielTaxoM = getReferentielTaxo(); |
| } else { |
| champs = champs.replaceAll(":referentiel", ""); |
| } |
| if(phenologieModifiee && !selecteurStadePheno.getRawValue().equals(VALEURS_MULTIPLES)) { |
| phenologieM = getPhenologie(); |
| } else { |
| champs = champs.replaceAll(":phenologie", ""); |
| } |
| 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); |
| obs.setLatitude(latM); |
| obs.setLongitude(longM); |
| obs.setAltitude(altM); |
| obs.setAbondance(abondanceM); |
| obs.setCertitude(certitudeM); |
| obs.setReferentielTaxo(referentielTaxoM); |
| obs.setPhenologie(phenologieM); |
| 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(); |
| if(idLoc.length() == 5) { |
| idLoc = idLoc.substring(0,2); |
| } |
| } else { |
| idLoc = obs.getIdentifiantLocalite(); |
| if(idLoc.length() == 5) { |
| idLoc = idLoc.substring(0,2); |
| } |
| } |
| 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.setRawValue(Util.remplacerSautsDeligneMalEncodes(obs.getCommentaire())); |
| } |
| if(!obs.getLocalite().equals("null") && !obs.getLocalite().equals("000null")) { |
| if(!idLoc.equals("000null") && !idLoc.equals("")) { |
| 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("000null")) { |
| numeroOrdre = obs.getNumeroOrdre() ; |
| } |
| if(doitAfficherLatLon(obs)) { |
| latitude.setValue(Util.formaterNombre(obs.getLatitude())) ; |
| longitude.setValue(Util.formaterNombre(obs.getLongitude())) ; |
| } |
| if(!obs.getAltitude().isEmpty() && !obs.getAltitude().equals("null") && !obs.getAltitude().equals("000null")) { |
| altitude.setValue(Util.formaterNombre(obs.getAltitude())) ; |
| } |
| selecteurAbondance.getStore().load(); |
| selecteurAbondance.setValue(obs.getAbondance()); |
| selecteurCertitude.getStore().load(); |
| selecteurCertitude.setValue(obs.getCertitude()); |
| selecteurStadePheno.getStore().load(); |
| selecteurStadePheno.setValue(obs.getPhenologie()); |
| selecteurReferentielTaxo.getStore().load(); |
| if(obs.getReferentielTaxo() != VALEURS_MULTIPLES) { |
| referentielTaxo = obs.getCodeCourtReferentielTaxo(); |
| if(referentielTaxo == null || referentielTaxo.isEmpty()) { |
| referentielTaxo = Configuration.getReferentielsDispos().get(0).getCode(); |
| } |
| selecteurReferentielTaxo.setValue(referentielTaxo); |
| } else { |
| referentielTaxo = ""; |
| selecteurReferentielTaxo.setRawValue(VALEURS_MULTIPLES); |
| } |
| afficherChampsEtendus(obs.getChampsEtendus(), null); |
| } |
| private boolean doitAfficherLatLon(Observation obs) { |
| return !obs.getLatitude().isEmpty() && |
| !obs.getLatitude().equals("null") && |
| !obs.getLatitude().equals("000null") && |
| !Util.estZero(obs.getLatitude()) && |
| !obs.getLongitude().isEmpty() && |
| !obs.getLongitude().equals("null") && |
| !obs.getLongitude().equals("000null") && |
| !Util.estZero(obs.getLongitude()); |
| } |
| private void viderChampsEtendus() { |
| if(listeChampsEtendus != null) { |
| for (Iterator<String> it = listeChampsEtendus.keySet().iterator(); it.hasNext();) { |
| TextField champEtendu = listeChampsEtendus.get(it.next()); |
| champEtendu.destroy(); |
| } |
| if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) { |
| conteneurChampEtenduGauche.clear(); |
| conteneurChampEtenduDroite.clear(); |
| panneauPremierColonne.remove(conteneurChampEtenduGauche); |
| panneauSecondeColonne.remove(conteneurChampEtenduDroite); |
| } |
| listeChampsEtendus = null; |
| } |
| } |
| private void afficherChampsEtendus(Map<String, ChampEtendu> champsEtendus, ChampEtendu champsAFocus) { |
| viderChampsEtendus(); |
| FormLayout flmd = new FormLayout(); |
| flmd.setLabelWidth(150); |
| FormLayout flmg = new FormLayout(); |
| flmg.setLabelWidth(150); |
| conteneurChampEtenduGauche = new Panel(); |
| conteneurChampEtenduGauche.setLayout(flmg); |
| conteneurChampEtenduDroite = new Panel(); |
| conteneurChampEtenduDroite.setLayout(flmd); |
| conteneurChampEtenduGauche.setAutoWidth(true); |
| conteneurChampEtenduGauche.setStyle("conteneurChampsEtendus"); |
| conteneurChampEtenduGauche.setBodyBorder(false); |
| conteneurChampEtenduDroite.setAutoWidth(true); |
| conteneurChampEtenduDroite.setStyle("conteneurChampsEtendus"); |
| conteneurChampEtenduDroite.setBodyBorder(false); |
| // pour corriger le décalage sur le panneau induit par le lien d'affichage |
| conteneurChampEtenduDroite.setPaddings(42, 0, 0, 0); |
| if(champsEtendus != null && champsEtendus.size() > 0) { |
| lienAfficherChampsEtendus.setVisible(true); |
| listeChampsEtendus = new HashMap<String, ChampSaisieEtendu>(champsEtendus.size()); |
| boolean gauche = true; |
| for (Iterator<String> iterator = champsEtendus.keySet().iterator(); iterator.hasNext();) { |
| String id = iterator.next(); |
| ChampEtendu champ = champsEtendus.get(id); |
| String valeur = champ.getValeur(); |
| String label = champ.getLabel(); |
| ChampSaisieEtendu champTexteEtendu = new ChampSaisieEtendu(label, id); |
| if(champ.equals(champsAFocus)) { |
| champTexteEtendu.focus(); |
| } |
| champTexteEtendu.setLabel(label); |
| champTexteEtendu.setId(id); |
| champTexteEtendu.setValue(valeur); |
| if(gauche) { |
| conteneurChampEtenduGauche.add(champTexteEtendu); |
| } else { |
| conteneurChampEtenduDroite.add(champTexteEtendu); |
| } |
| listeChampsEtendus.put(id, champTexteEtendu); |
| gauche = !gauche; |
| } |
| panneauPremierColonne.add(conteneurChampEtenduGauche); |
| panneauSecondeColonne.add(conteneurChampEtenduDroite); |
| if(!afficherChampsEtendus) { |
| conteneurChampEtenduGauche.setVisible(false); |
| conteneurChampEtenduDroite.setVisible(false); |
| } |
| } else { |
| lienAfficherChampsEtendus.setVisible(false); |
| } |
| doLayout(); |
| } |
| private Map<String, ChampEtendu> getValeursChampsEtendus() { |
| Map<String, ChampEtendu> valeursChampsEtendus = new HashMap<String, ChampEtendu>(); |
| if(listeChampsEtendus != null) { |
| for (Iterator<String> it = listeChampsEtendus.keySet().iterator(); it.hasNext();) { |
| String cle = it.next(); |
| TextField champTexteEtendu = listeChampsEtendus.get(cle); |
| String label = champTexteEtendu.getFieldLabel(); |
| String valeur = champTexteEtendu.getValueAsString(); |
| ChampEtendu champEtendu = new ChampEtendu(cle, label, valeur); |
| valeursChampsEtendus.put(cle, champEtendu); |
| } |
| } |
| return valeursChampsEtendus; |
| } |
| 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 =""; |
| latitude.reset(); |
| longitude.reset(); |
| break; |
| case ESPECE: |
| espece.reset(); |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| break; |
| case LATITUDE: |
| latitude.reset(); |
| afficherIndicationCommune(null); |
| break; |
| case LONGITUDE: |
| longitude.reset(); |
| afficherIndicationCommune(null); |
| break; |
| case ALTITUDE: |
| altitude.reset(); |
| break; |
| case ABONDANCE: |
| selecteurAbondance.setValue(""); |
| break; |
| case CERTITUDE: |
| selecteurCertitude.setValue(""); |
| break; |
| case REFERENTIELTAXO: |
| selecteurReferentielTaxo.setValue(""); |
| break; |
| case PHENOLOGIE: |
| selecteurStadePheno.setValue(""); |
| break; |
| case TOUT: |
| commune.reset(); |
| date.reset() ; |
| lieudit.reset() ; |
| station.reset() ; |
| milieu.reset() ; |
| comment.reset() ; |
| milieu.reset() ; |
| latitude.reset(); |
| longitude.reset(); |
| altitude.reset(); |
| departement =""; |
| espece.reset(); |
| selecteurAbondance.clearValue(); |
| selecteurCertitude.clearValue(); |
| selecteurReferentielTaxo.clearValue(); |
| selecteurStadePheno.clearValue(); |
| referentielTaxo = ""; |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| afficherIndicationCommune(null); |
| break; |
| } |
| } |
| 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 setSelectionMultiple(boolean selectionMultiple) { |
| this.selectionMultiple = selectionMultiple; |
| if(!selectionMultiple) { |
| boutonAnnuler.enable(); |
| boutonOK.enable(); |
| } else { |
| boutonAnnuler.disable(); |
| boutonOK.disable(); |
| } |
| } |
| public boolean getSelectionMultiple() { |
| return selectionMultiple; |
| } |
| 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 lat = null; |
| String lon = null; |
| String alt = null; |
| String abondance = null; |
| String certitude = null; |
| String referentielTaxo = null; |
| String phenologie = 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()); |
| lat = comparerDifferencesChamps(lat, obsEnCours.getLatitude()); |
| lon = comparerDifferencesChamps(lon, obsEnCours.getLongitude()); |
| alt = comparerDifferencesChamps(alt, obsEnCours.getAltitude()); |
| abondance = comparerDifferencesChamps(abondance, obsEnCours.getAbondance()); |
| certitude = comparerDifferencesChamps(certitude, obsEnCours.getCertitude()); |
| referentielTaxo = comparerDifferencesChamps(referentielTaxo, obsEnCours.getReferentielTaxo()); |
| phenologie = comparerDifferencesChamps(phenologie, obsEnCours.getPhenologie()); |
| ordreObs += obsEnCours.getNumeroOrdre()+","; |
| } |
| Observation obs=new Observation(espece,numeroNom,commune,departement,lieuDit,station,milieu, notes,date); |
| obs.setNumeroOrdre(ordreObs); |
| obs.setLatitude(lat); |
| obs.setLongitude(lon); |
| obs.setAltitude(alt); |
| obs.setAbondance(abondance); |
| obs.setCertitude(certitude); |
| obs.setReferentielTaxo(referentielTaxo); |
| obs.setPhenologie(phenologie); |
| afficherDetailsObservation(obs); |
| } |
| 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; |
| latModifiee = false; |
| longModifiee = false; |
| altModifiee = false; |
| abondanceModifiee = false; |
| certitudeModifiee = false; |
| referentielTaxoModifie = false; |
| phenologieModifiee = false; |
| } |
| public void saisieTabindex() |
| { |
| commune.setTabIndex(1); |
| lieudit.setTabIndex(3); |
| station.setTabIndex(4); |
| milieu.setTabIndex(5); |
| coordonnees.setTabIndex(-1); |
| coordonnees.addListener(new TextFieldListenerAdapter() { |
| @Override |
| public void onFocus(Field field) { |
| if(coordPanel.isVisible()) { |
| latitude.focus(); |
| } else { |
| Ext.get("lien_carto").focus(); |
| } |
| } |
| }); |
| latitude.setTabIndex(8); |
| longitude.setTabIndex(9); |
| altitude.setTabIndex(10); |
| comment.setTabIndex(11); |
| date.setTabIndex(12); |
| espece.setTabIndex(13); |
| selecteurCertitude.setTabIndex(14); |
| selecteurAbondance.setTabIndex(15); |
| selecteurStadePheno.setTabIndex(16); |
| boutonOK.setTabIndex(17); |
| boutonAnnuler.setTabIndex(18); |
| } |
| private void obtenirInformationCoord() { |
| if(coordonneesValides() != null) { |
| observationMediateur.obtenirInformationCoord(coordonneesValides()[0],coordonneesValides()[1]); |
| } else { |
| observationMediateur.afficherFenetreCarto(); |
| } |
| } |
| private void obtenirInformationCommune() { |
| observationMediateur.obtenirInformationCommune(getCommuneSansDepartement(), Util.obtenirDepartementAPartirChaineCommune(departement, commune.getText())); |
| } |
| public double[] coordonneesValides() { |
| try { |
| double lat = Double.parseDouble(latitude.getValueAsString().replaceAll(",", ".")); |
| double lon = Double.parseDouble(longitude.getValueAsString().replaceAll(",", ".")); |
| double[] coord = {lat, lon}; |
| return coord; |
| } catch (NumberFormatException ne) { |
| return null; |
| } |
| } |
| private String[] getValeurCoordonnees() { |
| double[] coDouble = coordonneesValides(); |
| if(coDouble != null) { |
| String[] coord = {coDouble[0]+"",coDouble[1]+""}; |
| return coord; |
| } else { |
| String[] coord = {"000null","000null" }; |
| return coord; |
| } |
| } |
| public String getCommune() { |
| String valeurCommune = ""; |
| if(commune.getValue() != null) { |
| valeurCommune = commune.getValue(); |
| } |
| return valeurCommune; |
| } |
| public String getDepartement() { |
| return Util.obtenirDepartementAPartirChaineCommune(departement, commune.getText()); |
| } |
| public String getCommuneSansDepartement() { |
| return Util.supprimerNumDepartementChaineLocalite(getCommune()); |
| } |
| private String getValeurChampListeLibre(ComboBox champ) { |
| String valeurChamp = champ.getValue(); |
| String valeurChampBrute = champ.getRawValue(); |
| // Test idiot qui permet de savoir si l'on utilise la valeur saisie directement ou bien la valeur |
| // selectionnee car lors du setValue sur le keypress, gwtext ne prends pas en compte le dernier |
| // caractère |
| if(valeurChampBrute.trim().length() == 0) { |
| valeurChamp = ""; |
| } else { |
| if(valeurChamp != null && valeurChamp.length() > 0) { |
| if(valeurChamp.equals(valeurChampBrute.substring(0, valeurChampBrute.length() -1))) { |
| valeurChamp = champ.getRawValue(); |
| } |
| } |
| } |
| return valeurChamp; |
| } |
| public String getAbondance() { |
| return getValeurChampListeLibre(selecteurAbondance); |
| } |
| public String getCertitude() { |
| return getValeurChampListeLibre(selecteurCertitude); |
| } |
| public String getPhenologie() { |
| return getValeurChampListeLibre(selecteurStadePheno); |
| } |
| public String getReferentielTaxo() { |
| String codeCourt = getValeurChampListeLibre(selecteurReferentielTaxo); |
| return Ontologies.getInfosReferentielNomParCode(codeCourt).getCodeVersionComplet(); |
| } |
| public boolean communeInitialisee() { |
| return communeModifiee; |
| } |
| public void redimensionnerFormulaire() { |
| afficherFormulaireLatLon.setWidth(panneauIntermediaire.getWidth()+"px"); |
| panneauPremierColonne.doLayout(); |
| panneauSecondeColonne.doLayout(); |
| panneauIntermediaire.doLayout(); |
| doLayout(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java |
|---|
| New file |
| 0,0 → 1,179 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreDateObservationFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreEntiteGeographiqueObservationFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreMotsClesObservationVue; |
| import org.tela_botanica.client.vues.observation.filtres.RechercheLibreVue; |
| import com.gwtext.client.core.Ext; |
| 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 ArbreMotsClesObservationVue arbreMotsClesObservationVue = null ; |
| private RechercheLibreVue rechercheLibreVue = 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()); |
| rechercheLibreVue = new RechercheLibreVue(observationMediateur); |
| if(Ext.isIE()) { |
| add(rechercheLibreVue); |
| rechercheLibreVue.setHeight(110); |
| } else { |
| add(rechercheLibreVue,new RowLayoutData(100)); |
| } |
| rechercheLibreVue.setWidth("100%") ; |
| rechercheLibreVue.setBorder(false); |
| 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); |
| arbreMotsClesObservationVue = new ArbreMotsClesObservationVue(observationMediateur); |
| add(arbreMotsClesObservationVue, new RowLayoutData()); |
| arbreMotsClesObservationVue.setWidth("100%") ; |
| arbreMotsClesObservationVue.setTitle("Projets"); |
| arbreMotsClesObservationVue.setTitleCollapse(true); |
| arbreMotsClesObservationVue.setCollapsible(true); |
| arbreMotsClesObservationVue.setBorder(false); |
| } |
| /** |
| * 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 ArbreMotsClesObservationVue getArbreMotsClesObservationVue() { |
| return arbreMotsClesObservationVue; |
| } |
| public RechercheLibreVue getRechercheLibreVue() { |
| return rechercheLibreVue; |
| } |
| /** |
| * 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() || rechercheLibreVue.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(), |
| arbreMotsClesObservationVue.renvoyerValeursAFiltrer(), |
| rechercheLibreVue.renvoyerValeursAFiltrer() |
| }; |
| return filtres; |
| } |
| public void viderFiltres() { |
| arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(); |
| arbreDateObservationFiltreVue.viderFiltre(); |
| arbreMotsClesObservationVue.viderFiltre(); |
| rechercheLibreVue.viderFiltre(); |
| } |
| public void viderFiltres(String nom) { |
| if(nom.equals("id_mots_cles")) { |
| arbreMotsClesObservationVue.viderFiltre(); |
| } |
| if(nom.equals("recherche")) { |
| rechercheLibreVue.viderFiltre(); |
| } |
| if(nom.equals("annee") || nom.equals("mois") || nom.equals("jour")) { |
| arbreDateObservationFiltreVue.viderFiltre(nom); |
| } |
| if(nom.equals("station") || nom.equals("lieudit") || nom.equals("departement") || nom.equals("commune")) { |
| arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(nom); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/EtatConnexionVue.java |
|---|
| New file |
| 0,0 → 1,280 |
| /** |
| 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.objets.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></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() { |
| @Override |
| public void execute(EventObject e) { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| ExtElement lienAide = Ext.get("lienAide"); |
| if(lienAide != null) |
| { |
| lienAide.removeAllListeners(); |
| lienAide.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| }); |
| } |
| } |
| }); |
| } |
| } |
| /** |
| * 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() { |
| @Override |
| public void execute(EventObject e) { |
| carnetEnLigneMediateur.deconnecterUtilisateur(); |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() |
| { |
| @Override |
| public void onAfterLayout(Container c) |
| { |
| ExtElement lienDeco = Ext.get("etatConnexion"); |
| lienDeco.addListener("click", new EventCallback() { |
| @Override |
| 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() { |
| @Override |
| public void execute(EventObject e) { |
| carnetEnLigneMediateur.afficherDialogueConnexion(); |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| ExtElement lienCo = Ext.get("etatConnexion"); |
| lienCo.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| carnetEnLigneMediateur.afficherDialogueConnexion(); |
| } |
| }); |
| } |
| }); |
| } |
| } |
| ExtElement lienAide = Ext.get("lienAide"); |
| if(lienAide != null) |
| { |
| lienAide.removeAllListeners(); |
| lienAide.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| String aideUrl = Configuration.getAideBaseUrl() ; |
| Window.open(aideUrl, "", "") ; |
| } |
| }); |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| ExtElement lienAide = Ext.get("lienAide"); |
| if(lienAide != null) |
| { |
| lienAide.removeAllListeners(); |
| lienAide.addListener("click", new EventCallback() { |
| @Override |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java |
|---|
| New file |
| 0,0 → 1,202 |
| /** |
| 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); |
| 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() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText()); |
| } |
| } |
| ); |
| // Click sur bouton d'annulation |
| boutonAnnuler.addListener( |
| new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| cacher(); |
| } |
| } |
| ); |
| // gestion de la touche entrée |
| ident.addKeyListener(EventObject.ENTER, new KeyListener() { |
| @Override |
| public void onKey(int key, EventObject e) { |
| carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText()); |
| } |
| }); |
| // Mot de passe |
| motDePasse.addKeyListener(EventObject.ENTER, new KeyListener() { |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| * |
| */ |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/MiniBarrePaginationVue.java |
|---|
| New file |
| 0,0 → 1,322 |
| package org.tela_botanica.client.vues; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.user.client.Window; |
| 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.event.ComboBoxListenerAdapter; |
| public class MiniBarrePaginationVue 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 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 "); |
| /** |
| * retourne la liste associé à la barre |
| */ |
| public ListePaginable getlistePaginable() { |
| return listePaginable; |
| } |
| /*************************************************************************** |
| * constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MiniBarrePaginationVue() { |
| super(); |
| } |
| /** |
| * constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer à la barre |
| */ |
| public MiniBarrePaginationVue(ListePaginable lst) { |
| super(); |
| listePaginable = lst; |
| // on dispose un peu de texte et quelques espaces pour séparer les |
| // éléments |
| addButton(prevPage); |
| addSpacer(); |
| addButton(suivPage); |
| 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 "); |
| } |
| 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() { |
| @Override |
| 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 |
| // et on notifie le médiateur de l'évenement |
| listePaginable.changerNumeroPage(pageCourante); |
| } |
| } |
| }); |
| suivPage.addListener(new ButtonListenerAdapter() { |
| @Override |
| 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 |
| // et on notifie le médiateur de l'évenement |
| listePaginable.changerNumeroPage(pageCourante); |
| } |
| } |
| }); |
| // listener pour la selection dans la combobox |
| selecteurTaillePage.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| 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); |
| Window.alert("la nouvelle taille est :"+nouvelleTaillePageString); |
| } |
| }); |
| } |
| /** |
| * 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 |
| */ |
| @Override |
| 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); |
| } |
| } |
| } |
| /** |
| * 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); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/BarreNotationVue.java |
|---|
| New file |
| 0,0 → 1,227 |
| 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 |
| @Override |
| 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 |
| @Override |
| public void onMouseLeave(Widget sender) { |
| // on affiche la véritable note |
| afficherNote(); |
| } |
| }); |
| etoiles[i].addClickListener(new ClickListener() { |
| // si on clique sur une étoiles |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/MenuImageVue.java |
|---|
| New file |
| 0,0 → 1,190 |
| 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 Item gestionMotsCles = 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"); |
| gestionMotsCles = new Item("Gérer les mots clés"); |
| 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); |
| addItem(gestionMotsCles); |
| 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 |
| @Override |
| 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(); |
| } |
| // si c'est l'affichage de la selection |
| if (item.equals(gestionMotsCles)) { |
| getIMediateur().afficherFenetreGestionMotsCles(); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| @Override |
| public void onShow(Menu menu) { |
| if(getIMediateur().getCompteSelection() != 0) { |
| afficherSelection.enable(); |
| viderSelection.enable(); |
| } |
| else { |
| afficherSelection.disable(); |
| viderSelection.disable(); |
| } |
| } |
| }); |
| mn.addListener(new MenuListenerAdapter() { |
| @Override |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/ZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,608 |
| 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.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.event.dom.client.LoadEvent; |
| import com.google.gwt.event.dom.client.LoadHandler; |
| import com.google.gwt.event.dom.client.MouseWheelEvent; |
| import com.google.gwt.event.dom.client.MouseWheelHandler; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.ui.Image; |
| 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.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.ToolbarTextItem; |
| 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; |
| private Panel infosTaxon = new Panel(); |
| /** |
| * 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>") ; |
| /**. |
| * boolean de gestion du double clic |
| */ |
| private boolean enClic = false; |
| private ToolbarButton modeZoom = null; |
| private ToolbarTextItem valeurZoom = new ToolbarTextItem("x 1"); |
| protected boolean scroll = 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"); |
| // l'image de base est vide |
| image.setUrl("vide.jpg"); |
| this.setLayout(new BorderLayout()); |
| prev.setWidth("60px"); |
| suiv.setWidth("60px"); |
| modeZoom = new ToolbarButton("Mode Zoom"); |
| Toolbar tb = new Toolbar(); |
| tb.addButton(modeZoom); |
| tb.addItem(valeurZoom); |
| //setTopToolbar(tb); |
| infosTaxon = new Panel(); |
| infosTaxon.setHeader(false); |
| //infosTaxon.setBorder(false); |
| infosTaxon.setHeight("30px"); |
| this.add(prev, new BorderLayoutData(RegionPosition.WEST)); |
| this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER)); |
| this.add(suiv, new BorderLayoutData(RegionPosition.EAST)); |
| this.add(infosTaxon, new BorderLayoutData(RegionPosition.SOUTH)); |
| imageConteneur.setMaskDisabled(true); |
| this.setBorder(false); |
| conteneurInitialise = true; |
| initialise = true; |
| configDragAndDrop() ; |
| // on ajoute les listeners |
| ajouterListeners(); |
| tp.setDismissDelay(1050); |
| 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 |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| //niveauZoom = 1; |
| // 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]) ; |
| String infosTaxon = "" ; |
| if(infos.length == 5 && infos[4] != null) { |
| infosTaxon = infos[4]; |
| } |
| setInfosTaxon(infosTaxon); |
| verifierEtRetaillerImage(); |
| } |
| } |
| } |
| /** |
| * Desactive visuellement le panneau et les boutons |
| */ |
| public void desactiverPanneau() { |
| getImage().setUrl("vide.jpg"); |
| 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.mask("Chargement"); |
| } |
| } |
| public void demasquerChargement() { |
| ExtElement imgEl = Ext.get(imageConteneur.getElement()); |
| if(imgEl != null) { |
| imgEl.unmask(); |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| image.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(!scroll) { |
| if(enClic) { |
| getIMediateur().doubleClicZoomImage(); |
| } else { |
| Timer t = new Timer() { |
| @Override |
| public void run() { |
| enClic = false; |
| } |
| }; |
| enClic = true; |
| t.schedule(800); |
| } |
| } |
| } |
| }); |
| image.addLoadHandler(new LoadHandler() { |
| @Override |
| public void onLoad(LoadEvent event) { |
| verifierEtRetaillerImage(); |
| Ext.get(image.getElement()).center(imageConteneur.getElement()); |
| demasquerChargement(); |
| } |
| }); |
| image.addMouseWheelHandler(new MouseWheelHandler() { |
| @Override |
| public void onMouseWheel(MouseWheelEvent event) { |
| if(event.isNorth()) { |
| masquerChargement(); |
| getIMediateur().clicBoutonZoomImage("suiv"); |
| } else { |
| masquerChargement(); |
| getIMediateur().clicBoutonZoomImage("prev"); |
| } |
| } |
| }); |
| // gestion du clic sur le bouton précedent |
| prev.addClickHandler(new ClickHandler() { |
| // en cas de clic |
| @Override |
| public void onClick(ClickEvent event) { |
| // on notifie le médiateur |
| masquerChargement(); |
| getIMediateur().clicBoutonZoomImage("prev"); |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickHandler(new ClickHandler() { |
| // en cas de clic |
| @Override |
| public void onClick(ClickEvent event) { |
| // on notifie le médiateur |
| masquerChargement(); |
| getIMediateur().clicBoutonZoomImage("suiv"); |
| } |
| }); |
| // gestion du redimensionnement |
| this.addListener(new PanelListenerAdapter() { |
| // lors d'un redimensionnement de l'application |
| @Override |
| 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 |
| @Override |
| 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 modifie enfin la taille de l'image pour qu'elle soit affichée |
| int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth()); |
| int[] tailleImage = new int[2]; |
| if(Ext.isIE()) { |
| image.setHeight(calculerDimensions(getTailleImage(),max,max)[1]+"px"); |
| image.setWidth(calculerDimensions(getTailleImage(),max,max)[0]+"px"); |
| } else { |
| if(max == imageConteneur.getHeight()) { |
| tailleImage[0] = getTailleImage()[0]; |
| tailleImage[1] = max; |
| image.setHeight(max+"px"); |
| } else { |
| tailleImage[1] = getTailleImage()[0]; |
| tailleImage[0] = max; |
| image.setWidth(max+"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) |
| { |
| @Override |
| 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 ; |
| } |
| @Override |
| 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 ; |
| } |
| public void setInfosTaxon(String nomTaxon) { |
| if(nomTaxon != null && !nomTaxon.equals("")) { |
| nomTaxon = getNomsObservationsFormatees(nomTaxon); |
| } |
| infosTaxon.setHtml("<div id='infos_taxon'><span class='texte_info_taxon'>"+nomTaxon+"</span></div>"); |
| infosTaxon.doLayout(); |
| } |
| /** |
| * 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; |
| } |
| public boolean estPortrait() { |
| return imageHeight > imageWidth; |
| } |
| public boolean estPaysage() { |
| return !estPortrait(); |
| } |
| /** |
| * Accesseur pour le conteneur de l'image |
| * @return le conteur de l'image |
| */ |
| public Panel getImageConteneur() { |
| return imageConteneur; |
| } |
| private String getNomsObservationsFormatees(String nomObs) { |
| String htmlInfobulle = ""; |
| String[][] obs = getObservationsAssociees(nomObs); |
| for(int i = 0; i < obs.length; i++) { |
| if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) { |
| htmlInfobulle += ", "+obs[i][1]; |
| } |
| } |
| htmlInfobulle = htmlInfobulle.replaceFirst(", ", ""); |
| return htmlInfobulle; |
| } |
| private String[][] getObservationsAssociees(String nomObs) { |
| if(nomObs.trim().equals("")) { |
| return new String[0][0]; |
| } |
| String[] obsTab = nomObs.split(";;"); |
| String[][] obsAnalysees = new String[obsTab.length][3]; |
| for(int i = 0; i < obsTab.length; i++) { |
| obsAnalysees[i] = obsTab[i].split("#"); |
| } |
| return obsAnalysees; |
| } |
| private boolean[] estAssocieeTransmise(String nomObs) { |
| String[][] obs = getObservationsAssociees(nomObs); |
| boolean[] associeesTranmises = {false, false}; |
| if(obs.length > 0) { |
| associeesTranmises[0] = true; |
| } |
| for(int i = 0; i < obs.length; i++) { |
| if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) { |
| associeesTranmises[1] = true; |
| } |
| } |
| return associeesTranmises; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/filtres/BarreRechercheFiltreVue.java |
|---|
| New file |
| 0,0 → 1,191 |
| 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.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.TextField; |
| import com.gwtext.client.widgets.layout.HorizontalLayout; |
| /** |
| * 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() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| @Override |
| 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 |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| filtreModifie = false; |
| } |
| /** |
| * renvoie l'état du filtre (modifié ou non) |
| * |
| * @return l'état du filtre |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Recherche "; |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| valider() ; |
| String[] valeurFiltre = { "recherche", 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 |
| */ |
| @Override |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/filtres/SelectionFiltreVue.java |
|---|
| New file |
| 0,0 → 1,98 |
| 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); |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Filtre par tampon"; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| if (check.getValue()) { |
| String[] val = { "ci_id_tampon", iMediateur.renvoyerSelection() }; |
| return val; |
| } |
| String[] val = { "ci_id_tampon", "" }; |
| return val; |
| } |
| @Override |
| public void valider() { |
| filtreModifie = true; |
| } |
| @Override |
| public void viderFiltre() { |
| check.setChecked(false); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/filtres/ArbreDateImageFiltreVue.java |
|---|
| New file |
| 0,0 → 1,588 |
| 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.objets.DateObservation; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import org.tela_botanica.client.util.Util; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.Panel; |
| 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() { |
| @Override |
| 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() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages(); |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| imageMediateur.obtenirPhotoGalerie() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| 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 ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| donneesDateEnCours = ""; |
| 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() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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=data.get(it.next()); |
| annee= ent.getAnnee() ; |
| mois= ent.getMois() ; |
| String moisLettre = Util.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() { |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| public int compare(TreeNode o1, TreeNode o2) { |
| String n1 = ((String[])o1.getUserObject())[1] ; |
| String n2 = ((String[])o2.getUserObject())[1] ; |
| return n1.compareTo(n2) ; |
| } |
| } ; |
| } |
| 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() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| donneesDateEnCours = ""; |
| } |
| public void obtenirDatesImages() { |
| imageMediateur.obtenirDatesImages(this); |
| } |
| @Override |
| public void viderFiltre() { |
| donneesDateEnCours = ""; |
| arbreDonneesDates.getSelectionModel().clearSelections(); |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreDonneesDates.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("annee")) { |
| profondeur = 1; |
| } |
| if(nom.equals("mois")) { |
| profondeur = 2; |
| } |
| if(nom.equals("jour")) { |
| profondeur = 3; |
| } |
| return profondeur; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/filtres/RechercheFiltreTaxonVue.java |
|---|
| New file |
| 0,0 → 1,118 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| 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.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() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| break; |
| } |
| } |
| }); |
| add(champRecherche); |
| add(boutonRechercher); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setPaddings(5); |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return estModifie; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Recherche Libre"; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String nom = "recherche"; |
| if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) { |
| valeurRecherchee = champRecherche.getValueAsString(); |
| nom = "recherche"; |
| } else { |
| nom = "recherche"; |
| valeurRecherchee = ""; |
| } |
| String[] valeurs = {nom,valeurRecherchee}; |
| return valeurs; |
| } |
| @Override |
| 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 = ""; |
| } |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| valeurRecherchee = ""; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/filtres/PanneauFiltresImagesVues.java |
|---|
| New file |
| 0,0 → 1,208 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| 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 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 libre |
| */ |
| private BarreRechercheFiltreVue rechercheLibreFiltreVue = 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() { |
| @Override |
| 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; |
| } |
| /** |
| * Accesseur pour le filtre des dates |
| * |
| * @return le filtre des dates |
| */ |
| public ArbreDateImageFiltreVue getArbreDateRecherche() { |
| return arbreDateImageFiltreVue; |
| } |
| /** |
| * 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; |
| } |
| public void viderFiltres() { |
| motsClesFiltres.viderFiltre(); |
| rechercheLibreFiltreVue.viderFiltre(); |
| arbreDateImageFiltreVue.viderFiltre(); |
| selectionFiltreVue.viderFiltre(); |
| } |
| public void viderFiltre(String nom) { |
| if(nom.equals("id_mots_cles")) { |
| motsClesFiltres.viderFiltre(); |
| } |
| if(nom.equals("recherche")) { |
| rechercheLibreFiltreVue.viderFiltre(); |
| } |
| if(nom.equals("annee") || nom.equals("mois") || nom.equals("jour")) { |
| arbreDateImageFiltreVue.viderFiltre(nom); |
| } |
| if(nom.equals("ci_id_tampon")) { |
| selectionFiltreVue.viderFiltre(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,640 |
| package org.tela_botanica.client.vues.image; |
| import java.util.Iterator; |
| 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.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.util.Util; |
| import org.tela_botanica.client.vues.MiniBarrePaginationVue; |
| 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.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.event.GridListenerAdapter; |
| 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; |
| 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, ListePaginable { |
| /** |
| * 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 MiniBarrePaginationVue pgBar = new MiniBarrePaginationVue(this) ; |
| 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; |
| int pageEnCours = 0; |
| int nbElements = 0; |
| int taillePage = 50; |
| private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION"; |
| /** |
| * Nombre de pages totales |
| */ |
| private int pageMax = 1 ; |
| /** |
| * Constructeur avec arguments |
| * @param im le médiateur à associer à la vue |
| */ |
| public MiniListeObservationVue(ImageMediateur im) |
| { |
| iMediateur = im ; |
| this.setId("x-view-mini-obs") ; |
| // 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() { |
| @Override |
| 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 "" ; |
| } |
| return value.toString() ; |
| } |
| } ; |
| Renderer dateRend = new Renderer() { |
| @Override |
| 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() ; |
| } |
| } ; |
| // on crée un store simple contenant un petit set de données et deux colonnes |
| store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, getObs()); |
| ColumnConfig[] columns = { |
| new ColumnConfig("", "transmis", 30, true, new Renderer() { |
| @Override |
| 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 "" ; |
| } |
| } |
| }), |
| new ColumnConfig("Taxon", "plante", 145, true, colRend), |
| new ColumnConfig("Date", "date", 68, true, dateRend), |
| new ColumnConfig("Lieu", "lieu", 145, true, colRend), |
| new ColumnConfig("Numero", "ordre_obs", 50, true, colRend), } ; |
| 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() { |
| @Override |
| 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.addGridListener(new GridListenerAdapter() { |
| @Override |
| public void onContextMenu(EventObject e) { |
| // si pas de selection, on selection au moins la ligne sur laquelle on a fait le clic |
| if(getSelectionModel().getSelections().length <= 0) { |
| int index = getView().findRowIndex(e); |
| Record rddrop = getStore().getRecordAt(index) ; |
| getSelectionModel().selectRecords(rddrop); |
| } |
| e.stopEvent() ; |
| MenuLiaisonVue mlv = new MenuLiaisonVue(iMediateur,liaison) ; |
| mlv.showAt(e.getXY()) ; |
| } |
| }) ; |
| obtenirNombreMiniListeObservations(); |
| } |
| /** |
| * 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) |
| { |
| @Override |
| 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 ; |
| } |
| @Override |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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()][6] ; |
| int i = 0 ; |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| Observation obs=data.get(it.next()); |
| listeObs[i][0] = obs.getTransmis(); |
| listeObs[i][1] = obs.getNomSaisi(); |
| listeObs[i][2] = obs.getDate() ; |
| listeObs[i][3] = Util.formaterLieu(obs, modeleLieu); |
| listeObs[i][4] = obs.getNumeroOrdre(); |
| listeObs[i][5] = obs.getId(); |
| i++ ; |
| } |
| store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, listeObs); |
| store.load(); |
| this.reconfigure(store, colModel) ; |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onShow(Component c) |
| { |
| obtenirNombreMiniListeObservations() ; |
| } |
| @Override |
| public void onAfterLayout(Container c) |
| { |
| obtenirNombreMiniListeObservations() ; |
| } |
| }) ; |
| } |
| } |
| // 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,nbElements) ; |
| masquerChargement(); |
| obtenirMiniListeObservations(); |
| } |
| redimensionner(); |
| deMasquerChargement() ; |
| } |
| private void obtenirMiniListeObservations() |
| { |
| iMediateur.obtenirMiniListeObservations(this, taillePage, pageEnCours) ; |
| } |
| private void obtenirNombreMiniListeObservations() |
| { |
| iMediateur.obtenirNombreMiniListeObservations(this) ; |
| } |
| /** |
| * Renvoie le faux set de données pour le store |
| * @return un tableau à deux colonnes int - String |
| */ |
| private Object[][] getObs() { |
| return new Object[][]{ |
| } ; |
| } |
| @Override |
| public Store getStore() |
| { |
| return store ; |
| } |
| public MiniBarrePaginationVue getBarrePagination() |
| { |
| return pgBar ; |
| } |
| private void setModification(String mode) |
| { |
| if(mode.equals("true")) { |
| liaison = true ; |
| selecteurMode.removeClass("x-selec-consult") ; |
| selecteurMode.setCls("x-selec-liaison") ; |
| getBarrePagination().disable(); |
| doLayout(); |
| } |
| else |
| { |
| liaison = false ; |
| selecteurMode.removeClass("x-selec-liaison") ; |
| selecteurMode.setCls("x-selec-consult") ; |
| getBarrePagination().enable(); |
| doLayout(); |
| } |
| 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 = ""; |
| for(int i = 0; i < sels.length; i++) { |
| id += ","+sels[i].getAsString("id_obs") ; |
| } |
| id = id.replaceFirst(",", ""); |
| 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) { |
| int taille = 400; |
| if(Window.getClientHeight() > 800 ) { |
| taille = Window.getClientHeight() - 350; |
| } |
| setHeight(taille); |
| getView().setForceFit(true); |
| doLayout(); |
| } |
| else { |
| } |
| } |
| /** |
| * Montre le menu de liaison aux coordonnées indiquées |
| * @param e |
| */ |
| public void montrerContextMenuLiaison(EventObject e) { |
| final Menu liObs = new Menu(); |
| final Item lierObservation = new Item("Lier aux images selectionnées"); |
| liObs.addItem(lierObservation); |
| liObs.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject ev) { |
| // si c'est la suppression |
| if (item.equals(lierObservation)) { |
| // on notifie le médiateur |
| } |
| // enfin, on cache le menu |
| liObs.hide(); |
| } |
| }); |
| liObs.showAt(e.getXY()); |
| } |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| pageEnCours = pageCourante ; |
| masquerChargement(); |
| // On lance le chargerment des observations |
| iMediateur.obtenirNombreMiniListeObservations(this); |
| } |
| /** |
| * Appelle le modèle pour qu'il change la taille de page utilisée |
| * @param nouvelleTaillePage la nouvelle taille de page |
| */ |
| @Override |
| public void changerTaillePage(int nouvelleTaillePage) |
| { |
| taillePage = nouvelleTaillePage ; |
| pageEnCours = calculerPageCourante(nbElements) ; |
| masquerChargement(); |
| // On lance le chargerment des observations |
| iMediateur.obtenirNombreMiniListeObservations(this); |
| // et on met à jour la taille de page dans les barres d'outils |
| pgBar.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} ; |
| pgBar.rafraichir(pages, false) ; |
| } |
| /** |
| * 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()) ; |
| } |
| 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; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/PanneauMetadonneesVue.java |
|---|
| New file |
| 0,0 → 1,526 |
| 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.image.ImageMotsClesVue; |
| import org.tela_botanica.client.vues.image.filtres.RechercheFiltreTaxonVue; |
| import com.google.gwt.user.client.Timer; |
| 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.Ext; |
| import com.gwtext.client.core.NameValuePair; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| 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.ContainerListenerAdapter; |
| 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.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| 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 ImageMotsClesVue 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 barre de recherche rapide des taxons |
| */ |
| private RechercheFiltreTaxonVue rechercheFiltreTaxonVue = 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; |
| Timer timerRedimensionnement = null; |
| /** |
| * 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 ImageMotsClesVue(im); |
| panneauMotsCles.setHeight("50%"); |
| 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") ; |
| if(!Ext.isIE()) { |
| panneauMiniListeObservation.setLayout(new RowLayout()); |
| } |
| miniListeObservation = new MiniListeObservationVue(im); |
| rechercheFiltreTaxonVue = new RechercheFiltreTaxonVue(im); |
| rechercheFiltreTaxonVue.setTitle("Recherche dans les observations"); |
| if(Ext.isIE()) { |
| panneauMiniListeObservation.add(rechercheFiltreTaxonVue); |
| rechercheFiltreTaxonVue.setHeight(90); |
| } else { |
| panneauMiniListeObservation.add(rechercheFiltreTaxonVue, new RowLayoutData(90)); |
| } |
| rechercheFiltreTaxonVue.setWidth("100%") ; |
| rechercheFiltreTaxonVue.setBorder(false); |
| if(Ext.isIE()) { |
| panneauMiniListeObservation.add(miniListeObservation, new RowLayoutData(400)) ; |
| } else { |
| panneauMiniListeObservation.add(miniListeObservation, new RowLayoutData()) ; |
| } |
| 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); |
| panneauExifGrid.setAutoScroll(true); |
| panneauIptcGrid.setAutoScroll(true); |
| panneauInfoGrid.add(sousPanneauInfosGenerales); |
| panneauInfoGrid.add(panneauMotsCles); |
| this.add(panneauMiniListeObservation) ; |
| this.add(panneauInfoGrid); |
| 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.setHeight(500); |
| ExifGrid.setSorted(false); |
| ExifGrid.setAutoScroll(true); |
| 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.setHeight(500); |
| IptcGrid.setSorted(false); |
| IptcGrid.setAutoScroll(true); |
| 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 |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| public void onCellDblClick(GridPanel grid, int rowIndex, |
| int colIndex, EventObject e) { |
| // on empeche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| }); |
| panneauMiniListeObservation.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, |
| int rawWidth, int rawHeight) { |
| timerRedimensionnement = new Timer() { |
| @Override |
| public void run() { |
| int taille = 500; |
| if(Window.getClientHeight() > 800 ) { |
| taille = Window.getClientHeight() - 226; |
| } |
| panneauMiniListeObservation.setHeight(taille); |
| } |
| }; |
| timerRedimensionnement.schedule(300); |
| } |
| }); |
| panneauExifGrid.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, |
| int rawWidth, int rawHeight) { |
| timerRedimensionnement = new Timer() { |
| @Override |
| public void run() { |
| int taille = 500; |
| taille = Window.getClientHeight() - 150; |
| ExifGrid.setHeight(taille); |
| panneauExifGrid.setHeight(taille); |
| } |
| }; |
| timerRedimensionnement.schedule(300); |
| } |
| }); |
| panneauExifGrid.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, |
| int rawWidth, int rawHeight) { |
| timerRedimensionnement = new Timer() { |
| @Override |
| public void run() { |
| int taille = 500; |
| taille = Window.getClientHeight() - 150; |
| IptcGrid.setHeight(taille); |
| panneauIptcGrid.setHeight(taille); |
| } |
| }; |
| timerRedimensionnement.schedule(300); |
| } |
| }); |
| } |
| /** |
| * Desactive visuellement ce panneau |
| */ |
| public void desactiverPanneau() { |
| panneauInfoGrid.setDisabled(true); |
| panneauExifGrid.setDisabled(true); |
| panneauIptcGrid.setDisabled(true); |
| } |
| /** |
| * Active visuellement ce panneau |
| */ |
| public void activerPanneau() { |
| panneauInfoGrid.setDisabled(false); |
| panneauExifGrid.setDisabled(false); |
| panneauIptcGrid.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 |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit un tableau d'objets |
| if (nouvelleDonnees instanceof Object[]) { |
| final Object ressourceObject = nouvelleDonnees; |
| if(!this.isRendered()) { |
| addListener(new PanelListenerAdapter() { |
| @Override |
| public void onRender(Component component) { |
| rafraichir(ressourceObject, false); |
| } |
| }); |
| return ; |
| } |
| // extrait infos, exifs et iptc |
| Object meta[] = (Object[]) nouvelleDonnees; |
| String[][] exif = (String[][]) meta[0]; |
| String[][] iptc = (String[][]) meta[1]; |
| final 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.setValue(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 ImageMotsClesVue getPanneauMotsCles() { |
| return panneauMotsCles; |
| } |
| public BarreNotationVue getNoteVue() { |
| return noteVue; |
| } |
| public MiniListeObservationVue getMiniListeObservation() |
| { |
| return miniListeObservation ; |
| } |
| public RechercheFiltreTaxonVue getRechercheFiltreTaxonVue() |
| { |
| return rechercheFiltreTaxonVue ; |
| } |
| public void redimensionner() { |
| if(panneauMiniListeObservation.isCreated() && panneauMiniListeObservation.isVisible()) { |
| panneauMiniListeObservation.doLayout(); |
| //panneauMiniListeObservation.show(); |
| miniListeObservation.redimensionner(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/BarreOutilsVue.java |
|---|
| New file |
| 0,0 → 1,235 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.util.Util; |
| import org.tela_botanica.client.vues.MenuAideVue; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.SplitButton; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.ToolbarMenuButton; |
| import com.gwtext.client.widgets.ToolbarTextItem; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.SplitButtonListenerAdapter; |
| /** |
| * 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 |
| */ |
| OptionsImages imageMenuEtendu = null; |
| /** |
| * L'item affichant les filtres en cours |
| */ |
| ToolbarTextItem texteFiltres; |
| /** |
| * 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); |
| imageMenuEtendu = new OptionsImages(im); |
| //aideMenu = new MenuAideVue(im); |
| //images = new ToolbarMenuButton("Fichiers", imageMenu); |
| //aide = new ToolbarMenuButton("Aide", aideMenu); |
| texteFiltres = new ToolbarTextItem(""); |
| final ToolbarMenuButton menuImage = new ToolbarMenuButton("Ajouter des images", imageMenuEtendu.getMenuImage()); |
| menuImage.addListener(new SplitButtonListenerAdapter() { |
| @Override |
| public void onArrowClick(SplitButton menuButton, EventObject e) { |
| menuImage.showMenu(); |
| } |
| @Override |
| public void onClick(Button button, EventObject e) { |
| menuImage.showMenu(); |
| } |
| }); |
| ToolbarButton menuSuppression = imageMenuEtendu.getBoutonSuppression(); |
| final ToolbarMenuButton menuTampon = new ToolbarMenuButton("Tampon", imageMenuEtendu.getMenuTampon()); |
| menuTampon.addListener(new SplitButtonListenerAdapter() { |
| @Override |
| public void onArrowClick(SplitButton menuButton, EventObject e) { |
| menuTampon.showMenu(); |
| } |
| @Override |
| public void onClick(Button button, EventObject e) { |
| menuTampon.showMenu(); |
| } |
| }); |
| ToolbarButton menuGestionMotsCles = new ToolbarButton("Gérer les mots clés"); |
| menuGestionMotsCles.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| getIMediateur().afficherFenetreGestionMotsCles(); |
| } |
| }); |
| this.addButton(menuImage); |
| this.addButton(menuSuppression); |
| this.addButton(menuGestionMotsCles); |
| this.addButton(menuTampon); |
| this.addItem(texteFiltres); |
| //this.addButton(aide); |
| } |
| /** |
| * @return the images |
| */ |
| public ToolbarMenuButton getImages() { |
| return images; |
| } |
| /** |
| * @return the iMediateur |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| public void setFiltresEnCours(String[][] filtresEnCours) { |
| String texteFiltresEnCours = ""; |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours += " - "; |
| } |
| texteFiltresEnCours += "<span class=\"affichage_filtre\">"+ |
| transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+ |
| " <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_img_"+filtresEnCours[i][0]+"\" />"+ |
| "</span>"; |
| } |
| } |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>"; |
| } |
| texteFiltres.setText(texteFiltresEnCours); |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(Ext.get("bouton_raz_filtres_img_"+filtresEnCours[i][0]) != null) { |
| Ext.get("bouton_raz_filtres_img_"+filtresEnCours[i][0]).addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| e.stopEvent(); |
| iMediateur.viderFiltre(e.getTarget().getAttribute("rel")); |
| } |
| }); |
| } |
| } |
| } |
| } |
| private String transformerNomFiltre(String nomFiltre) { |
| if(nomFiltre.equals("id_mots_cles")) { |
| nomFiltre = "mots clés"; |
| } |
| return nomFiltre; |
| } |
| private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) { |
| String valeurFiltreTransformee = valeurFiltre; |
| if(nomFiltre.equals("id_mots_cles")) { |
| String[] tabMotsCles = valeurFiltre.split(";"); |
| String[] tabMotsClesTexte = iMediateur.getTexteMotsCles(tabMotsCles); |
| if(tabMotsClesTexte.length > 1) { |
| valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte); |
| } else { |
| valeurFiltreTransformee = tabMotsClesTexte[0]; |
| } |
| } |
| if(nomFiltre.equals("mois")) { |
| valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre)); |
| } |
| return valeurFiltreTransformee; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/FenetreGestionMotsCles.java |
|---|
| New file |
| 0,0 → 1,672 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.dd.DD; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragDrop; |
| 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.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListener; |
| import com.gwtext.client.widgets.event.PanelListener; |
| import com.gwtext.client.widgets.event.WindowListener; |
| import com.gwtext.client.widgets.event.WindowListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.HorizontalLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| import com.gwtext.client.widgets.tree.DropNodeCallback; |
| import com.gwtext.client.widgets.tree.MultiSelectionModel; |
| import com.gwtext.client.widgets.tree.TreeEditor; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| import com.gwtext.client.widgets.tree.TreePanel; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListener; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| /** |
| * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots |
| * clés cochables et réorganisables à volonté |
| * |
| * @author aurelien |
| * |
| */ |
| public abstract class FenetreGestionMotsCles extends com.gwtext.client.widgets.Window implements Rafraichissable { |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreMotsCles = null; |
| /** |
| * L'éditeur qui permet de modifier les mots clés dans l'arbre |
| */ |
| private TreeEditor te = null; |
| /** |
| * Le textfield associé à l'éditeur |
| */ |
| private TextField tfEdit = null; |
| /** |
| * Bouton de validation |
| */ |
| private Button valider = null; |
| /** |
| * Bouton d'annulation |
| */ |
| private Button annuler = null; |
| /** |
| * Bouton d'ajout de tag |
| */ |
| private ToolbarButton ajouterTag = null; |
| /** |
| * Bouton de suppression de tag |
| */ |
| private ToolbarButton supprimerTag = null; |
| /** |
| * Bouton de renommage de tag |
| */ |
| private ToolbarButton renommerTag = null; |
| /** |
| * Une string permettant connaitre les mots clés cochés en cours séparés par |
| * des virgules |
| */ |
| private String motsClesEnCours = ""; |
| private String[] tableauMotsClesEnCours = new String[0]; |
| /** |
| * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre |
| * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu |
| * du conteneur n'ai été effectué) |
| */ |
| private String[] motsClesEnAttente = new String[0]; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un |
| * noeud |
| */ |
| private boolean ajoutNoeud = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train de modifier un |
| * noeud |
| */ |
| private boolean modifNoeud = false; |
| /** |
| * Booléen d'instanciation du conteneur |
| */ |
| private boolean arbreCharge = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu |
| */ |
| private boolean motsCleInitialises; |
| /** |
| * panneau intermédiaire contenant l'arbre |
| */ |
| private Panel panelIntermediaire; |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public FenetreGestionMotsCles() { |
| // on crée le panel |
| setTitle("Mots clés"); |
| this.setLayoutData(new RowLayout()); |
| // on crée le conteneur de l'arbre |
| arbreMotsCles = new TreePanel(); |
| // on permet le drag and drop dans l'arbre |
| arbreMotsCles.setEnableDD(true); |
| arbreMotsCles.setId("x-view-tree-keyword-imgs"); |
| arbreMotsCles.setSelectionModel(new MultiSelectionModel()); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Tags"); |
| root.setId("racine"); |
| String[] usObject = { "Mots clés", "racine" }; |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.setRootVisible(true); |
| arbreMotsCles.setBorder(false); |
| arbreMotsCles.setWidth(500); |
| root.setUserObject(usObject); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onClick(Node node, EventObject e) { |
| if(!arbreCharge) { |
| expand(); |
| } |
| } |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| arbreCharge = true; |
| } |
| } |
| }); |
| // on crée l'éditeur pour l'arbre |
| tfEdit = new TextField(); |
| tfEdit.setAutoWidth(true); |
| te = new TreeEditor(arbreMotsCles, tfEdit); |
| valider = new Button("Appliquer"); |
| annuler = new Button("Annuler"); |
| arbreMotsCles.add(te); |
| panelIntermediaire = new Panel(); |
| panelIntermediaire.setLayout(new FitLayout()); |
| panelIntermediaire.setAutoScroll(true); |
| panelIntermediaire.setWidth("100%"); |
| arbreMotsCles.setWidth("100%"); |
| arbreMotsCles.setHeight("100%"); |
| Panel panelBoutons = new Panel(); |
| panelBoutons.setLayout(new HorizontalLayout(130)); |
| panelBoutons.setWidth("100%"); |
| // on met en forme le layout |
| panelIntermediaire.add(arbreMotsCles); |
| panelBoutons.add(annuler); |
| panelBoutons.add(valider); |
| this.add(panelIntermediaire, new RowLayoutData()); |
| this.add(panelBoutons, new RowLayoutData(30)); |
| arbreMotsCles.setHeight("100%"); |
| arbreMotsCles.setAutoScroll(true); |
| Toolbar barreBouton = new Toolbar(); |
| ajouterTag = new ToolbarButton("Nouveau Tag"); |
| ajouterTag.setIcon("mot_cle_ajouter.png"); |
| renommerTag = new ToolbarButton("Renommer"); |
| renommerTag.setIcon("mot_cle_editer.png"); |
| renommerTag.disable(); |
| supprimerTag = new ToolbarButton("Supprimer"); |
| supprimerTag.setIcon("mot_cle_supprimer.png"); |
| supprimerTag.disable(); |
| barreBouton.addButton(ajouterTag); |
| barreBouton.addSeparator(); |
| barreBouton.addButton(renommerTag); |
| barreBouton.addSeparator(); |
| barreBouton.addButton(supprimerTag); |
| this.setTopToolbar(barreBouton); |
| setCloseAction(com.gwtext.client.widgets.Window.HIDE); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Acesseur pour l'arbre des mots clés |
| * |
| * @return le panel contenant l'arbre |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreMotsCles; |
| } |
| /** |
| * Accesseur pour l'éditeur |
| * |
| * @return l'éditeur associé à l'arbre |
| */ |
| public TreeEditor getTe() { |
| return te; |
| } |
| /** |
| * Acesseur pour le TextField associé à l'éditeur |
| * |
| * @return le champ texte associé à l'éditeur |
| */ |
| public TextField getTfEdit() { |
| return tfEdit; |
| } |
| protected abstract void surAffichageMenuContextuel(TreeNode node, EventObject e, TreeEditor te); |
| protected abstract void surAjoutMotCle(TreeNode node, Tree arbre); |
| protected abstract void surSuppressionMotCle(TreeNode node, Tree arbre); |
| protected abstract void surDeplacementMotCle(TreeNode node, Tree arbre); |
| protected abstract void surChangementTexte(TreeNode node, Tree arbre); |
| protected abstract void surClicValider(String chaineMotsCles, Tree arbre); |
| protected abstract void demanderArbreMotsCles(Rafraichissable r); |
| /** |
| * Ajoute les listeners nécessaires pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new WindowListenerAdapter() { |
| @Override |
| public void onResize(com.gwtext.client.widgets.Window source, int width, |
| int height) { |
| panelIntermediaire.setHeight(getHeight() - 80); |
| } |
| }); |
| arbreMotsCles.addListener(new TreePanelListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container self) { |
| panelIntermediaire.setHeight(getHeight() - 80); |
| } |
| @Override |
| public void onExpandNode(TreeNode node) { |
| cocherMotsCles(tableauMotsClesEnCours); |
| } |
| // gestion du clic sur un noeud |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| gererClicNoeud(node); |
| if(!node.equals(arbreMotsCles.getRootNode())) { |
| supprimerTag.enable(); |
| renommerTag.enable(); |
| } |
| } |
| // gestion du clic droit sur un noeud |
| @Override |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| surAffichageMenuContextuel(node, e, getTe()); |
| if(!node.equals(arbreMotsCles.getRootNode())) { |
| supprimerTag.enable(); |
| renommerTag.enable(); |
| } |
| } |
| // gestion de la modification du texte d'un noeud |
| @Override |
| public void onTextChange(TreeNode node, String text, String oldText) { |
| if(node.equals(arbreMotsCles.getRootNode())) { |
| return; |
| } |
| // on récupère les informations associées au noeud |
| TreeNode nd = node; |
| String[] usObject = new String[2]; |
| usObject[0] = text; |
| usObject[1] = ((String[]) nd.getUserObject())[1]; |
| nd.setUserObject(usObject); |
| // si c'est un nouveau noeud |
| if (ajoutNoeud) { |
| // on considère l'ajout achevé |
| ajoutNoeud = false; |
| // et on notifie le médiateur de l'ajout et on lui passe |
| // l'arbre |
| surAjoutMotCle(nd, getArbreMotsCles().getTree()); |
| } |
| // si c'est noeud déjà existant |
| else { |
| // on considère la modification achevée |
| modifNoeud = false; |
| if(!text.equals(oldText)) { |
| // et on notifie le médiateur de la modification et on lui |
| // passe l'arbre |
| surChangementTexte(nd, getArbreMotsCles().getTree()); |
| } |
| } |
| } |
| // gestion du déplacement d'un noeud |
| @Override |
| public void onMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| // on notifie le médiateur et on lui passe l'arbre |
| surDeplacementMotCle(node, getArbreMotsCles().getTree()); |
| } |
| }); |
| // gestion de la validation |
| valider.addListener(new ButtonListenerAdapter() { |
| // lors du clic |
| @Override |
| public void onClick(Button button, EventObject e) { |
| // on vide les mots clés en cours |
| motsClesEnCours = ""; |
| // pour chaque noeud à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // on éxécute une fonction |
| @Override |
| public boolean execute(Node node) { |
| // on récupère le mot clé associé au noeud et |
| // ses infos |
| TreeNode tn = getArbreMotsCles().getNodeById( |
| node.getId()); |
| String[] usObject = (String[]) tn |
| .getUserObject(); |
| /*getIMediateur().mettreAjourMotsClesId( |
| usObject[0], usObject[1]);*/ |
| if (tn.getUI().isChecked()) { |
| // et les concatène à la string des mots |
| // clés en cours |
| motsClesEnCours += usObject[1] + ","; |
| } |
| return true; |
| } |
| }); |
| // enfin on notifie le médiateur et on lui passe l'arbre et la |
| // liste des mots clés ainsi obtenue |
| surClicValider(motsClesEnCours, arbreMotsCles.getTree()); |
| } |
| }); |
| annuler.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| hide(); |
| } |
| }); |
| renommerTag.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| TreeNode noeudRenommage; |
| if(noeuds.length > 0) { |
| noeudRenommage = noeuds[noeuds.length - 1]; |
| } else { |
| noeudRenommage = arbreMotsCles.getRootNode(); |
| } |
| renommerNoeud(noeudRenommage); |
| } |
| }); |
| ajouterTag.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| TreeNode noeudAjout; |
| if(noeuds.length > 0) { |
| noeudAjout = noeuds[noeuds.length - 1]; |
| } else { |
| noeudAjout = arbreMotsCles.getRootNode(); |
| } |
| ajouterNoeud(noeudAjout); |
| } |
| }); |
| supprimerTag.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| for (int i = 0; i < noeuds.length; i++) { |
| supprimerNoeud(noeuds[i]); |
| } |
| } |
| }); |
| } |
| /** |
| * Envoie une demande au médiateur pour obtenir l'arbre des mots clés |
| */ |
| public void obtenirArbreMotsCles() { |
| demanderArbreMotsCles(this); |
| } |
| /** |
| * Supprime un noeud de l'arbre |
| * |
| * @param n |
| * le noeud à supprimer |
| */ |
| public void supprimerNoeud(TreeNode n) { |
| // si ça n'est pas la racine (qu'on ne peut pas supprimer) |
| if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) { |
| if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) { |
| // on détache le noeud et on le détruit |
| n.getParentNode().removeChild(n); |
| n.destroy(); |
| // puis on en notifie le médiateur en lui passant le noeud supprimé |
| // et l'arbre |
| surSuppressionMotCle(n, arbreMotsCles.getTree()); |
| } |
| } else { |
| // si l'utilisateur tente de supprimer la racine, on l'avertit de |
| // son erreur |
| Window.alert("Impossible de supprimer la racine de l'arbre"); |
| } |
| } |
| /** |
| * Ajoute un noeud dans l'arbre au parent donné |
| * |
| * @param parent |
| * le futur parent du noeud à ajouter |
| */ |
| public void ajouterNoeud(TreeNode parent) { |
| // 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); |
| } |
| /** |
| * Renomme le noeud passé en paramètre |
| */ |
| public void renommerNoeud(TreeNode n) { |
| // TODO Auto-generated method stub |
| te.startEdit(n); |
| } |
| /** |
| * Coche le noeud s'il est décoché, le décoche sinon |
| * |
| * @param node |
| */ |
| public void gererClicNoeud(TreeNode node) { |
| if (node.getUI().isChecked()) { |
| node.getUI().toggleCheck(false); |
| } else { |
| node.getUI().toggleCheck(true); |
| } |
| } |
| /** |
| * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots |
| * clés à cocher |
| * |
| * @param motsClesIds |
| * un tableau contenant les identifiants des mots clés à cocher |
| */ |
| public void cocherMotsCles(final String[] motsClesIds) { |
| if (getArbreMotsCles() != null |
| && getArbreMotsCles().getRootNode() != null) { |
| // à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // pour chaque noeud |
| @Override |
| public boolean execute(Node node) { |
| 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); |
| getArbreMotsCles().getNodeById(nodeId).ensureVisible(); |
| return true; |
| } |
| } |
| // et on passe au suivant |
| return true; |
| } |
| }); |
| } |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données pour l'objet |
| * @param repandreRafraichissement |
| * booleen qui dit si on doit répandre l'évenement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| if(nouvelleDonnees instanceof Tree) { |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| // on prend sa racine et on l'attache à l'arbre des mots clés |
| Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!arbreCharge) { |
| // on signale que oui |
| arbreCharge = true; |
| } |
| } |
| // Si on reçoit un tableau de String (cas ou l'on séléectionne une |
| // nouvelle image) |
| if (nouvelleDonnees instanceof String[]) { |
| // le tableau de String contient les id des mots clés associés à |
| // l'image |
| // on coche les mots clés contenu dans le tableau |
| tableauMotsClesEnCours = (String[]) nouvelleDonnees; |
| if(this.isVisible()) { |
| cocherMotsCles(tableauMotsClesEnCours); |
| } else { |
| addListener(new WindowListenerAdapter() { |
| @Override |
| public void onShow(Component component) { |
| cocherMotsCles(tableauMotsClesEnCours); |
| } |
| }); |
| } |
| } |
| } |
| 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); |
| } |
| } |
| } |
| } |
| public void activerBoutonValider(boolean activer) { |
| valider.setVisible(activer); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/GalerieImageVue.java |
|---|
| New file |
| 0,0 → 1,575 |
| 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.ContainerListenerAdapter; |
| 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) |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| 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 |
| */ |
| @Override |
| 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'>{indication_transmission}{indication_liaison}<img class='miniature_galerie' src='{url_image_M}' width='{taille_x_s} px' height='{taille_y_s} px' title='{infobulle}' /></div>", |
| "<span class='info_image'>{nom_obs_associees_formatees}</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") { |
| @Override |
| 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]); |
| String nomObs = data.getProperty("obs_associees"); |
| String htmltransmis = ""; |
| String htmllie = ""; |
| boolean associee = estAssocieeTransmise(nomObs)[0]; |
| boolean transmise = estAssocieeTransmise(nomObs)[1]; |
| String nomFormate = getNomsObservationsFormatees(nomObs); |
| if(associee) { |
| htmllie = "<img class='picto_haut_droite' src='chain.png' />"; |
| } |
| if(transmise) { |
| htmltransmis = "<img class='picto_haut_gauche' src='tela.png' />"; |
| } |
| data.setProperty("infobulle", nomFormate); |
| data.setProperty("indication_transmission", htmltransmis); |
| data.setProperty("indication_liaison", htmllie); |
| data.setProperty("nom_obs_associees_formatees", nomFormate); |
| } |
| }; |
| 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 defObsAssociees = new StringFieldDef("obs_associees"); |
| FieldDef[] defTab = { defNumImage, defNomImage, defDatImage, defLieImage, |
| defAppImage, defUrlImageS, defUrlImageM, defUrlImage,defTailleX,defTailleY, defObsAssociees}; |
| 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) |
| { |
| @Override |
| 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 ; |
| } |
| @Override |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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 != null && videPanel.isVisible()) { |
| videPanel.setVisible(false) ; |
| } |
| if(dView != null) { |
| 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 != null && !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); |
| } |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| iMediateur.changerNumeroPage(pageCourante) ; |
| } |
| @Override |
| 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() { |
| @Override |
| public void onAfterLayout(Container c) { |
| ExtElement uploadS = Ext.get("lienUploadSimple"); |
| uploadS.removeAllListeners(); |
| uploadS.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| getIMediateur().uploaderImages(false); |
| } |
| }) ; |
| ExtElement uploadM = Ext.get("lienUploadMultiple"); |
| uploadM.removeAllListeners(); |
| uploadM.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| getIMediateur().uploaderImages(true); |
| } |
| }); |
| } |
| }); |
| } |
| private String getNomsObservationsFormatees(String nomObs) { |
| String htmlInfobulle = ""; |
| String[][] obs = getObservationsAssociees(nomObs); |
| for(int i = 0; i < obs.length; i++) { |
| if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) { |
| htmlInfobulle += ", "+obs[i][1]; |
| } |
| } |
| htmlInfobulle = htmlInfobulle.replaceFirst(", ", ""); |
| return htmlInfobulle; |
| } |
| private String[][] getObservationsAssociees(String nomObs) { |
| if(nomObs.trim().equals("")) { |
| return new String[0][0]; |
| } |
| String[] obsTab = nomObs.split(";;"); |
| String[][] obsAnalysees = new String[obsTab.length][3]; |
| for(int i = 0; i < obsTab.length; i++) { |
| obsAnalysees[i] = obsTab[i].split("#"); |
| } |
| return obsAnalysees; |
| } |
| private boolean[] estAssocieeTransmise(String nomObs) { |
| String[][] obs = getObservationsAssociees(nomObs); |
| boolean[] associeesTranmises = {false, false}; |
| if(obs.length > 0) { |
| associeesTranmises[0] = true; |
| } |
| for(int i = 0; i < obs.length; i++) { |
| if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) { |
| associeesTranmises[1] = true; |
| } |
| } |
| return associeesTranmises; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/ImageMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,96 |
| 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.HTML; |
| import com.gwtext.client.widgets.Panel; |
| /** |
| * 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 ImageMotsClesVue extends Panel implements Rafraichissable { |
| /** |
| * Une string permettant connaitre les mots clés cochés en cours séparés par |
| * des virgules |
| */ |
| private String motsClesEnCours = ""; |
| private String[] tableauMotsClesEnCours = new String[0]; |
| /** |
| * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre |
| * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu |
| * du conteneur n'ai été effectué) |
| */ |
| private String[] motsClesEnAttente = new String[0]; |
| private HTML motsClesAffiches = new HTML(); |
| /** |
| * Constructeur sans paramètre (privé car interdit d'utilisation) |
| */ |
| @SuppressWarnings("unused") |
| private ImageMotsClesVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ImageMotsClesVue(ImageMediateur im) { |
| // on crée le panel |
| super("Mots clés"); |
| this.setHeight("100%"); |
| this.add(motsClesAffiches); |
| motsClesAffiches.setHeight("100%"); |
| this.setBorder(false); |
| this.setBodyBorder(false); |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données pour l'objet |
| * @param repandreRafraichissement |
| * booleen qui dit si on doit répandre l'évenement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // Si on reçoit un tableau de String (cas ou l'on séléectionne une |
| // nouvelle image) |
| if (nouvelleDonnees instanceof String[]) { |
| // le tableau de String contient les id des mots clés associés à |
| // l'image |
| // on affiche les mots clés contenu dans le tableau |
| tableauMotsClesEnCours = (String[]) nouvelleDonnees; |
| afficherMotsCles(tableauMotsClesEnCours); |
| } |
| } |
| private void afficherMotsCles(String[] tableauMotsClesEnCours) { |
| motsClesEnCours = "<ul class=\"liste_mots_cles\">"; |
| for (int i = 0; i < tableauMotsClesEnCours.length; i++) { |
| if(!tableauMotsClesEnCours[i].trim().isEmpty()) { |
| motsClesEnCours += "<li>"+tableauMotsClesEnCours[i]+"</li>"; |
| } |
| } |
| motsClesEnCours += "</ul>"; |
| motsClesAffiches.setHTML(motsClesEnCours); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/MenuIdVue.java |
|---|
| New file |
| 0,0 → 1,85 |
| 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 |
| @Override |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/OptionsImages.java |
|---|
| New file |
| 0,0 → 1,211 |
| 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.Button; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| 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 OptionsImages { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour l'upload |
| */ |
| private MenuItem uploaderImage = null; |
| /** |
| * Item pour la suppression |
| */ |
| private ToolbarButton 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 mnFichiers = null ; |
| private Menu mnTampon = null ; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private OptionsImages() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public OptionsImages(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| mnFichiers = new Menu(); |
| uploadMultiple = new Item("Plusieurs dossiers ou fichiers à la fois"); |
| uploadSimple = new Item("Un fichier à la la fois"); |
| mnFichiers.addItem(uploadMultiple); |
| mnFichiers.addItem(uploadSimple); |
| // on construit le menu |
| uploaderImage = new MenuItem("Ajouter des images", mnFichiers); |
| supprimerImage = new ToolbarButton("Supprimer"); |
| ajouterImageSelection = new Item( |
| "Ajouter les images sélectionnées au tampon"); |
| viderSelection = new Item("vider le contenu du tampon"); |
| afficherSelection = new Item("Supprimer le contenu du tampon"); |
| mnTampon = new Menu(); |
| mnTampon.addItem(ajouterImageSelection); |
| mnTampon.addItem(viderSelection); |
| mnTampon.addItem(afficherSelection); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| mnTampon.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // 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 |
| mnTampon.hide(); |
| } |
| @Override |
| public void onShow(Menu menu) { |
| if(getIMediateur().getCompteSelection() != 0) { |
| afficherSelection.enable(); |
| viderSelection.enable(); |
| } |
| else { |
| afficherSelection.disable(); |
| viderSelection.disable(); |
| } |
| } |
| }); |
| mnTampon.setTitle("Permet de sélectionner et d'afficher des images présentes sur plusieurs pages"); |
| // si c'est la suppression |
| supprimerImage.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| // on notifie le médiateur |
| getIMediateur().supprimerImages(); |
| } |
| }); |
| supprimerImage.setTitle("Supprimer les images sélectionnées"); |
| mnFichiers.addListener(new MenuListenerAdapter() { |
| @Override |
| 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); |
| } |
| } |
| }); |
| mnFichiers.setTitle("Ajouter des images en les selectionnant une par une ou bien un dossier à la fois"); |
| } |
| public Menu getMenuImage() { |
| return mnFichiers; |
| } |
| public Menu getMenuTampon() { |
| return mnTampon; |
| } |
| public ToolbarButton getBoutonSuppression() { |
| return supprimerImage; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/ListeImageVue.java |
|---|
| New file |
| 0,0 → 1,745 |
| 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 transmisImage; |
| /** |
| * 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; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig obsAssociees; |
| /** |
| * 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() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String ImgNum = record.getAsString("num_image"); |
| return "<div class=\"centered-list\">" + ImgNum |
| + "</div>"; |
| } |
| }); |
| transmisImage = new ColumnConfig(" ", "obs_associees", 10, true, new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String nomObs = record.getAsString("obs_associees"); |
| if(nomObs == null) { |
| return ""; |
| } |
| boolean transmise = estAssocieeTransmise(nomObs)[1]; |
| if(transmise) |
| { |
| return "<img src=\"tela.png\"/></img>" ; |
| } |
| else |
| { |
| return "" ; |
| } |
| } |
| }); |
| datImage = new ColumnConfig("Date", "dat_image", 80, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| 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() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| 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() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| 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() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| // 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() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| 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 original", "nom_original", 120, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String imgNomOr = record.getAsString("nom_original"); |
| if (imgNomOr == null) { |
| imgNomOr = " "; |
| } |
| return "<div class=\"centered-list\">" + imgNomOr |
| + "</div>"; |
| } |
| }); |
| obsAssociees = new ColumnConfig("Nom associé", "obs_associees", 80, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String nomObs = record.getAsString("obs_associees"); |
| if(nomObs == null) { |
| return ""; |
| } |
| String nomFormate = getNomsObservationsFormatees(nomObs); |
| return "<div class=\"centered-list\">" + nomFormate |
| + "</div>"; |
| } |
| }); |
| // on associe le modèle de colonnes |
| ColumnConfig[] cm = { numImage, transmisImage, urlImage, obsAssociees, datImage, lieImage, appImage, |
| noteImage,nomImage} ; |
| 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 defTransmisImage = new IntegerFieldDef("obs_associees"); |
| 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 defObsAssociees = new StringFieldDef("obs_associees"); |
| FieldDef[] defTab = { defNumImage,defTransmisImage, defNomImage, defDatImage, defLieImage, |
| defAppImage, defUrlImageS, defUrlImageM, defUrlImage, |
| defNoteImage, defTailleX, defTailleY, defObsAssociees}; |
| 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() { |
| @Override |
| 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é |
| @Override |
| public void onRender(Component component) { |
| if (!isEstInstancie()) { |
| setEstInstancie(true); |
| setDragDropText("Glissez les images sur la liste d'observation pour les lier") ; |
| getIMediateur().synchroniserSelection("galerie"); |
| } |
| } |
| @Override |
| public void onShow(Component component) { |
| } |
| }); |
| this.addGridRowListener(new GridRowListener() { |
| // gestion du clic sur une ligne |
| @Override |
| public void onRowClick(GridPanel grid, int rowIndex, EventObject e) { |
| // on notifie le médiateur et on lui passe le numéro de ligne |
| getIMediateur().clicListeImage(rowIndex); |
| } |
| // gestion du clic droit |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| 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) |
| { |
| @Override |
| 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 ; |
| } |
| } |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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); |
| } |
| } |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| iMediateur.changerNumeroPage(pageCourante) ; |
| } |
| @Override |
| 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 String getNomsObservationsFormatees(String nomObs) { |
| String htmlInfobulle = ""; |
| String[][] obs = getObservationsAssociees(nomObs); |
| for(int i = 0; i < obs.length; i++) { |
| if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) { |
| htmlInfobulle += ", "+obs[i][1]; |
| } |
| } |
| htmlInfobulle = htmlInfobulle.replaceFirst(", ", ""); |
| return htmlInfobulle; |
| } |
| private String[][] getObservationsAssociees(String nomObs) { |
| if(nomObs.trim().equals("")) { |
| return new String[0][0]; |
| } |
| String[] obsTab = nomObs.split(";;"); |
| String[][] obsAnalysees = new String[obsTab.length][3]; |
| for(int i = 0; i < obsTab.length; i++) { |
| obsAnalysees[i] = obsTab[i].split("#"); |
| } |
| return obsAnalysees; |
| } |
| private boolean[] estAssocieeTransmise(String nomObs) { |
| String[][] obs = getObservationsAssociees(nomObs); |
| boolean[] associeesTranmises = {false, false}; |
| if(obs.length > 0) { |
| associeesTranmises[0] = true; |
| } |
| for(int i = 0; i < obs.length; i++) { |
| if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) { |
| associeesTranmises[1] = true; |
| } |
| } |
| return associeesTranmises; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/image/MenuLiaisonVue.java |
|---|
| New file |
| 0,0 → 1,149 |
| 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 lier la selection d'images aux observations selectionnées |
| */ |
| private Item lierSelectionTampon = 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; |
| lierSelection = new Item("Lier les images selectionnées à la sélection d'observation"); |
| lierSelectionTampon = new Item("Lier le tampon à la sélection d'observation"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(lierSelection); |
| addItem(lierSelectionTampon); |
| addItem(afficherSelection); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| public MenuLiaisonVue(ImageMediateur im, boolean liaison) { |
| iMediateur = im; |
| lierSelection = new Item("Lier les images selectionnées à la sélection d'observation"); |
| lierSelectionTampon = new Item("Lier le tampon à la sélection d'observation"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(lierSelection); |
| addItem(lierSelectionTampon); |
| addItem(afficherSelection); |
| iMediateur = im; |
| 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 |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(lierSelection)) { |
| // on notifie le médiateur |
| getIMediateur().LierObservations(); |
| } |
| // si c'est la suppression |
| if (item.equals(lierSelectionTampon)) { |
| // 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java |
|---|
| New file |
| 0,0 → 1,213 |
| package org.tela_botanica.client.vues; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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.Panel; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.layout.HorizontalLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| 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 com.gwtext.client.widgets.Button annuler = null; |
| private boolean selectionUtilisateur =false; |
| public String utilisateur = null; |
| public String idUtilisateur = null; |
| 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("Choisir un utilisateur") ; |
| this.cMediateur = cMed; |
| listeUtil=new ComboBox("Utilisateurs","courriel",280); |
| this.setLayout(new RowLayout()); |
| final String resultTplUtil = "<div class=\"search-item-utilisateur\">{courriel}</div>"; |
| utilisateur = cMediateur.getUtilisateur().getLoginUtilisateurConsulte(); |
| idUtilisateur = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(); |
| listeUtil.setTpl(resultTplUtil); |
| listeUtil.setMode(ComboBox.REMOTE); |
| listeUtil.setItemSelector("div.search-item-utilisateur"); |
| listeUtil.setHideTrigger(true); |
| listeUtil.setDisplayField("courriel"); |
| listeUtil.setLoadingText("Recherche..."); |
| listeUtil.setValue(utilisateur); |
| OK= new com.gwtext.client.widgets.Button("OK"); |
| annuler = new com.gwtext.client.widgets.Button("Annuler"); |
| Panel boutonPanel = new Panel(); |
| boutonPanel.setLayout(new HorizontalLayout(0)); |
| add(listeUtil); |
| boutonPanel.add(OK); |
| boutonPanel.add(annuler); |
| add(boutonPanel); |
| this.setSize(300, 75); |
| OK.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(com.gwtext.client.widgets.Button button, |
| EventObject e) { |
| if(valider()) { |
| cMediateur.changerIdentite(idUtilisateur,utilisateur); |
| close(); |
| } |
| } |
| }); |
| annuler.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(com.gwtext.client.widgets.Button button, |
| EventObject e) { |
| close(); |
| } |
| }); |
| listeUtil.addKeyPressListener(new EventCallback() { |
| @Override |
| 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 { |
| if(valider()) { |
| cMediateur.changerIdentite(idUtilisateur,utilisateur); |
| } |
| close(); |
| } |
| break; |
| default: |
| obtenirListeUtilisateur(); |
| break; |
| } |
| } |
| }); |
| listeUtil.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| utilisateur = record.getAsString("courriel"); |
| idUtilisateur = record.getAsString("id_utilisateur"); |
| listeUtil.setValue(utilisateur); |
| } |
| }); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof String[][]) { |
| Object[][] utilData = (Object[][])nouvelleDonnees ; |
| FieldDef defId = new StringFieldDef("id_utilisateur"); |
| FieldDef defCourriel = new StringFieldDef("courriel"); |
| FieldDef[] defTab = {defId,defCourriel}; |
| 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(); |
| } |
| } |
| private boolean valider() { |
| if(listeUtil.getValue() != null) { |
| return true; |
| } |
| return false; |
| } |
| public void obtenirListeUtilisateur() { |
| String valeur = listeUtil.getRawValue(); |
| cMediateur.obtenirListeUtilisateurs(valeur,this) ; |
| } |
| public void focusChampUtilisateur() { |
| listeUtil.focus(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-beche/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java:r290-316 |
| Added: svn:ignore |
| +.project |
| +tomcat |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,498 |
| 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 = ""; |
| private String[] tableauMotsClesEnCours = new String[0]; |
| /** |
| * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre |
| * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu |
| * du conteneur n'ai été effectué) |
| */ |
| private String[] motsClesEnAttente = new String[0]; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un |
| * noeud |
| */ |
| private boolean ajoutNoeud = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train de modifier un |
| * noeud |
| */ |
| private boolean modifNoeud = false; |
| /** |
| * Booléen d'instanciation du conteneur |
| */ |
| private boolean arbreCharge = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu |
| */ |
| private boolean motsCleInitialises; |
| /** |
| * 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() { |
| @Override |
| public void onExpandNode(TreeNode node) { |
| cocherMotsCles(tableauMotsClesEnCours); |
| } |
| // gestion du clic sur un noeud |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| gererClicNoeud(node); |
| } |
| // gestion du clic droit sur un noeud |
| @Override |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| getIMediateur().montrerContextMenuArbre(node, e, getTe()); |
| } |
| // gestion du double clic sur un noeud |
| @Override |
| 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 |
| @Override |
| 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 considère l'ajout achevé |
| ajoutNoeud = false; |
| // et on notifie le médiateur de l'ajout et on lui passe |
| // l'arbre |
| getIMediateur().ajouterMotCleDansArbre(nd, |
| getArbreMotsCles().getTree()); |
| } |
| // si c'est noeud déjà existant |
| else { |
| // et on considère la modification achevée |
| modifNoeud = false; |
| // on notifie le médiateur de la modification et on lui |
| // passe l'arbre |
| getIMediateur().modifierMotCleDansArbre(nd, |
| getArbreMotsCles().getTree()); |
| } |
| } |
| // gestion du déplacement d'un noeud |
| @Override |
| public void onMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| // on notifie le médiateur et on lui passe l'arbre |
| getIMediateur().deplacerMotCleDansArbre(node, |
| getArbreMotsCles().getTree()); |
| } |
| }); |
| // gestion de la validation |
| valider.addListener(new ButtonListenerAdapter() { |
| // lors du clic |
| @Override |
| public void onClick(Button button, EventObject e) { |
| // on vide les mots clés en cours |
| motsClesEnCours = ""; |
| // pour chaque noeud à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // on éxécute une fonction |
| @Override |
| public boolean execute(Node node) { |
| // on récupère le mot clé associé au noeud et |
| // ses infos |
| TreeNode tn = getArbreMotsCles().getNodeById( |
| node.getId()); |
| String[] usObject = (String[]) tn |
| .getUserObject(); |
| getIMediateur().mettreAjourMotsClesId( |
| usObject[0], usObject[1]); |
| if (tn.getUI().isChecked()) { |
| // et les concatène à la string des mots |
| // clés en cours |
| motsClesEnCours += usObject[1] + ","; |
| } |
| return true; |
| } |
| }); |
| // enfin on notifie le médiateur et on lui passe l'arbre et la |
| // liste des mots clés ainsi obtenue |
| getIMediateur().mettreAjourMotsCles(motsClesEnCours, |
| arbreMotsCles.getTree()); |
| } |
| }); |
| } |
| /** |
| * Envoie une demande au médiateur pour obtenir l'arbre des mots clés |
| */ |
| public void obtenirArbreMotsCles() { |
| getIMediateur().obtenirArbreMotsCles(this); |
| } |
| /** |
| * Supprime un noeud de l'arbre |
| * |
| * @param n |
| * le noeud à supprimer |
| */ |
| public void supprimerNoeud(TreeNode n) { |
| // si ça n'est pas la racine (qu'on ne peut pas supprimer) |
| if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) { |
| // on détache le noeud et on le détruit |
| n.getParentNode().removeChild(n); |
| n.destroy(); |
| // puis on en notifie le médiateur en lui passant le noeud supprimé |
| // et l'arbre |
| getIMediateur() |
| .supprimerMotCleDansArbre(n, arbreMotsCles.getTree()); |
| } else { |
| // si l'utilisateur tente de supprimer la racine, on l'avertit de |
| // son erreur |
| Window.alert("Impossible de supprimer la racine de l'arbre"); |
| } |
| } |
| /** |
| * Ajoute un noeud dans l'arbre au parent donné |
| * |
| * @param parent |
| * le futur parent du noeud à ajouter |
| */ |
| public void ajouterNoeud(TreeNode parent) { |
| // on met l'ajout du noeud à vrai |
| ajoutNoeud = true; |
| // on crée un nouveau noeud vide |
| TreeNode nd = new TreeNode(""); |
| nd.setCls("x-view-treenode-keyword"); |
| nd.setChecked(true); |
| // on associe un objet au noeud qui contient des infos |
| String[] usObject = new String[2]; |
| // l'objet contient le nom du noeud |
| usObject[0] = ""; |
| usObject[1] = genererIdMotCle(nd); |
| nd.setId(usObject[1]); |
| nd.setUserObject(usObject); |
| // l'identifiant d'un noeud c'est son hashcode |
| // l'objet associé au noeud contient aussi son identifiant |
| // on le concatène au parent et on étend ses enfants |
| parent.appendChild(nd); |
| parent.expand(); |
| // enfin on place le curseur et on fait apparaitre le champ d'édition |
| // pour que l'utilisateur nomme son mot clé |
| te.startEdit(nd); |
| } |
| /** |
| * Coche le noeud s'il est décoché, le décoche sinon |
| * |
| * @param node |
| */ |
| public void gererClicNoeud(TreeNode node) { |
| if (node.getUI().isChecked()) { |
| node.getUI().toggleCheck(false); |
| } else { |
| node.getUI().toggleCheck(true); |
| } |
| } |
| /** |
| * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots |
| * clés à cocher |
| * |
| * @param motsClesIds |
| * un tableau contenant les identifiants des mots clés à cocher |
| */ |
| public void cocherMotsCles(final String[] motsClesIds) { |
| if (getArbreMotsCles() != null |
| && getArbreMotsCles().getRootNode() != null) { |
| // à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // pour chaque noeud |
| @Override |
| 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 |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| if(nouvelleDonnees instanceof Tree) { |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| // on prend sa racine et on l'attache à l'arbre des mots clés |
| Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!arbreCharge) { |
| // on signale que oui |
| arbreCharge = true; |
| } |
| } |
| // Si on reçoit un tableau de String (cas ou l'on séléectionne une |
| // nouvelle image) |
| if (nouvelleDonnees instanceof String[]) { |
| // le tableau de String contient les id des mots clés associés à |
| // l'image |
| // on coche les mots clés contenu dans le tableau |
| tableauMotsClesEnCours = (String[]) nouvelleDonnees; |
| cocherMotsCles(tableauMotsClesEnCours); |
| } |
| } |
| 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); |
| } |
| } |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/vues/BarrePaginationVue.java |
|---|
| New file |
| 0,0 → 1,488 |
| 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() { |
| @Override |
| 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() { |
| @Override |
| 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() { |
| @Override |
| 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); |
| } |
| } |
| } |
| @Override |
| 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() { |
| @Override |
| 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() { |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/ListePaginable.java |
|---|
| New file |
| 0,0 → 1,15 |
| package org.tela_botanica.client.interfaces; |
| /** |
| * Toutes les classes qui affichent des listes paginables |
| * implémentent cette interface. |
| * @author david delon |
| * |
| */ |
| public interface ListePaginable { |
| public void changerTaillePage(int nouvelleTaillePage); |
| public void changerNumeroPage(int pageCourante); |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/Filtrable.java |
|---|
| New file |
| 0,0 → 1,48 |
| package org.tela_botanica.client.interfaces; |
| /** |
| * Les classes qui implémentent cette interface fonctionnent sous forme de |
| * filtres et doivent être capable de rendre compte de leur état (modifié ou |
| * non) et de renvoyer les valeurs de filtrage |
| * |
| * @author aurelien |
| * |
| */ |
| public interface Filtrable { |
| /** |
| * Renvoie un tableau contenant le nom du filtre et sa valeur |
| * |
| * @return un tableau contenant le nom du filtre (exemple : |
| * "ci_meta_mots_cle") et sa valeur |
| */ |
| public String[] renvoyerValeursAFiltrer(); |
| /** |
| * Renvoie le nom du filtre de manière lisible (exemple : Filtre pour les |
| * mots clés) |
| * |
| * @return le nom du filtre |
| */ |
| public String renvoyerNomFiltre(); |
| /** |
| * Renvoie l'état du filtre (modifié ou non) |
| * |
| * @return true si le filtre à été modifié depuis le dernier appel, false |
| * sinon |
| */ |
| public boolean renvoyerEtatFiltre(); |
| /** |
| * Rassemble les valeurs contenant dans le ou les champs du filtre, les |
| * vérifie, et si celles-ci on changées, appelle le médiateur |
| */ |
| public void valider(); |
| /** |
| * Vide le filtre en cours |
| */ |
| public void viderFiltre(); |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/iRetourUtilisateur.java |
|---|
| New file |
| 0,0 → 1,8 |
| package org.tela_botanica.client.interfaces; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| public interface iRetourUtilisateur { |
| public void onRetour(Utilisateur utilisateur); |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/FournisseurListe.java |
|---|
| New file |
| 0,0 → 1,17 |
| package org.tela_botanica.client.interfaces; |
| /** |
| * Toutes les classes qui recoivent des données de manières asynchrones ou imprévisible |
| * implémentent cette interface. |
| * Elle permet de faire transiter le rafraichissable jusqu'au DAO et d'appeler sa méthode rafraichir un fois |
| * les données reçues, tout celà en préservant bien la séparation des rôles car les classes qui font transiter |
| * le rafraichissable ne connaissent que cette interface et pas le reste de l'objet |
| * @author aurelien |
| * |
| */ |
| public interface FournisseurListe { |
| public void obtenirListeDonnees(final Rafraichissable r, String critere); |
| public void obtenirListeDonnees(Rafraichissable r, String referentiel, String critere); |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/iRetourObservation.java |
|---|
| New file |
| 0,0 → 1,8 |
| package org.tela_botanica.client.interfaces; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| public interface iRetourObservation { |
| public void onRetour(Observation observation); |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/iMediateur.java |
|---|
| New file |
| 0,0 → 1,10 |
| package org.tela_botanica.client.interfaces; |
| /* |
| * Interface Mediateur |
| * |
| */ |
| public interface iMediateur { |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/IRetourImage.java |
|---|
| New file |
| 0,0 → 1,9 |
| package org.tela_botanica.client.interfaces; |
| import org.tela_botanica.client.modeles.objets.ListeImageCarnet; |
| public interface IRetourImage { |
| public void onRetour(ListeImageCarnet listeImage); |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/IdVue.java |
|---|
| New file |
| 0,0 → 1,94 |
| package org.tela_botanica.client.interfaces; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| 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.event.KeyListener; |
| import com.gwtext.client.widgets.event.WindowListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| public class IdVue extends Window implements Rafraichissable { |
| private ImageMediateur iMediateur; |
| private TextField champId = null; |
| private Button ok = null; |
| public IdVue(ImageMediateur im) { |
| super("Identification"); |
| iMediateur = im; |
| champId = new TextField(); |
| ok = new Button("OK"); |
| add(champId); |
| add(ok); |
| setSize(156, 75); |
| setClosable(false); |
| setModal(true); |
| this.setCloseAction(HIDE); |
| ajouterListeners(); |
| } |
| private void ajouterListeners() { |
| // gestion du clic sur le bouton |
| ok.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| // gestion de la touche entrée |
| champId.addKeyListener(EventObject.ENTER, new KeyListener() { |
| @Override |
| public void onKey(int key, EventObject e) { |
| valider(); |
| } |
| }); |
| this.addListener(new WindowListenerAdapter() { |
| @Override |
| public void onClose(Panel panel) { |
| } |
| }); |
| } |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| protected void valider() { |
| String id = champId.getText(); |
| getIMediateur().setIdentifiant("" + id.hashCode()); |
| getIMediateur().changerUtilisateur(); |
| this.close(); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/VueListable.java |
|---|
| New file |
| 0,0 → 1,21 |
| package org.tela_botanica.client.interfaces; |
| /** |
| * Les classes qui implétement cette interface sont des classes qui affichent |
| * des éléments qui peuvent être identifiés de manière unique Cette interface |
| * facilite le travail du médiateur dans la mesure ou il peut obtenir les |
| * éléments selectionnés d'une vue sans se préoccuper de son type précis |
| * |
| * @author aurelien |
| * |
| */ |
| public interface VueListable { |
| /** |
| * Renvoie un tableau contenant les identifiants des élements selectionnés |
| * |
| * @return les id des éléments sélectionnés |
| */ |
| public String[] getIdSelectionnees(); |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/interfaces/Rafraichissable.java |
|---|
| New file |
| 0,0 → 1,29 |
| package org.tela_botanica.client.interfaces; |
| /** |
| * Toutes les classes qui recoivent des données de manières asynchrones ou |
| * imprévisible implémentent cette interface. Elle permet de faire transiter le |
| * rafraichissable jusqu'au DAO et d'appeler sa méthode rafraichir un fois les |
| * données reçues, tout celà en préservant bien la séparation des rôles car les |
| * classes qui font transiter le rafraichissable ne connaissent que cette |
| * interface et pas le reste de l'objet |
| * |
| * @author aurelien |
| * |
| */ |
| public interface Rafraichissable { |
| /** |
| * Méthode de mise à jour d'un objet |
| * |
| * @param nouvelleDonnees |
| * Un objet de n'importe quel type (programmation générique) qui |
| * contient les données de mise à jour |
| * @param repandreRaffraichissement |
| * indique si l'élement doit notifier d'autres éléments de sa |
| * mise à jour |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement); |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/CarnetEnLigneModele.java |
|---|
| New file |
| 0,0 → 1,62 |
| package org.tela_botanica.client; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ListeUtilisateurAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.UtilisateurAsynchroneDAO; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| /** |
| * Modele generique permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour |
| * Ne previent pas les vues. Est appelle par le mediateur qui traite le resultat. |
| */ |
| public class CarnetEnLigneModele { |
| /** |
| * booleen qui verifie l'unicite de l'instance |
| */ |
| private static boolean estInstancie = false ; |
| /** |
| * La configuration en cours |
| */ |
| private Configuration config = null; |
| /** |
| * Constructeur |
| */ |
| public static CarnetEnLigneModele Instance() |
| { |
| //TODO: voir si ca sert encore à quelque chose |
| if(!estInstancie) |
| { |
| estInstancie = true ; |
| return new CarnetEnLigneModele() ; |
| } |
| else |
| { |
| return null ; |
| } |
| } |
| public void deconnecterUtilisateur(Rafraichissable r, String user) { |
| new UtilisateurAsynchroneDAO(this).deconnecterUtilisateur(r,user ); |
| } |
| public void connecterUtilisateur(Rafraichissable r, String login , String password) { |
| new UtilisateurAsynchroneDAO(this).connecteUtilisateur(r,login, password ); |
| } |
| public void getEtatUtilisateur(Rafraichissable r) { |
| new UtilisateurAsynchroneDAO(this).getEtatUtilisateur(r); |
| } |
| public void obtenirListeUtilisateur(Rafraichissable r,String rech, String identifiant) { |
| ListeUtilisateurAsynchroneDAO liDAO = new ListeUtilisateurAsynchroneDAO(this); |
| liDAO.obtenirListeUtilisateur(r,rech,identifiant); |
| } |
| public void accepterLicenceUtilisateur(String identifiantUtilisateur) { |
| UtilisateurAsynchroneDAO utilisateurDao = new UtilisateurAsynchroneDAO(this); |
| utilisateurDao.accepterLicence(identifiantUtilisateur); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/cel2.java |
|---|
| New file |
| 0,0 → 1,87 |
| package org.tela_botanica.client; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import com.google.gwt.ajaxloader.client.AjaxLoader; |
| import com.google.gwt.ajaxloader.client.AjaxLoader.AjaxLoaderOptions; |
| import com.google.gwt.core.client.EntryPoint; |
| import com.google.gwt.user.client.Timer; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.widgets.Viewport; |
| /** |
| * Entry point classes define <code>onModuleLoad()</code>. |
| */ |
| public class cel2 implements EntryPoint { |
| /** |
| * This is the entry point method. |
| */ |
| @Override |
| public void onModuleLoad() { |
| // A décommenter + compiler en detailed dans le cas d'une erreur |
| // survernant uniquement sur le serveur |
| /*GWT.setUncaughtExceptionHandler(new UncaughtExceptionHandler() { |
| @Override |
| public void onUncaughtException(Throwable e) { |
| Window.alert("uncaught: " + e.getMessage()); |
| String s = buildStackTrace(e, "RuntimeException:\n"); |
| Window.alert(s); |
| e.printStackTrace(); |
| } |
| });*/ |
| Configuration config = new Configuration(); |
| AjaxLoaderOptions optAj = AjaxLoaderOptions.newInstance(); |
| optAj.setOtherParms("key="+Configuration.getCleGoogleMaps()+"&sensor=false"); |
| Runnable callback = new Runnable() { |
| public void run() { |
| initialiserCel(); |
| }; |
| }; |
| AjaxLoader.loadApi("maps", "3", callback, optAj); |
| } |
| private void initialiserCel() { |
| CarnetEnLigneMediateur carnetEnLigneMediateur= CarnetEnLigneMediateur.Instance(); |
| new Viewport(carnetEnLigneMediateur.getPanneauPrincipalCarnetEnLigne()) ; |
| carnetEnLigneMediateur.getEtatUtilisateur() ; |
| Timer t = new Timer() { |
| @Override |
| public void run() { |
| Ext.get("loading").hide(); |
| } |
| }; |
| t.schedule(3000); |
| } |
| private String buildStackTrace(Throwable t, String log) { |
| if (t != null) { |
| log += t.getClass().toString(); |
| log += t.getMessage(); |
| // |
| StackTraceElement[] stackTrace = t.getStackTrace(); |
| if (stackTrace != null) { |
| StringBuffer trace = new StringBuffer(); |
| for (int i = 0; i < stackTrace.length; i++) { |
| trace.append(stackTrace[i].getClassName() + "." + stackTrace[i].getMethodName() + "(" |
| + stackTrace[i].getFileName() + ":" + stackTrace[i].getLineNumber()); |
| } |
| log += trace.toString(); |
| } |
| // |
| Throwable cause = t.getCause(); |
| if (cause != null && cause != t) { |
| log += buildStackTrace(cause, "CausedBy:\n"); |
| } |
| } |
| return log; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/TransmissionObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,65 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| public class TransmissionObservationAsynchroneDAO { |
| ObservationModele om = null ; |
| public TransmissionObservationAsynchroneDAO(ObservationModele observationModele) { |
| om = observationModele ; |
| } |
| public void transmettreObservations(final Rafraichissable r, String identifiant, String idsObs, boolean publier) { |
| // on envoie le get asynchrone |
| String post = "&transmission="; |
| if(publier) { |
| post += "1"; |
| } |
| else |
| { |
| post += "0" ; |
| } |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl() |
| +"/InventoryTransmit/"+Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+"/"+idsObs) ; |
| try { |
| rb.sendRequest(post, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| r.rafraichir("OK",true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeEntiteGeographiqueObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,122 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO la liste des communes. |
| * @author David Delon |
| * |
| */ |
| public class ListeEntiteGeographiqueObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeEntiteGeographiqueObservationAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele = obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres. |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param critere un string contenant le terme a rechercher |
| */ |
| public final void obtenirListeEntitesGeographiques(final Rafraichissable r, final String utilisateur) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/InventoryLocationList/" + utilisateur); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(final Request request, final Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| final ListeEntiteGeographiqueObservation listeEntiteGeographiqueObservation; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = null; |
| // si c'est un tableau |
| if ((reponse = responseValue.isArray()) != null) { |
| JSONObject entites; |
| final int taillemax = reponse.size(); |
| listeEntiteGeographiqueObservation = new ListeEntiteGeographiqueObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((entites = reponse.get(i).isObject()) != null) { |
| String idZoneGeo = Util.convertirChaineZoneGeoVersDepartement(Util.getValeurJsonOuVide(entites, "ce_zone_geo")); |
| String zoneGeo = Util.getValeurJsonOuVide(entites, "zone_geo"); |
| String lieuDit = Util.getValeurJsonOuVide(entites, "lieudit"); |
| String station = Util.getValeurJsonOuVide(entites, "station"); |
| EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(idZoneGeo, zoneGeo, lieuDit, station); |
| listeEntiteGeographiqueObservation.put(ent); |
| } |
| } |
| } else { |
| listeEntiteGeographiqueObservation = new ListeEntiteGeographiqueObservation(0); |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| r.rafraichir(listeEntiteGeographiqueObservation, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ImageGeneriqueVueAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,95 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO d'accès a une observation |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageGeneriqueVueAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele observationModele = null; |
| public ImageGeneriqueVueAsynchroneDAO(ObservationModele obs) { |
| observationModele = obs; |
| } |
| /** |
| * Recherche Image associee a un nom |
| * @param r |
| * @param identifiant |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirURLImage(final Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) { |
| String referentielDefaut = Configuration.getReferentielsDispos().get(0).getCode(); |
| referentielTaxo = (referentielTaxo != null && !referentielTaxo.isEmpty()) ? referentielTaxo : referentielDefaut; |
| // on envoie le get asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() |
| +"/NameImage/"+referentielTaxo+"/"+numeroNomenclaturalSaisiObservation) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| try { |
| JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse; |
| String urlImage=null; |
| String urlImageMax=null; |
| if ((reponse = responseValue.isArray()) != null) { |
| // Url Image |
| urlImage= ((JSONString)reponse.get(0)).stringValue(); |
| urlImageMax= ((JSONString)reponse.get(1)).stringValue(); |
| } |
| else { |
| urlImage=""; |
| urlImageMax=""; |
| } |
| r.rafraichir(new String[]{urlImage,urlImageMax},true); |
| } catch (Exception e) { |
| // TODO: handle exception |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ImageInformationRepartitionAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,89 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO d'accès a une observation |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageInformationRepartitionAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele observationModele = null; |
| public ImageInformationRepartitionAsynchroneDAO(ObservationModele obs) { |
| observationModele = obs; |
| } |
| /** |
| * Recherche Image repartition associee a un nom |
| * @param r |
| * @param identifiant |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirURLImage(final Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) { |
| String referentielDefaut = Configuration.getReferentielsDispos().get(0).getCode(); |
| referentielTaxo = (referentielTaxo != null && !referentielTaxo.isEmpty()) ? referentielTaxo : referentielDefaut; |
| // on envoie le get asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() |
| +"/NameMap/"+referentielTaxo+"/"+numeroNomenclaturalSaisiObservation) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse; |
| String urlImage=null; |
| if ((reponse = responseValue.isArray()) != null) { |
| // Url Image |
| urlImage= ((JSONString)reponse.get(0)).stringValue(); |
| } |
| else { |
| urlImage=""; |
| } |
| r.rafraichir(urlImage,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/UtilisateurAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,183 |
| package org.tela_botanica.client.modeles.dao; |
| /** |
| * Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour |
| * |
| */ |
| import org.tela_botanica.client.CarnetEnLigneModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.Window; |
| public class UtilisateurAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| private CarnetEnLigneModele carnetEnLigneModele = null ; |
| /** |
| * Constructeur |
| */ |
| public UtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) { |
| this.carnetEnLigneModele=carnetEnLigneModele; |
| } |
| /** |
| * Methode de classe d'appel du service gestion identification |
| * @param baseURL : URL du service |
| * @param retour : methode appelle en retour d'appel |
| */ |
| public void getEtatUtilisateur(final Rafraichissable r) { |
| // Recherche identifiant utilisateur identifie |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() + "/User/") ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(response.getText().isEmpty()) { |
| Window.alert("Impossible de contacter le serveur, veuillez vérifier la configuration du cel ou contacter un administrateur"); |
| } else { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONObject objetJsonUtilisateur; |
| if ((objetJsonUtilisateur = jsonValue.isObject()) != null) { |
| Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur); |
| r.rafraichir(utilisateur,true); |
| } |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void deconnecterUtilisateur(final Rafraichissable r, String user) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()+ "/User/" + user) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONObject objetJsonUtilisateur; |
| if ((objetJsonUtilisateur = jsonValue.isObject()) != null) { |
| Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur); |
| r.rafraichir(utilisateur,true); |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void connecteUtilisateur (final Rafraichissable r, String login, String password) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() + "/User/" + login + "/" + password) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONObject objetJsonUtilisateur; |
| if ((objetJsonUtilisateur = jsonValue.isObject()) != null) { |
| Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur); |
| r.rafraichir(utilisateur,true); |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| e.printStackTrace() ; |
| } |
| } |
| public void accepterLicence(String identifiantUtilisateur) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl() + "/LicenceUtilisateur/"+identifiantUtilisateur) ; |
| try { |
| String postData = "licence=1"; |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| } |
| }) ; |
| } catch (RequestException e) { |
| e.printStackTrace() ; |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,108 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.user.client.Window; |
| /** |
| * DAO d'accès à la liaison entre mots clés et observations |
| * |
| * @author aurelien |
| * |
| */ |
| public class LiaisonMotsClesImageAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ImageModele iModele = null; |
| public LiaisonMotsClesImageAsynchroneDAO(ImageModele img) { |
| iModele = img; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param img |
| * le modèle à associer |
| */ |
| public void setiModele(ImageModele img) { |
| iModele = img; |
| } |
| /** |
| * Envoie requete au serveur pour modifier une observations |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void modifier(final Rafraichissable r, String utilisateur, String idImg, String idMC) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordImageLink/") ; |
| String postData = "ce_utilisateur="+utilisateur |
| +"&images="+idImg |
| +"&mots_cles="+URL.encodeComponent(""+idMC); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| Window.alert("Liaison aux mots clés effectuée"); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void supprimer(final Rafraichissable r, String utilisateur, String idImg, String idMC) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordImageLink/" + utilisateur + "/" +idImg+ "/" + URL.encodeComponent(""+idMC) + "/") ; |
| String postData = "&action=DELETE"; |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| Window.alert("Liaison aux mots clés supprimée"); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeUtilisateurAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,74 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.CarnetEnLigneModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| public class ListeUtilisateurAsynchroneDAO { |
| CarnetEnLigneModele cModele = null ; |
| public ListeUtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) { |
| cModele = carnetEnLigneModele ; |
| } |
| public final void obtenirListeUtilisateur(final Rafraichissable r,final String rech, final String utilisateur) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/InventoryUserList/" + utilisateur+"/"+rech); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(final Request request, final Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| String[][] util ; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = responseValue.isArray(); |
| if(reponse != null) { |
| util = new String[reponse.size()][2]; |
| for(int i = 0; i < reponse.size() ; i++) { |
| JSONObject item = reponse.get(i).isObject(); |
| util[i][0] = Util.getValeurJsonOuVide(item, "id_utilisateur"); |
| util[i][1] = Util.getValeurJsonOuVide(item, "courriel"); |
| } |
| } |
| else { |
| util = new String[0][2]; |
| } |
| r.rafraichir(util, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesObsAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,107 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| /** |
| * DAO d'accès à la liaison entre mots clés et observations |
| * |
| * @author aurelien |
| * |
| */ |
| public class LiaisonMotsClesObsAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele oModele = null; |
| public LiaisonMotsClesObsAsynchroneDAO(ObservationModele obs) { |
| oModele = obs; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param obs |
| * le modèle à associer |
| */ |
| public void setoModele(ObservationModele obs) { |
| oModele = obs; |
| } |
| /** |
| * Envoie requete au serveur pour modifier une observations |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void modifier(final Rafraichissable r, String utilisateur, String idObs, String idMC) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordObsLink/") ; |
| String postData = "ce_utilisateur="+utilisateur |
| +"&observations="+idObs |
| +"&mots_cles="+URL.encodeComponent(""+idMC); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| oModele.obtenirListeObservation(r); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void supprimer(final Rafraichissable r, String utilisateur, String idObs, String idMC) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordObsLink/" + utilisateur + "/" +idObs+ "/" + URL.encodeComponent(""+idMC) + "/") ; |
| String postData = "&action=DELETE"; |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| oModele.obtenirListeObservation(r); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/NomRetenuAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,69 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| public class NomRetenuAsynchroneDAO { |
| private ObservationModele oModele = null ; |
| public NomRetenuAsynchroneDAO(ObservationModele observationModele) { |
| oModele = observationModele ; |
| } |
| public void obtenirNomRetenu(final Rafraichissable r, final String anum) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, |
| Configuration.getServiceBaseUrl() |
| + "/name/"+anum); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONArray jsonArray; |
| if ((jsonArray = jsonValue.isArray()) != null) { |
| String aname = ((JSONString) jsonArray.get(0)).toString(); |
| // Nom |
| if (aname.compareTo("null")!=0) { |
| String[] numNom = {aname, anum } ; |
| r.rafraichir(numNom, false); |
| } |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ImageUploaderAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,165 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import com.gwtext.client.core.UrlParam; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.WindowListenerAdapter; |
| import com.gwtextux.client.widgets.upload.UploadDialog; |
| import com.gwtextux.client.widgets.upload.UploadDialogListenerAdapter; |
| /** |
| * DAO un peu particulier car il crée une fenetre d'upload différente suivant |
| * que le plugin Java est détecté ou non |
| * |
| * |
| */ |
| public class ImageUploaderAsynchroneDAO { |
| /** |
| * Modele associé au DAO |
| */ |
| private static ImageModele iModele; |
| public ImageUploaderAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Setteur pour le modele |
| * |
| * @param im |
| * le modèle à associer au DAO |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Crée un panel d'upload simple aux fonctions réduites mais utilisant |
| * uniquement javascript (pour les utilisateurs qui n'ont pas java) |
| */ |
| public static void appelerUploadSimple() { |
| UploadDialog up = new UploadDialog("Upload simple de fichiers"); |
| up.setUrl(Configuration.getServiceBaseUrl() + "/InventoryImage"); |
| UrlParam id = new UrlParam("ce_utilisateur",Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| UrlParam[] params = { id }; |
| up.setBaseParams(params); |
| up.setModal(true); |
| up.addListener(new UploadDialogListenerAdapter() { |
| @Override |
| public void onClose(Panel panel) { |
| iModele.setDernierePage(); |
| iModele.requeteTerminee(); |
| } |
| @Override |
| public void onUploadComplete(UploadDialog source) { |
| iModele.setDernierePage(); |
| iModele.requeteTerminee(); |
| } |
| }); |
| up.show(); |
| } |
| /** |
| * Crée une fenêtre contenant une applet java pour uploader plusieurs |
| * fichiers à la fois avec quelques fonctions avancées (nécessite le plugin |
| * java pour le navigateur) |
| */ |
| public static void appelerUploadMultiple() { |
| final Window nPan = new Window("Upload multiple"); |
| nPan.setWidth(640); |
| final String warning = "<p class=\"warning_upload\"> A la fin de l'envoi, veuillez fermer la fenêtre pour accéder aux images. </p>"; |
| final String applet = "<applet code=\"wjhk.jupload2.JUploadApplet\" name=\"JUpload\" archive=\"wjhk.jupload.jar\" alt=\"Le plugin java n'est pas installé\" mayscript=\"true\" height=\"350\" width=\"625\">"; |
| final String paramPostTarget = "<param name=\"postURL\" value=\"" |
| + Configuration.getServiceBaseUrl() |
| + "/InventoryImage/\">"; |
| final String paramUploadPolicy = "<param name=\"uploadPolicy\" value=\"PictureUploadPolicy\">"; |
| final String paramMaxChunkSize = "<param name=\"maxChunkSize\" value=\"0\">"; |
| final String paramMaxFileSize = "<param name=\"maxFileSize\" value=\""+Configuration.getTailleMaxUpload()+"\">"; |
| final String paramTransmitMetaData = "<param name=\"pictureTransmitMetadata\" value=\"true\">"; |
| final String paramFilesPerRequest = "<param name=\"nbFilesPerRequest\" value=\"1\">"; |
| final String paramAllowedExtensions = "<param name=\"allowedFileExtensions\" value=\"jpg/jpeg/\">"; |
| final String paramUploadSuccess = "<param name=\"stringUploadSuccess\" value=\"OK\">"; |
| final String paramShowLogWindow = "<param name=\"showLogWindow\" value=\"false\">"; |
| final String paramFormdata = "<param name=\"formData\" value=\"postid\">"; |
| final String finApplet = "</applet>"; |
| final String appelApplet = applet + paramPostTarget + paramUploadPolicy |
| + paramMaxChunkSize + paramMaxFileSize + paramTransmitMetaData |
| + paramFilesPerRequest + paramAllowedExtensions |
| + paramUploadSuccess + paramShowLogWindow + paramFormdata |
| + finApplet; |
| final String htmlForm = "<form method=\"post\" name=\"postid\">" |
| + "<input type=\"hidden\" name=\"ce_utilisateur\" value=\"" |
| + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "\">" + "</form>"; |
| nPan.setHtml(warning + appelApplet + htmlForm); |
| nPan.setModal(true); |
| nPan.addListener(new WindowListenerAdapter() { |
| @Override |
| public void onClose(Panel panel) { |
| iModele.setDernierePage(); |
| iModele.requeteTerminee(); |
| } |
| }); |
| nPan.show(); |
| } |
| /** |
| * Fonction javascript native qui détecte la présence du plugin java pour le |
| * navigateur et appelle la méthode d'upload adaptée (appelerUploadSimple ou |
| * appelerUploadMultiple) |
| */ |
| public static native void choisirMethodeUpload() /*-{ |
| var agt=navigator.userAgent.toLowerCase(); |
| var ie = (agt.indexOf("msie") != -1); |
| var ns = (navigator.appName.indexOf("Netscape") != -1); |
| var win = ((agt.indexOf("win")!=-1) || (agt.indexOf("32bit")!=-1)); |
| var mac = (agt.indexOf("mac")!=-1); |
| function detectIE(ClassID,name) { result = false; document.write('<SCRIPT LANGUAGE=VBScript>\n on error resume next \n result = IsObject(CreateObject("' + ClassID + '"))</SCRIPT>\n'); if (result) return name+','; else return ''; } |
| function detectNS(ClassID,name) { n = ""; if (nse.indexOf(ClassID) != -1) if (navigator.mimeTypes[ClassID].enabledPlugin != null) n = name+","; return n; } |
| if (ie && win) { pluginlist = detectIE("Adobe.SVGCtl","SVG Viewer") + detectIE("SWCtl.SWCtl.1","Shockwave Director") + detectIE("ShockwaveFlash.ShockwaveFlash.1","Shockwave Flash") + detectIE("rmocx.RealPlayer G2 Control.1","RealPlayer") + detectIE("QuickTimeCheckObject.QuickTimeCheck.1","QuickTime") + detectIE("MediaPlayer.MediaPlayer.1","Windows Media Player") + detectIE("PDF.PdfCtrl.5","Acrobat Reader"); } |
| if (ns || !win) { |
| nse = ""; for (var i=0;i<navigator.mimeTypes.length;i++) nse += navigator.mimeTypes[i].type.toLowerCase(); |
| pluginlist = detectNS("image/svg-xml","SVG Viewer") + detectNS("application/x-director","Shockwave Director") + detectNS("application/x-shockwave-flash","Shockwave Flash") + detectNS("audio/x-pn-realaudio-plugin","RealPlayer") + detectNS("video/quicktime","QuickTime") + detectNS("application/x-mplayer2","Windows Media Player") + detectNS("application/pdf","Acrobat Reader"); |
| } |
| pluginlist += navigator.javaEnabled() ? "Java," : ""; |
| if (pluginlist.length > 0) pluginlist = pluginlist.substring(0,pluginlist.length-1); |
| if(pluginlist.indexOf("Java")!=-1) |
| { |
| @org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO::appelerUploadMultiple()() ; |
| } |
| else |
| { |
| @org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO::appelerUploadSimple()() ; |
| } |
| }-*/; |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeReferentielPersoAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,103 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| public class ListeReferentielPersoAsynchroneDAO { |
| /** |
| * Cache |
| * |
| */ |
| private HashMap<String,ListeReferentielPerso> cache = new HashMap(); |
| private TypesReferentiels refDemande = null; |
| public ListeReferentielPersoAsynchroneDAO(ObservationModele obs) { |
| } |
| public void setRefDemande(TypesReferentiels refDemande) { |
| this.refDemande = refDemande; |
| } |
| public void obtenirListeDonnees(final Rafraichissable r, String utilisateur, final String critere) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + |
| "/SelfRefList/"+ |
| utilisateur+"/"+ |
| refDemande.toString()+ |
| "?start=0&limit=50&recherche="+URL.encode(critere)); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(final Request request, final Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| final ListeReferentielPerso referentielData; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = null; |
| // si c'est un tableau |
| if ((reponse = responseValue.isArray()) != null) { |
| JSONString elementsRef; |
| final int taillemax = reponse.size(); |
| referentielData = new ListeReferentielPerso(taillemax, refDemande); |
| for (int i = 0; i < taillemax; i++) { |
| if ((elementsRef = reponse.get(i).isString()) != null) { |
| String valeur = elementsRef.stringValue(); |
| referentielData.put(i+"", valeur); |
| } |
| } |
| } else { |
| referentielData = new ListeReferentielPerso(0, refDemande); |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| r.rafraichir(referentielData, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/InformationCommuneDAO.java |
|---|
| New file |
| 0,0 → 1,167 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.Window; |
| public class InformationCommuneDAO { |
| private final String NOM_SERVICE = "CoordSearch"; |
| private final String CODE_PAYS = "FR"; |
| Rafraichissable r = null; |
| public InformationCommuneDAO(Rafraichissable r) { |
| this.r = r; |
| } |
| public void obtenirCommunePlusProche(final Rafraichissable r, final double lng, |
| final double lat) { |
| String adresseAppel = Configuration.getServiceBaseUrl() + "/" |
| + NOM_SERVICE + "/" + URL.encode("" + lat) + "/" |
| + URL.encode("" + lng) + "/*/*/"; |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, adresseAppel); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| Window.alert(exception.getMessage()); |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| EntiteGeographiqueObservation infos; |
| String idLocalite = ""; |
| String nomCommune = ""; |
| if (response.getStatusCode() == Response.SC_BAD_REQUEST) { |
| Window.alert("Requete mal formée"); |
| } else { |
| if(response.getText().equals("")) { |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""+lat); |
| infos.setLon(""+lng); |
| r.rafraichir(infos, false); |
| } |
| final JSONValue responseValue = JSONParser |
| .parse(response.getText()); |
| if (responseValue.isObject() != null) { |
| JSONObject objectRetour = responseValue.isObject(); |
| if(objectRetour.get("nom").isString() != null) { |
| nomCommune = objectRetour.get("nom").isString().stringValue(); |
| } |
| if(objectRetour.get("code_insee").isString() != null) { |
| idLocalite = objectRetour.get("code_insee").isString().stringValue().substring(0, 2); |
| } |
| } |
| } |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""+lat); |
| infos.setLon(""+lng); |
| r.rafraichir(infos, false); |
| } |
| }); |
| } catch (RequestException e) { |
| Window.alert(e.getMessage()); |
| } |
| } |
| public void obtenirInfosCommune(final Rafraichissable r, |
| String valeurCommune, String codePostal) { |
| codePostal = codePostal.replaceAll("000null", "*"); |
| codePostal = codePostal.replaceAll("\"", ""); |
| valeurCommune = valeurCommune.split(" \\([0-9][0-9]\\)")[0]; |
| valeurCommune = valeurCommune.replaceAll("000null", "*"); |
| valeurCommune = valeurCommune.replaceAll("\"", ""); |
| String adresseAppel = Configuration.getServiceBaseUrl() + "/" |
| + NOM_SERVICE + "/*/*/" + URL.encode(valeurCommune) + "/" |
| + URL.encode(codePostal) + "/" |
| + URL.encode(CODE_PAYS); |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, adresseAppel); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| Window.alert(exception.getMessage()); |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getStatusCode() == Response.SC_BAD_REQUEST) { |
| r.rafraichir("Impossible de géolocaliser cette observation", false); |
| } else { |
| final JSONValue responseValue = JSONParser |
| .parse(response.getText()); |
| if (responseValue.isObject() != null) { |
| EntiteGeographiqueObservation infos; |
| Double lng = 0.0; |
| Double lat = 0.0; |
| JSONObject objectRetour = responseValue.isObject(); |
| String nomCommune = Util.getValeurJsonOuVide(objectRetour, "nom"); |
| String idLocalite = Util.getValeurJsonOuVide(objectRetour, "code_insee"); |
| lat = Util.jsonNonNull(objectRetour,"lat") ? objectRetour.get("lat").isNumber().doubleValue(): 0.0; |
| lng = Util.jsonNonNull(objectRetour,"lng") ? objectRetour.get("lng").isNumber().doubleValue(): 0.0; |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""+lat); |
| infos.setLon(""+lng); |
| r.rafraichir(infos, false); |
| } else { |
| EntiteGeographiqueObservation infos; |
| String idLocalite = ""; |
| String nomCommune = ""; |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""); |
| infos.setLon(""); |
| r.rafraichir(infos, false); |
| } |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| Window.alert(e.getMessage()); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeReferentielNomAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,158 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielNom; |
| import org.tela_botanica.client.modeles.objets.ReferentielNom; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO liste noms scientifiques // utilisation d'un cahce memoire pour eviter des requetes inutiles. |
| * @author David Delon |
| * |
| */ |
| public class ListeReferentielNomAsynchroneDAO implements FournisseurListe { |
| //TODO : limiter taille du cache ? (si pb performance) |
| /** |
| * Le modèle associé au DAO |
| */ |
| private ObservationModele observationModele = null ; |
| private String referentiel = null; |
| /** |
| * Cache |
| * |
| */ |
| private HashMap <String,ListeReferentielNom> cache = new HashMap(); |
| public ListeReferentielNomAsynchroneDAO(ObservationModele observationModele) |
| { |
| this.observationModele=observationModele; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param criteres un string contenant le terme a rechercher |
| */ |
| @Override |
| public void obtenirListeDonnees(final Rafraichissable r,final String referentiel, final String critere) |
| { |
| ListeReferentielNom referentielNomDataFromCache=null; |
| if(this.referentiel != referentiel) { |
| cache.clear(); |
| } |
| // En cache ? |
| if ((referentielNomDataFromCache=getFromCache(critere))!=null) { |
| r.rafraichir(referentielNomDataFromCache,true); |
| } |
| else { |
| // On vérifie si un genre et une espèce sont demandées |
| // et ajoute le / manuellement car sinon il devient urlencode |
| String[] criteres =critere.split("/"); |
| String urlParams = "/NameSearch/"+referentiel+"/"; |
| if(criteres.length > 1) { |
| String critere1 = criteres[0]; |
| String critere2 = criteres[1]; |
| urlParams += URL.encode(critere1)+"/"+URL.encode(critere2); |
| } else { |
| urlParams += URL.encode(critere); |
| } |
| this.referentiel = referentiel; |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()+urlParams); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| final ListeReferentielNom referentielNomData ; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse=null; |
| // si c'est un tableau |
| if ((reponse=responseValue.isArray()) != null) { |
| JSONArray noms; |
| final int taillemax = reponse.size(); |
| referentielNomData = new ListeReferentielNom(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((noms=reponse.get(i).isArray()) != null) { |
| String nom = ((JSONString) noms.get(0)).stringValue(); |
| String numeroNom = ((JSONString) noms.get(1)).stringValue(); |
| String statut= ((JSONString) noms.get(2)).stringValue(); |
| ReferentielNom nomScientifique = new ReferentielNom(nom, numeroNom, statut); |
| // FIXME : et si le numero de nom n'est pas unique ? (cas de multirefrentiel....) |
| referentielNomData.put(nomScientifique.getNumeroNom(),nomScientifique); |
| } |
| } |
| } else { |
| referentielNomData = new ListeReferentielNom(0) ; |
| } |
| addToCache(critere, referentielNomData); |
| r.rafraichir(referentielNomData,true); |
| } |
| }) ; |
| } catch(RequestException e) { |
| } |
| } // fin else si pas de cache |
| } |
| @Override |
| public void obtenirListeDonnees(Rafraichissable r, String critere) { |
| obtenirListeDonnees(r, "bdtfx", critere); |
| } |
| private void addToCache(String query, ListeReferentielNom result) { |
| cache.put(query.toLowerCase(),result); |
| } |
| private ListeReferentielNom getFromCache (String query) { |
| return cache.get(query.toLowerCase()); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeDateImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,84 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| public class ListeDateImageAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ImageModele imageModele = null; |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeDateImageAsynchroneDAO(final ImageModele obs) { |
| this.imageModele = obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres. |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param critere un string contenant le terme a rechercher |
| */ |
| public final void obtenirListeDate(final Rafraichissable r, final String utilisateur) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/ImageDateList/" + utilisateur); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(final Request request, final Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| final ListeDate lDateObs; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = responseValue.isArray(); |
| // si c'est un tableau |
| lDateObs = (reponse) != null ? new ListeDate(reponse) : new ListeDate(0); |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| r.rafraichir(lDateObs, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,181 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| /** |
| * DAO d'accès à une image, n'est utilisé que pour l'écriture et pas pour la |
| * lecture des images qui se fait par paquet |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageAsynchroneDAO { |
| ImageModele iModele = null; |
| public ImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Met à jour la base de données avec toutes les données d'une image |
| * |
| * @param ic |
| * l'image à mettre à jour |
| */ |
| public void SynchroniserBaseDeDonnees(final ImageCarnet ic) { |
| String postData = ""; |
| String[][] champsModifiables = ic.obtenirChampsModifiablesImage(); |
| for (int i = 0; i < champsModifiables.length; i++) { |
| postData += "&"+champsModifiables[i][0]+"="+champsModifiables[i][1]; |
| } |
| // et on envoie une requête asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImage/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+"/"+ic.getId()); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Met à jour la base de données avec les mots clés associés à l'image |
| * |
| * @param ic |
| * l'image à mettre à jour |
| */ |
| public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic) { |
| String postData = ""; |
| // on récupère les mots clés de l'image et on fabrique le post |
| String motsCles = ic.getMotsCles(); |
| String id = ic.getId(); |
| postData += "&id_image=" + id + "&id_mot_cle_utilisateur=" + motsCles; |
| // on envoie une requête asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventoryKeyWordImageList/" +Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+ "/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| // TODO: les messages ne devraient pas être affichés ici |
| // mais l'architecture par très malléable complique les choses |
| if (response.getText().equals("OK")) { |
| com.google.gwt.user.client.Window |
| .alert("Les mots clés suivants ont bien été appliqués : "+iModele.renvoyerChaineMotClesTexte(ic)); |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText()); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Supprime une image de la base de données |
| * |
| * @param ic |
| * l'image à supprimer |
| */ |
| public void supprimerBaseDeDonnees(final ImageCarnet ic) { |
| // le post contient l'action delete pour JREST (qui ne gère pas DELETE |
| // comme une requête à part entière) |
| String postData = ""; |
| postData += "&action=DELETE"; |
| // on envoie un post avec l'id de l'image à supprimer |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImage/" |
| + iModele.getIdentifiant() |
| + "/" |
| + ic.getId()); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données : "+response.getText()); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,251 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.modeles.objets.ListeImageCarnet; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * Data Object Access communiquant avec le serveur jrest fournissant la liste |
| * des images répondant à des critères donné |
| * |
| * @author aurelien |
| * |
| */ |
| public class ListeImageAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| ImageModele iModele = null; |
| public ListeImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèle à associer |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir une liste d'images |
| * correspondant à des critères demandés |
| * |
| * @param r |
| * le rafraichissable qui a demandé les données |
| * @param criteres |
| * un tableau contenant les critères de selections |
| */ |
| public void ObtenirListeImages(final Rafraichissable r, String[][] criteres) { |
| String requete = ""; |
| // on construit les paramètres du get |
| if (criteres != null) { |
| for (int i = 0; i < criteres.length; i++) { |
| if (!criteres[i][1].equals("")) { |
| if (i != 0) { |
| requete += "&"; |
| } |
| requete += criteres[i][0] + "=" + criteres[i][1]; |
| } |
| } |
| } |
| // on envoie le get asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryImageList/" |
| + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() |
| + "/?" |
| + requete); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| final ListeImageCarnet photoData; |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si c'est un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| final int taillemax = reponse.size(); |
| photoData = new ListeImageCarnet(taillemax); |
| // on le parcourt |
| for (int j = 0; j < taillemax; j++) { |
| JSONObject image = (JSONObject) reponse.get(j); |
| ImageCarnet im = new ImageCarnet(image); |
| // et on en extrait les données pour construire la |
| // liste d'image |
| photoData.put(im.getOrdre(), im); |
| } |
| } else { |
| // si c'est un objet alors il n'y a qu'une réponse |
| if (responseValue.isObject() != null) { |
| photoData = new ListeImageCarnet(1); |
| ImageCarnet im = new ImageCarnet(responseValue |
| .isObject()); |
| // on crée une liste de 1 élement auquel on ajoute |
| // ce qui a été reçu |
| photoData.put(im.getOrdre(), im); |
| } else { |
| // sinon on crée une liste vide |
| photoData = new ListeImageCarnet(0); |
| } |
| } |
| // dans tous les cas on transmet la liste crée au |
| // rafraichissable en lui demandant de répandre les données |
| // car il est |
| // le premier à les recevoir |
| r.rafraichir(photoData, true); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Met à jour les valeurs d'une liste d'image donnée dans la base de données |
| * |
| * @param li |
| * la liste d'image à synchroniser avec la base |
| */ |
| public void SynchroniserBaseDeDonnees(ListeImageCarnet li) { |
| // on parcourt toute la liste d'image |
| for (Iterator<String> listIt = li.keySet().iterator(); listIt.hasNext();) { |
| String postData = ""; |
| ImageCarnet enCours = li.get(listIt.next()); |
| String[][] champsModifiables = enCours.obtenirChampsModifiablesImage(); |
| for (int i = 0; i < champsModifiables.length; i++) { |
| postData += "&"+champsModifiables[i][0]+"="+champsModifiables[i][1]; |
| } |
| // on fait un post asynchrone et on les envoie à jrest |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventoryImage/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Supprime des image sur le serveur par rapport à leur identifant |
| * |
| * @param ids |
| * un tableau d'identifiants d'images à supprimer |
| */ |
| public void supprimerBaseDeDonnees(String[] ids) { |
| String postData = ""; |
| // on fait un delete dans le post (jrest ne gère pas delete comme une |
| // action à part entière) |
| postData += "&action=DELETE"; |
| String uid = ""; |
| // on concatène les ids |
| for (int i = 0; i < ids.length; i++) { |
| uid += ids[i] + ","; |
| } |
| // et on envoie ça au serveur |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImageList/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/" + uid); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| // quand la requête est éxecutée on le signale au modèle |
| // poru qu'il mette à jour les données |
| // et en notifie le médiateur |
| iModele.requeteTerminee(); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/NombreImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,116 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO qui renvoie le nombre d'image associées à différents critères donnés |
| * (utile pour la pagination) |
| * |
| * @author aurelien |
| * |
| */ |
| public class NombreImageAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| private ImageModele iModele = null; |
| public NombreImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèlme à associer |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir le nombre d'images |
| * correspondant à des critères données en paramètres |
| * |
| * @param r |
| * le rafraichissable qui demande la mise à jour |
| * @param criteres |
| * un tableau nom/valeur des critères pour les images |
| */ |
| public void obtenirNombreImages(final Rafraichissable r, String[][] criteres) { |
| String requete = ""; |
| if (criteres != null) { |
| // on construit les paramètres du get avec les critères |
| // (&critere1=valeur1&critere2=valeur2 etc...) |
| for (int i = 0; i < criteres.length; i++) { |
| if (!criteres[i][1].equals("")) { |
| if (i != 0) { |
| requete += "&"; |
| } |
| requete += criteres[i][0] + "=" + criteres[i][1]; |
| } |
| } |
| } |
| // on fait un get asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryImageCount/" |
| + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() |
| + "/?" |
| + requete); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si la requete se passe bien on reçoit une chaine JSON |
| if (responseValue.isString() != null) { |
| // qui contient une valeur : le nombre d'images |
| // correspondant au critères |
| JSONString reponseNombre = responseValue.isString(); |
| int maxImages = Integer.parseInt(reponseNombre |
| .stringValue()); |
| int[] nbImages = { maxImages }; |
| // on le met dans un tableau d'entiers qu'on transmet au |
| // demandeur de la mise à jour |
| r.rafraichir(nbImages, true); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ExportObservationsDAO.java |
|---|
| New file |
| 0,0 → 1,40 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.user.client.Window; |
| public class ExportObservationsDAO { |
| ObservationModele om = null ; |
| public ExportObservationsDAO(ObservationModele observationModele) { |
| om = observationModele ; |
| } |
| public void exporterObservations(String identifiant, String[][] criteres, String format, String groupes) { |
| String requete = "colonnes=" + groupes ; |
| if(criteres != null) |
| { |
| // on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
| for (int i = 0; i < criteres.length; i++) { |
| if(criteres[i] != null && criteres[i][1] != null && !criteres[i][1].equals("")) |
| { |
| requete += "&"+criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ; |
| } |
| } |
| } |
| requete += "&id_utilisateur="+identifiant+"&format="+format; |
| Window.open(Configuration.getServiceBaseUrl()+"/CelWidgetExport/export/?"+requete,"Export",null) ; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ImportObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,57 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| public class ImportObservationAsynchroneDAO { |
| private ObservationModele oModele = null ; |
| public ImportObservationAsynchroneDAO(ObservationModele observationModele) { |
| oModele = observationModele; |
| } |
| public void importerObservations() { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryImport/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(response.getText().equals("OK")) { |
| oModele.obtenirNombreObservation(null); |
| } |
| else |
| { |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/MotsClesAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,268 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO d'accès à l'arbre de mots clés |
| * |
| * @author aurelien |
| * |
| */ |
| public class MotsClesAsynchroneDAO { |
| private String identifiant = "" ; |
| private String mode = ""; |
| public MotsClesAsynchroneDAO() { |
| mode = "images"; |
| identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(); |
| } |
| public MotsClesAsynchroneDAO(String mode) { |
| this.mode = mode; |
| identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(); |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir l'arbre des mots clés |
| * |
| * @param r |
| * le rafraichissable qui demande les données |
| */ |
| public void obtenirListeMotsCles(final Rafraichissable r) { |
| // on demande tous les mots clés associés à l'utilisateur |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/"+mode+"/"+identifiant+"/"); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si la requête est un succès on reçoit un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // et on met à jour le demandeur des données |
| r.rafraichir(reponse, true); |
| } else { |
| JSONArray vide = new JSONArray(); |
| r.rafraichir(vide, true); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour ajouter un mot clé |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void ajouterBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = motcle+"&mode="+mode; |
| // on fait un post asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| // TODO: les messages ne devraient pas être affichés ici |
| // mais l'architecture par très malléable complique les choses |
| if (response.getText().equals("OK")) { |
| com.google.gwt.user.client.Window |
| .alert("Le mot clé a été ajouté"); |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText()); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour supprimer un mot clé |
| * |
| * @param motcle |
| * le mots clés à supprimer |
| */ |
| public void supprimerBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = ""; |
| postData += "&action=DELETE"; |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/" |
| + mode+"/" |
| + identifiant |
| + "/" |
| + motcle); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| // TODO: les messages ne devraient pas être affichés ici |
| // mais l'architecture par très malléable complique les choses |
| if (response.getText().equals("OK")) { |
| com.google.gwt.user.client.Window |
| .alert("Le mot clé a été supprimé"); |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText()); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour modifier un mot clé |
| * |
| * @param motcle |
| * le mots clés à modifier avec son parent et son identifiant |
| */ |
| public void modifierBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = ""; |
| postData += "&action=modification"+motcle; |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/"+mode+"/"+ identifiant); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| // TODO: les messages ne devraient pas être affichés ici |
| // mais l'architecture par très malléable complique les choses |
| if (response.getText().equals("OK")) { |
| com.google.gwt.user.client.Window |
| .alert("Le mot clé a été renommé"); |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText()); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour modifier un mot clé |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son ancien parent, son nouveau et |
| * son identifiant |
| */ |
| public void deplacerBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = ""; |
| postData += "&action=deplacement"+motcle; |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/"+mode+"/"+identifiant); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeReferentielCommuneAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,146 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielCommune; |
| import org.tela_botanica.client.modeles.objets.ReferentielCommune; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO la liste des communes. Utilisation d'un cache pour eviter les requetes inutiles |
| * @author David Delon |
| * |
| */ |
| public class ListeReferentielCommuneAsynchroneDAO implements FournisseurListe { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| /** |
| * Cache |
| * |
| */ |
| private HashMap<String,ListeReferentielCommune> cache = new HashMap(); |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeReferentielCommuneAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele = obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres. |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param critere un string contenant le terme a rechercher |
| */ |
| @Override |
| public final void obtenirListeDonnees(final Rafraichissable r, final String critere) { |
| ListeReferentielCommune referentielCommuneDataFromCache=null; |
| // En cache ? |
| if ((referentielCommuneDataFromCache=getFromCache(critere))!=null) { |
| r.rafraichir(referentielCommuneDataFromCache,true); |
| } |
| else { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/LocationSearch/" + URL.encodeComponent(critere)); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(final Request request, final Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| final ListeReferentielCommune referentielCommuneData; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = null; |
| // si c'est un tableau |
| if ((reponse = responseValue.isArray()) != null) { |
| JSONArray communes; |
| final int taillemax = reponse.size(); |
| referentielCommuneData = new ListeReferentielCommune(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((communes = reponse.get(i).isArray()) != null) { |
| String commune = ((JSONString) communes.get(0)).stringValue(); |
| String departement = ((JSONString) communes.get(1)).stringValue(); |
| ReferentielCommune com = new ReferentielCommune(commune, departement); |
| referentielCommuneData.put(com.getCommune() + com.getDepartement(), com); |
| } |
| } |
| } else { |
| referentielCommuneData = new ListeReferentielCommune(0); |
| } |
| addToCache(critere, referentielCommuneData); |
| r.rafraichir(referentielCommuneData, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } // Fin else si pas de cache |
| } |
| /** |
| * Fonction à implémenter dans le futur, lors de l'utilisation de plusieurs |
| * référentiels de localité |
| */ |
| @Override |
| public void obtenirListeDonnees(Rafraichissable r, String referentiel, String critere) { |
| // TODO Auto-generated method stub |
| } |
| private void addToCache(String query, ListeReferentielCommune result) { |
| cache.put(query.toLowerCase(),result); |
| } |
| private ListeReferentielCommune getFromCache (String query) { |
| return cache.get(query.toLowerCase()); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/LienImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,248 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| public class LienImageAsynchroneDAO { |
| private ImageModele iModele = null ; |
| private ObservationModele oModele = null ; |
| private Rafraichissable raf = null ; |
| public LienImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| public LienImageAsynchroneDAO(ObservationModele om) { |
| oModele = om; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèle à associer |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| public void obtenirLiaisonsImagesObservations(Rafraichissable r,String id) |
| { |
| String paramGet = "id_image="+id ; |
| raf = r ; |
| // et on envoie ça au serveur |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/" + paramGet); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| final ListeObservation observationData ; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse=null; |
| // si c'est un tableau |
| if ((reponse=responseValue.isArray()) != null) { |
| JSONObject observation; |
| final int taillemax = reponse.size(); |
| observationData = new ListeObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((observation = reponse.get(i).isObject()) != null) { |
| Observation obs= new Observation(observation); |
| observationData.put(obs.getNumeroOrdre(),obs); |
| } |
| } |
| } else { |
| observationData = new ListeObservation(0) ; |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| // TODO : ce n'est pas ici qu'on devrait le decider .. |
| raf.rafraichir(observationData,true); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void obtenirLiaisonsObservationsImages(Rafraichissable r,String idObs, String utilisateur) |
| { |
| String paramGet = "id_observation="+idObs ; |
| raf = r ; |
| // et on envoie ça au serveur |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/" + utilisateur + "/" + paramGet); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| String baseUrl = Configuration.getImageBaseUrl() ; |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si c'est un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| final int taillemax = reponse.size(); |
| String imgTab[][] = new String[taillemax][3] ; |
| for(int i = 0 ;i<taillemax ;i++) |
| { |
| final JSONObject reponseInt = reponse.get(i).isObject(); |
| String idImg = Util.getValeurJsonOuVide(reponseInt, "id_image") ; |
| String X = Util.getValeurJsonOuVide(reponseInt, "hauteur") ; |
| String Y = Util.getValeurJsonOuVide(reponseInt, "largeur") ; |
| imgTab[i][0] = idImg ; |
| imgTab[i][1] = X ; |
| imgTab[i][2] = Y ; |
| } |
| raf.rafraichir(imgTab, false) ; |
| } |
| else |
| { |
| String imgTab[] = new String[0] ; |
| raf.rafraichir(imgTab, false) ; |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void lierImageBaseDeDonnees(String idsImages, String idsObs) { |
| String postData = ""; |
| postData += "id_image="+idsImages ; |
| postData += "&id_observation="+idsObs ; |
| postData += "&ce_utilisateur="+Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() ; |
| // et on envoie ça au serveur |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| iModele.requeteTerminee(); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void supprimerLienImageObservation(String idImg, String idObs) { |
| String postData = ""; |
| postData += "&action=DELETE" ; |
| String identifiant = "" ; |
| identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(); |
| // et on envoie ça au serveur |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/"+identifiant+"/"+idImg+"/"+idObs); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| // quand la requête est éxecutée on le signale au modèle |
| // pour qu'il mette à jour les données |
| // et en notifie le médiateur |
| iModele.requeteTerminee(); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeDateObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,87 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| public class ListeDateObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeDateObservationAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele = obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres. |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param critere un string contenant le terme a rechercher |
| */ |
| public final void obtenirListeDate(final Rafraichissable r, final String utilisateur) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/InventoryDateList/" + utilisateur); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(final Request request, final Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| final ListeDate lDateObs; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = responseValue.isArray(); |
| // si c'est un tableau |
| lDateObs = (reponse) != null ? new ListeDate(reponse) : new ListeDate(0); |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| r.rafraichir(lDateObs, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,205 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.user.client.Window; |
| /** |
| * DAO d'accès a une observation |
| * |
| * @author aurelien |
| * |
| */ |
| public class ObservationAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele oModele = null; |
| public ObservationAsynchroneDAO(ObservationModele obs) { |
| oModele = obs; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param obs |
| * le modèle à associer |
| */ |
| public void setoModele(ObservationModele obs) { |
| oModele = obs; |
| } |
| /** |
| * Envoie requete au serveur pour ajouter une observations |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void ajouter(final Rafraichissable r, String utilisateur, final Observation obs) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/Inventory/") ; |
| rb.setHeader("Content-type", "application/x-www-form-urlencoded"); |
| String postData = "ce_utilisateur=" |
| + utilisateur |
| +"&nom_sel="+URL.encodeComponent(obs.getNomSaisi()) |
| +"&nom_sel_nn="+obs.getNumeroNomenclaturalSaisi() |
| +"&zone_geo="+URL.encodeComponent(obs.getLocalite()) |
| +"&ce_zone_geo="+obs.getIdentifiantLocalite() |
| +"&date_observation=" + obs.getDate() |
| +"&lieudit="+ URL.encodeComponent(obs.getLieudit()) |
| +"&station="+URL.encodeComponent(obs.getStation()) |
| +"&milieu="+URL.encodeComponent(obs.getMilieu()) |
| +"&commentaire="+obs.getCommentaire() |
| +"&latitude="+URL.encodeComponent(""+obs.getLatitude()) |
| +"&longitude="+URL.encodeComponent(""+obs.getLongitude()) |
| +"&altitude="+URL.encodeComponent(""+obs.getAltitude()) |
| +"&abondance="+URL.encodeComponent(""+obs.getAbondance()) |
| +"&certitude="+URL.encodeComponent(""+obs.getCertitude()) |
| +"&phenologie="+URL.encodeComponent(""+obs.getPhenologie()) |
| +"&nom_referentiel="+URL.encodeComponent(""+obs.getReferentielTaxo()) |
| +"&obs_etendue="+URL.encodeComponent(""+Util.convertirChampsEtendusEnChaineRequete(obs.getChampsEtendus())); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(response.getStatusCode() >= 400) { |
| com.google.gwt.user.client.Window.alert(response.getText()); |
| } |
| r.rafraichir(obs,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| /** |
| * Envoie requete au serveur pour modifier une observations |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void modifier(final Rafraichissable r, String utilisateur, final Observation obs) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/Inventory/" + utilisateur + "/" + obs.getNumeroOrdre()+ "/") ; |
| rb.setHeader("Content-type", "application/x-www-form-urlencoded"); |
| String postData = "ce_utilisateur=" |
| + utilisateur |
| + "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()) |
| + "&nom_sel_nn=" + obs.getNumeroNomenclaturalSaisi() |
| + "&zone_geo=" + URL.encodeComponent(obs.getLocalite()) |
| + "&ce_zone_geo=" + obs.getIdentifiantLocalite() |
| + "&date_observation=" + obs.getDate() |
| + "&lieudit="+ URL.encodeComponent(obs.getLieudit()) |
| + "&station="+ URL.encodeComponent(obs.getStation()) |
| +"&milieu="+ URL.encodeComponent(obs.getMilieu()) |
| +"&commentaire="+obs.getCommentaire() |
| +"&latitude="+URL.encodeComponent(""+obs.getLatitude()) |
| +"&longitude="+URL.encodeComponent(""+obs.getLongitude()) |
| +"&altitude="+URL.encodeComponent(""+obs.getAltitude()) |
| +"&abondance="+URL.encodeComponent(""+obs.getAbondance()) |
| +"&certitude="+URL.encodeComponent(""+obs.getCertitude()) |
| +"&phenologie="+URL.encodeComponent(""+obs.getPhenologie()) |
| +"&nom_referentiel="+URL.encodeComponent(""+obs.getReferentielTaxo()) |
| +"&obs_etendue="+URL.encodeComponent(""+Util.convertirChampsEtendusEnChaineRequete(obs.getChampsEtendus())); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(response.getStatusCode() >= 400) { |
| com.google.gwt.user.client.Window.alert(response.getText()); |
| } |
| r.rafraichir(obs,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void supprimer(Rafraichissable r, String identifiant, String numeroOrdre) { |
| String postData = ""; |
| postData += "&action=DELETE"; |
| // on envoie un post avec l'id de l'image à supprimer |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventory/" |
| + identifiant |
| + "/" |
| + numeroOrdre); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| return ; |
| } |
| } |
| }); |
| r.rafraichir("OK", true) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,273 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO la liste des observations attachées a un observateur. |
| * @author David Delon |
| * TODO : se servir de ObservationDAO pour la lecture unitaire |
| * |
| */ |
| public class ListeObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| private ImageModele imageModele = null; |
| public ListeObservationAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele=obs; |
| } |
| /** |
| * Le modèle associé au DAO. |
| */ |
| public ListeObservationAsynchroneDAO(final ImageModele img) { |
| this.imageModele = img; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant |
| * à des critères données en paramètres |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param criteres un tableau nom/valeur des critères pour les observations |
| */ |
| public final void obtenirListeObservation(final Rafraichissable r, final String utilisateur, final String[][] criteres) |
| { |
| String requete = "" ; |
| if(criteres != null) |
| { |
| // on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
| // ils contiennent limite et taille page et autres filtres (communes , lieu dit etc ...)S |
| for (int i = 0; i < criteres.length; i++) { |
| if(criteres[i][1] != null && !criteres[i][1].equals("")) |
| { |
| if(i!= 0) |
| { |
| requete += "&"; |
| } |
| requete += criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ; |
| } |
| } |
| } |
| // on envoie le get asynchrone |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() |
| +"/InventoryObservationList/"+utilisateur+"/?"+requete) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(final Request request, final Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| final ListeObservation observationData ; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse=null; |
| // si c'est un tableau |
| if ((reponse=responseValue.isArray()) != null) { |
| JSONObject observation; |
| final int taillemax = reponse.size(); |
| observationData = new ListeObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((observation=reponse.get(i).isObject()) != null) { |
| Observation obs = new Observation(observation); |
| observationData.put(obs.getNumeroOrdre(),obs); |
| } |
| } |
| } else { |
| observationData = new ListeObservation(0) ; |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| // TODO : ce n'est pas ici qu'on devrait le decider .. |
| r.rafraichir(observationData,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void modifierEnMasse(final Rafraichissable r, String identifiant, |
| final Observation obs) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryObservationList/" + identifiant + "/" + obs.getNumeroOrdre()+ "/") ; |
| String postData = "ce_utilisateur=" |
| + identifiant ; |
| if(obs.getNomSaisi() != null) { |
| postData += "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()); |
| } |
| if(obs.getNumeroNomenclaturalSaisi() != null) { |
| postData += "&nom_sel_nn=" + obs.getNumeroNomenclaturalSaisi(); |
| } |
| if(obs.getIdentifiantLocalite() != null) { |
| postData += "&ce_zone_geo=" + obs.getIdentifiantLocalite(); |
| } |
| if(obs.getLocalite() != null) { |
| postData += "&zone_geo=" + URL.encodeComponent(obs.getLocalite()); |
| } |
| if(obs.getDate() != null) { |
| postData += "&date_observation=" + obs.getDate(); |
| } |
| if(obs.getLieudit() != null) { |
| postData += "&lieudit="+ URL.encodeComponent(obs.getLieudit()); |
| } |
| if(obs.getStation() != null) { |
| postData += "&station="+ URL.encodeComponent(obs.getStation()); |
| } |
| if(obs.getMilieu() != null) { |
| postData += "&milieu="+ URL.encodeComponent(obs.getMilieu()); |
| } |
| if(obs.getCommentaire() != null) { |
| postData += "&commentaire="+obs.getCommentaire(); |
| } |
| if(obs.getLatitude() != null ) { |
| postData += "&latitude="+URL.encodeComponent(""+obs.getLatitude()); |
| } |
| if(obs.getLongitude() != null) { |
| postData += "&longitude="+URL.encodeComponent(""+obs.getLongitude()); |
| } |
| if(obs.getAltitude() != null) { |
| postData += "&altitude="+URL.encodeComponent(""+obs.getAltitude()); |
| } |
| if(obs.getAbondance() != null) { |
| postData += "&abondance="+URL.encodeComponent(""+obs.getAbondance()); |
| } |
| if(obs.getCertitude() != null) { |
| postData += "&certitude="+URL.encodeComponent(""+obs.getCertitude()); |
| } |
| if(obs.getPhenologie() != null) { |
| postData += "&phenologie="+URL.encodeComponent(""+obs.getPhenologie()); |
| } |
| if(obs.getReferentielTaxo() != null) { |
| postData += "&nom_referentiel="+URL.encodeComponent(""+obs.getReferentielTaxo()); |
| } |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(observationModele != null) { |
| observationModele.obtenirListeObservation(r); |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| /** |
| * Supprime les observations possédant les identifiants données |
| * @param r le rafraichissable à avertir de la mise à jour |
| * @param identifiant l'identifiant utilisateur |
| * @param numerosOrdre les numéros d'ordre des observations séparés par des virgules |
| */ |
| public void supprimerListeObservation(Rafraichissable r, String identifiant, String numerosOrdre) { |
| String postData = ""; |
| postData += "&action=DELETE"; |
| // on envoie un post avec l'id de l'image à supprimer |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventoryObservationList/" |
| + identifiant |
| + "/" |
| + numerosOrdre); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| return ; |
| } |
| } |
| }); |
| r.rafraichir("OK", true) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/NombreObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,112 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO qui renvoie le nombre d'image associées à différents critères donnés (utile pour la pagination) |
| * @author aurelien |
| * |
| */ |
| public class NombreObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| private ObservationModele observationModele = null ; |
| private ImageModele imageModele = null; |
| public NombreObservationAsynchroneDAO(ObservationModele observationModele) |
| { |
| this.observationModele=observationModele; |
| } |
| public NombreObservationAsynchroneDAO(final ImageModele imageModele) { |
| this.imageModele = imageModele; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant |
| * à des critères données en paramètres |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param criteres un tableau nom/valeur des critères pour les images |
| */ |
| public void obtenirNombreObservation(final Rafraichissable r, String utilisateur, String[][] criteres) |
| { |
| String requete = "" ; |
| if(criteres != null) |
| { |
| // on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
| for (int i = 0; i < criteres.length; i++) { |
| if(criteres[i][1] != null && !criteres[i][1].equals("")) |
| { |
| if(i!= 0) |
| { |
| requete += "&"; |
| } |
| requete += criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ; |
| } |
| } |
| } |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl()+"/InventoryObservationCount/"+utilisateur+"/?"+requete) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void onResponseReceived(Request request, |
| Response response) { |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| // si la requete se passe bien on reçoit un tableau JSON |
| if(responseValue.isString() != null) |
| { |
| // qui contient une valeur : le nombre d'images correspondant au critères |
| JSONString res = responseValue.isString() ; |
| int maxObservations = Integer.parseInt(res.stringValue()) ; |
| int[] nbObservations = {maxObservations} ; |
| // on le met dans un tableau d'entiers qu'on tranmset au demandeur de la mise à jour |
| r.rafraichir(nbObservations, true) ; |
| } else { |
| int[] nbObservations = {} ; |
| r.rafraichir(nbObservations, true) ; |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/dao/ListeReferentielChampsEtendusDAO.java |
|---|
| New file |
| 0,0 → 1,124 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.Request; |
| import org.tela_botanica.client.util.RequestBuilderWithCredentials; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| public class ListeReferentielChampsEtendusDAO { |
| /** |
| * Cache |
| * |
| */ |
| private HashMap<String,ListeReferentielPerso> cache = new HashMap(); |
| public ListeReferentielChampsEtendusDAO(ObservationModele obs) { |
| } |
| public void obtenirListeNomsChampsEtendus(final Rafraichissable r, String recherche) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + |
| "/NomsChampsEtendus/cle"+ |
| "?recherche="+URL.encode(recherche)); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| HashMap<String, String> labelCles = new HashMap<String, String>(); |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONObject reponse = null; |
| // si c'est un tableau |
| if ((reponse = responseValue.isObject()) != null) { |
| Iterator<String> it = reponse.keySet().iterator(); |
| while(it.hasNext()) { |
| String cle = it.next(); |
| String valeur = reponse.get(cle).isString().stringValue(); |
| labelCles.put(cle, valeur); |
| } |
| } |
| r.rafraichir(labelCles, true); |
| } |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| public void obtenirListeValeursChampEtendu(final Rafraichissable r, String cle, String recherche) { |
| RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + |
| "/NomsChampsEtendus/valeur"+ |
| "?cle="+URL.encode(cle)+"&recherche="+URL.encode(recherche)); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| @Override |
| public void onResponseReceived(final Request request, |
| final Response response) { |
| ArrayList<String> valeurs = new ArrayList<String>(); |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = null; |
| if ((reponse = responseValue.isArray()) != null) { |
| for(int i = 0; i < reponse.size(); i++) { |
| valeurs.add(reponse.get(i).isString().stringValue()); |
| } |
| } |
| r.rafraichir(valeurs, true); |
| } |
| @Override |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/EntiteGeographiqueObservation.java |
|---|
| New file |
| 0,0 → 1,74 |
| package org.tela_botanica.client.modeles.objets; |
| /** |
| * |
| * Classe representant une idZoneGeo geographique (localite, zoneGeo, lieu dit) presente dans la liste des observations |
| * |
| */ |
| public class EntiteGeographiqueObservation { |
| private String idZoneGeo=null; |
| private String zoneGeo=null; |
| private String lieuDit=null; |
| private String station=null; |
| private String lat=null; |
| private String lon=null; |
| public EntiteGeographiqueObservation() { |
| } |
| /** |
| * @param zoneGeo |
| * @param departement |
| */ |
| public EntiteGeographiqueObservation(String idZoneGeo, String zoneGeo, String lieuDit, String station) { |
| this.idZoneGeo = idZoneGeo; |
| this.zoneGeo = zoneGeo; |
| this.lieuDit = lieuDit; |
| this.station = station; |
| } |
| public void setLat(String la) { |
| lat = la; |
| } |
| public void setLon(String lo) { |
| lon = lo; |
| } |
| public String getLat() { |
| return lat; |
| } |
| public String getLon() { |
| return lon; |
| } |
| public String getIdZoneGeo() { |
| return idZoneGeo; |
| } |
| public String getZoneGeo() { |
| return zoneGeo; |
| } |
| public String getLieuDit() { |
| return lieuDit; |
| } |
| public String getStation() { |
| return station; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ListeEntiteGeographiqueObservation.java |
|---|
| New file |
| 0,0 → 1,54 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.LinkedHashMap; |
| /** |
| * table de hachage composée d'entite geographique, renvoyé par les objets de type DAO |
| * La clé est le nom de l'entite + le nom de l'entite parente |
| * |
| * @author david delon |
| * |
| */ |
| public class ListeEntiteGeographiqueObservation extends LinkedHashMap<String, EntiteGeographiqueObservation> { |
| private static final long serialVersionUID = 2717710270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeEntiteGeographiqueObservation() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeEntiteGeographiqueObservation(int taille) |
| { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau d'ImageCarnet |
| */ |
| public ListeEntiteGeographiqueObservation(EntiteGeographiqueObservation[] ent) |
| { |
| super() ; |
| for (int i = 0; i < ent.length; i++) |
| { |
| if(ent[i] != null && ent[i] instanceof EntiteGeographiqueObservation) |
| { |
| this.put(ent[i].hashCode()+"",ent[i]); |
| } |
| } |
| } |
| public void put(EntiteGeographiqueObservation value) { |
| this.put(value.hashCode()+"",value); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/Configuration.java |
|---|
| New file |
| 0,0 → 1,294 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import com.google.gwt.i18n.client.Dictionary; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.Window.Location; |
| /** |
| * Classe chargeant certains paramètres de configuration à partir d'un fichier |
| * javascript (config.js) |
| * |
| * @author aurelien |
| * |
| */ |
| public class Configuration { |
| /** |
| * L'url de base du serveur jrest |
| */ |
| private static String serviceBaseUrl; |
| private static String imageBaseUrl; |
| private static String suiviBugUrl ; |
| private static String aideBaseUrl ; |
| private static String emailContact; |
| private static String referentielGeo ; |
| private static String cleGoogleMaps ; |
| private static String lienEfloreBaseUrl; |
| private static String refTax; |
| private static String refTaxVersion; |
| private static String licence =""; |
| private static String formatOriginal = ""; |
| private static String formatZoom = ""; |
| private static String formatGalerie = ""; |
| private static String formatListe = ""; |
| private static String utiliseRedirectionImage; |
| private static String imageRedirectUrl; |
| private static String tailleMaxUpload; |
| private static List<InfosReferentielNom> referentielsDispos; |
| private static Map<String,HashMap<String, String>> groupesChampsEtendus; |
| private static String activerSaisieChampsEtendus = "0"; |
| /** |
| * Constructeur sans argument |
| */ |
| public Configuration() { |
| // on utilise le dictionnaire d'internationalisation pour lire les |
| // variables du fichier javascript |
| //if(GWT.isScript()) { |
| serviceBaseUrl = Dictionary.getDictionary("configuration").get( |
| "serviceBaseUrl"); |
| emailContact = Dictionary.getDictionary("configuration").get( |
| "emailContact"); |
| suiviBugUrl = Dictionary.getDictionary("configuration").get( |
| "suiviBugUrl"); |
| imageBaseUrl = Dictionary.getDictionary("configuration").get( |
| "imageBaseUrl"); |
| aideBaseUrl = Dictionary.getDictionary("configuration").get( |
| "aideBaseUrl"); |
| referentielGeo = Dictionary.getDictionary("configuration").get( |
| "referentielGeo"); |
| cleGoogleMaps = Dictionary.getDictionary("configuration").get( |
| "cleGoogleMaps"); |
| lienEfloreBaseUrl = Dictionary.getDictionary("configuration").get( |
| "lienEfloreBaseUrl"); |
| formatOriginal = Dictionary.getDictionary("configuration").get( |
| "formatOriginal"); |
| formatZoom = Dictionary.getDictionary("configuration").get( |
| "formatZoom"); |
| formatGalerie = Dictionary.getDictionary("configuration").get( |
| "formatGalerie"); |
| formatListe = Dictionary.getDictionary("configuration").get( |
| "formatListe"); |
| utiliseRedirectionImage = Dictionary.getDictionary("configuration").get( |
| "utiliseRedirectionImage"); |
| imageRedirectUrl = Dictionary.getDictionary("configuration").get( |
| "imageRedirectUrl"); |
| tailleMaxUpload = Dictionary.getDictionary("configuration").get( |
| "tailleMaxUpload"); |
| referentielsDispos = parserReferentielsDispos(Dictionary.getDictionary("configuration").get( |
| "referentielsDispos")); |
| activerSaisieChampsEtendus = Dictionary.getDictionary("configuration").get( |
| "activerSaisieChampsEtendus"); |
| // Pour test, l'activation de l'ajout des champs étendus est activable ou désactivable par |
| // l'url |
| if(Location.getParameter("activerSaisieChampsEtendus") != null) { |
| if(Location.getParameter("activerSaisieChampsEtendus").equals("1")) { |
| activerSaisieChampsEtendus = "1"; |
| } else if(Location.getParameter("activerSaisieChampsEtendus").equals("0")) { |
| activerSaisieChampsEtendus = "0"; |
| } |
| } |
| groupesChampsEtendus = new HashMap<String,HashMap<String, String>>(); |
| if(activerSaisieChampsEtendus.equals("1")) { |
| if(Dictionary.getDictionary("configuration").get("groupesChampsEtendus") != null && |
| !Dictionary.getDictionary("configuration").get("groupesChampsEtendus").isEmpty()) { |
| groupesChampsEtendus = parserGroupesChampsEtendus(Dictionary.getDictionary("configuration").get( |
| "groupesChampsEtendus")); |
| } |
| } |
| } |
| private HashMap<String,HashMap<String, String>> parserGroupesChampsEtendus(String groupeChampsEtendusJson) { |
| HashMap<String,HashMap<String, String>> groupesChampsEtendus = new HashMap<String,HashMap<String, String>>(); |
| try { |
| JSONValue groupesJson = JSONParser.parse(groupeChampsEtendusJson); |
| JSONObject groupes = groupesJson.isObject(); |
| for (Iterator<String> iterator = groupes.keySet().iterator(); iterator.hasNext();) { |
| String groupe = iterator.next(); |
| JSONValue listeClesLabelsJson = groupes.get(groupe); |
| JSONObject listeClesLabels = listeClesLabelsJson.isObject(); |
| HashMap<String, String> groupesClesLabel = new HashMap<String, String>(); |
| for (Iterator<String> itCleLabels = listeClesLabels.keySet().iterator(); itCleLabels.hasNext();) { |
| String cle = itCleLabels.next(); |
| String label = listeClesLabels.get(cle).isString().stringValue(); |
| groupesClesLabel.put(cle, label); |
| } |
| groupesChampsEtendus.put(groupe, groupesClesLabel); |
| } |
| } catch (Exception e) { |
| // TODO: handle exception |
| } |
| return groupesChampsEtendus; |
| } |
| private List<InfosReferentielNom> parserReferentielsDispos(String chaineListeReferentiels) { |
| String[] tabReferentiels = chaineListeReferentiels.split(";"); |
| List<InfosReferentielNom> referentiels = new ArrayList<InfosReferentielNom>(tabReferentiels.length); |
| for (int i = 0; i < tabReferentiels.length; i++) { |
| InfosReferentielNom infoRef = new InfosReferentielNom(tabReferentiels[i]); |
| referentiels.add(infoRef); |
| } |
| return referentiels; |
| } |
| /** |
| * Accesseur pour l'url de base du serveur jrest |
| * |
| * @return une url de la forme http://emplacement_serveur/jrest |
| */ |
| public static String getServiceBaseUrl() { |
| return serviceBaseUrl; |
| } |
| /** |
| * Accesseur pour l'url de base du suivi de bug |
| * |
| * @return une url pointant vers le suivi des bugs |
| */ |
| public static String getSuiviBugUrl() { |
| return suiviBugUrl; |
| } |
| /** |
| * Accesseur pour l'url de base des images |
| * |
| * @return une url pointant vers la racine du dossier contenant les images |
| */ |
| public static String getImageBaseUrl() { |
| return imageBaseUrl ; |
| } |
| /** |
| * Accesseur pour l'url de base de l'aide |
| * |
| * @return une url pointant vers la racine de l'aide |
| */ |
| public static String getAideBaseUrl() { |
| return aideBaseUrl ; |
| } |
| /** |
| * Accesseur pour l'email de contact du carnet en ligne |
| * |
| * @return une chaine contenant l'email de contact |
| */ |
| public static String getEmailContact() { |
| return emailContact; |
| } |
| /** |
| * Accesseur pour le référentiel geo |
| * |
| * @return le référentiel geo |
| */ |
| public static String getReferentielGeo() { |
| return referentielGeo ; |
| } |
| /** |
| * Accesseur pour la clé google maps |
| * |
| * @return la clé google maps |
| */ |
| public static String getCleGoogleMaps() { |
| return cleGoogleMaps ; |
| } |
| public static String getLienEfloreBaseUrl() { |
| return lienEfloreBaseUrl; |
| } |
| public static String getLicence() { |
| return licence; |
| } |
| public static String getFormatOriginal() { |
| return formatOriginal; |
| } |
| public static String getFormatZoom() { |
| return formatZoom; |
| } |
| public static String getFormatGalerie() { |
| return formatGalerie; |
| } |
| public static String getFormatListe() { |
| return formatListe; |
| } |
| public static boolean utiliseRedirectionImages() { |
| return utiliseRedirectionImage.equals("1"); |
| } |
| public static String getImageRedirectUrl() { |
| return imageRedirectUrl; |
| } |
| public static String getTailleMaxUpload() { |
| return tailleMaxUpload; |
| } |
| public static List<InfosReferentielNom> getReferentielsDispos() { |
| return referentielsDispos; |
| } |
| public static boolean saisieChampsEtendusActivee() { |
| return activerSaisieChampsEtendus.equals("1"); |
| } |
| public static Map<String,HashMap<String, String>> getGroupesChampsEtendus() { |
| return groupesChampsEtendus; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/Utilisateur.java |
|---|
| New file |
| 0,0 → 1,129 |
| package org.tela_botanica.client.modeles.objets; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONString; |
| public class Utilisateur { |
| private String loginUtilisateurConnecte = null; |
| private String loginUtilisateurConsulte = null; |
| private String identifiantUtilisateurConnecte = null; |
| private String identifiantUtilisateurConsulte = null; |
| private boolean identifie = false; |
| private boolean isAdmin = false; |
| private boolean licenceAcceptee = false; |
| private static Utilisateur thisUtilisateur = null; |
| public static Utilisateur InitialiserInstance(JSONObject objetJsonUtilisateur) { |
| thisUtilisateur = new Utilisateur(objetJsonUtilisateur); |
| return thisUtilisateur; |
| } |
| public static Utilisateur getInstance() { |
| return thisUtilisateur; |
| } |
| private Utilisateur(JSONObject objetJsonUtilisateur) { |
| // login utilisateur ou vide si non identifie |
| loginUtilisateurConnecte = ((JSONString) objetJsonUtilisateur.get("courriel")).stringValue(); |
| loginUtilisateurConsulte = loginUtilisateurConnecte; |
| // identifiant utilisateur ou bien identifiant de session si non identifie |
| identifiantUtilisateurConnecte = ((JSONString) objetJsonUtilisateur.get("id_utilisateur")).stringValue(); |
| identifiantUtilisateurConsulte = identifiantUtilisateurConnecte; |
| // Drapeau leve si utilisateur deja identifie |
| identifie = objetJsonUtilisateur.get("connecte").isBoolean().booleanValue(); |
| // Drapeau leve si utilisateur est admin |
| isAdmin = objetJsonUtilisateur.get("admin").isBoolean().booleanValue(); |
| // Drapeau leve si utilisateur a accepte licence |
| licenceAcceptee = objetJsonUtilisateur.get("licence_acceptee").isBoolean().booleanValue(); |
| } |
| /** |
| * Retourne vrai si utilisateur identifie |
| * @return boolean |
| */ |
| public boolean isIdentifie() { |
| return identifie; |
| } |
| /** |
| * Retourne vrai si utilisateur est admin |
| * @return boolean |
| */ |
| public boolean isAdmin() { |
| return isAdmin; |
| } |
| /** |
| * Met à jour l'identité utilisée (dans le cas où l'utilisateur est admin) |
| * @param identite la nouvelle identité |
| */ |
| public void setUtilisateurConsulte(String identifiantUtilisateurConsulte, String loginUtilisateurConsulte) { |
| if(isAdmin()) { |
| this.identifiantUtilisateurConsulte = identifiantUtilisateurConsulte; |
| this.loginUtilisateurConsulte = loginUtilisateurConsulte; |
| } |
| else { |
| this.identifiantUtilisateurConsulte = identifiantUtilisateurConnecte; |
| this.loginUtilisateurConsulte = loginUtilisateurConnecte; |
| } |
| } |
| /** |
| * Retourne l'identifiant de l'utilisateur identifie ou un identifiant de session |
| * @return String identifiantUtilisateurConsulte |
| */ |
| public String getIdentifiantUtilisateurConnecte() { |
| return identifiantUtilisateurConnecte; |
| } |
| /** |
| * Retourne l'identifiant de l'utilisateur consulte |
| * @return String identifiantUtilisateurConsulte |
| */ |
| public String getIdentifiantUtilisateurConsulte() { |
| return identifiantUtilisateurConsulte; |
| } |
| /** |
| * Retourne le login de l'utilisateur identifie ou un identifiant de session |
| * @return String loginUtilisateurConnecte |
| */ |
| public String getLoginUtilisateurConnecte() { |
| return loginUtilisateurConnecte; |
| } |
| /** |
| * Retourne le login de l'utilisateur consulte |
| * @return String loginUtilisateurConsulte |
| */ |
| public String getLoginUtilisateurConsulte() { |
| return loginUtilisateurConsulte; |
| } |
| public void setLicenceAcceptee(boolean licenceAcceptee) { |
| this.licenceAcceptee = licenceAcceptee; |
| } |
| public boolean getLicenceAcceptee() { |
| return licenceAcceptee; |
| } |
| public void setLoginUtilisateurConnecte(String loginUtilisateurConnecte) { |
| this.loginUtilisateurConnecte = loginUtilisateurConnecte; |
| } |
| public void setLoginUtilisateurConsulte(String loginUtilisateurConsulte) { |
| this.loginUtilisateurConsulte = loginUtilisateurConsulte; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/InfosReferentielNom.java |
|---|
| New file |
| 0,0 → 1,66 |
| package org.tela_botanica.client.modeles.objets; |
| public class InfosReferentielNom { |
| private String code = null; |
| private String version = null; |
| private String versionCourte = null; |
| private String intitule = null; |
| public InfosReferentielNom(String infosReferentiel) { |
| String[] codeCompletIntitule = infosReferentiel.split(","); |
| intitule = codeCompletIntitule[1]; |
| String[] codeVersion = codeCompletIntitule[0].split(":"); |
| code = codeVersion[0]; |
| if(codeVersion.length > 1) { |
| version = codeVersion[1]; |
| versionCourte = formaterVersionCourte(version); |
| } else { |
| version = versionCourte = null; |
| } |
| } |
| public InfosReferentielNom(String code, String version, String intitule) { |
| super(); |
| this.code = code; |
| this.version = version; |
| this.intitule = intitule; |
| this.versionCourte = formaterVersionCourte(version); |
| } |
| private String formaterVersionCourte(String version) { |
| return version.replaceAll("v",""); |
| } |
| public String getCodeVersionComplet() { |
| return code+":"+version; |
| } |
| public String getCode() { |
| return code; |
| } |
| public void setCode(String code) { |
| this.code = code; |
| } |
| public String getVersion() { |
| return version; |
| } |
| public void setVersion(String version) { |
| this.version = version; |
| } |
| public String getIntitule() { |
| return intitule; |
| } |
| public void setIntitule(String intitule) { |
| this.intitule = intitule; |
| } |
| public String getVersionCourte() { |
| return versionCourte; |
| } |
| public void setVersionCourte(String versionCourte) { |
| this.versionCourte = versionCourte; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ReferentielNom.java |
|---|
| New file |
| 0,0 → 1,45 |
| package org.tela_botanica.client.modeles.objets; |
| /** |
| * |
| * Classe representant un element du referentiel de nom |
| * |
| */ |
| public class ReferentielNom { |
| private String nom=null; |
| private String numeroNom=null; |
| private String statut=null; |
| public ReferentielNom() { |
| } |
| /** |
| * @param nom |
| * @param numeroNom |
| * @param statut |
| * |
| */ |
| public ReferentielNom(String nom, String numeroNom, String statut) { |
| this.nom = nom; |
| this.numeroNom = numeroNom; |
| this.statut = statut; |
| } |
| public String getNom() { |
| return nom; |
| } |
| public String getNumeroNom() { |
| return numeroNom; |
| } |
| public String getStatut() { |
| return statut; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ListeDate.java |
|---|
| New file |
| 0,0 → 1,59 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.LinkedHashMap; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONString; |
| /** |
| * table de hachage composée d'entite geographique, renvoyé par les objets de type DAO |
| * La clé est le nom de l'entite + le nom de l'entite parente |
| * |
| * @author david delon |
| * |
| */ |
| public class ListeDate extends LinkedHashMap<String, DateObservation> { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 6057292016502553510L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeDate() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeDate(int taille) |
| { |
| super(taille); |
| } |
| public ListeDate(JSONArray dates) |
| { |
| super(dates.size()) ; |
| final int taillemax = dates.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONString dateEncours = dates.get(i).isString() ; |
| if(dateEncours != null) |
| { |
| String dateString = dateEncours.stringValue() ; |
| DateObservation dat = new DateObservation(dateString); |
| this.put(dateString,dat); |
| } |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ListeReferentielPerso.java |
|---|
| New file |
| 0,0 → 1,76 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.HashMap; |
| public class ListeReferentielPerso extends HashMap<String, String> { |
| public static enum TypesReferentiels { |
| REFERENTIEL_LIEU_DIT { |
| @Override |
| public String toString() { |
| return "lieudit"; |
| } |
| }, |
| REFERENTIEL_STATION { |
| @Override |
| public String toString() { |
| return "station"; |
| } |
| }, |
| REFERENTIEL_MILIEU { |
| @Override |
| public String toString() { |
| return "milieu"; |
| } |
| } |
| } |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 2159394354752556196L; |
| private TypesReferentiels typeReferentiel = null; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeReferentielPerso(TypesReferentiels typeReferentiel) |
| { |
| super(); |
| this.typeReferentiel = typeReferentiel; |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeReferentielPerso(int taille,TypesReferentiels typeReferentiel) |
| { |
| super(); |
| this.typeReferentiel = typeReferentiel; |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau de strings |
| */ |
| public ListeReferentielPerso(TypesReferentiels typeReferentiel, String[] nom) |
| { |
| super() ; |
| this.typeReferentiel = typeReferentiel; |
| for (int i = 0; i < nom.length; i++) |
| { |
| if(nom[i] != null && nom[i].equals("00null")) |
| { |
| this.put(i+"",nom[i]); |
| } |
| } |
| } |
| public TypesReferentiels getTypeReferentiel() { |
| return typeReferentiel; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ListeReferentielNom.java |
|---|
| New file |
| 0,0 → 1,52 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.HashMap; |
| /** |
| * table de hachage composée de noms, renvoyé par les objets de type DAO |
| * pour les noms |
| * La clé est l'identifiant du nom dans la base de données, et la valeur un objet |
| * de type ReferentielNom |
| * @author david delon |
| * |
| */ |
| public class ListeReferentielNom extends HashMap<String, ReferentielNom> { |
| private static final long serialVersionUID = 3214510270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeReferentielNom() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeReferentielNom(int taille) |
| { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau d'ImageCarnet |
| */ |
| public ListeReferentielNom(ReferentielNom[] nom) |
| { |
| super() ; |
| for (int i = 0; i < nom.length; i++) |
| { |
| if(nom[i] != null && nom[i] instanceof ReferentielNom) |
| { |
| this.put(nom[i].getNumeroNom(),nom[i]); |
| } |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ImageCarnet.java |
|---|
| New file |
| 0,0 → 1,457 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.tela_botanica.client.i18n.VocabulaireMetadonnees; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.xml.client.Document; |
| import com.google.gwt.xml.client.Node; |
| import com.google.gwt.xml.client.NodeList; |
| import com.google.gwt.xml.client.Text; |
| import com.google.gwt.xml.client.XMLParser; |
| import com.google.gwt.xml.client.impl.DOMParseException; |
| /** |
| * |
| * Classe representant une image du carnet, elle ne contient pas d'image à |
| * proprement parler mais plutôt les informations associées ainsi que l'url |
| * distante. C'est une table de hachage qui contient des paires propriété/valeur |
| * |
| */ |
| public class ImageCarnet extends HashMap<String, String> { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = -6220175386957259859L; |
| /** |
| * Constructeur avec un objet JSON |
| * |
| * @param image |
| */ |
| public ImageCarnet(JSONObject image) { |
| // l'objet JSON est une table de hachage |
| Set<String> im = image.keySet(); |
| // on la parcourt pour chaque clé |
| for (Iterator<String> iterator = im.iterator(); iterator.hasNext();) { |
| // si elle est associée à une valeur, on l'ajoute |
| String key = iterator.next(); |
| if (Util.jsonNonNull(image, key)) { |
| String valeur = image.get(key).isString().stringValue(); |
| this.put(key, valeur); |
| } else { |
| // sinon on ajoute la clé avec une valeur vide |
| String valeur = " "; |
| this.put(key, valeur); |
| } |
| } |
| } |
| public ImageCarnet(String[][] image) { |
| for (int i = 0; i < image.length; i++) { |
| if (image[i][0] != null && image[i][1] != null) { |
| this.put(image[i][0], image[i][1]); |
| } |
| } |
| } |
| /** |
| * Surcharge de toString qui affiche toutes les propriétés de l'image |
| */ |
| @Override |
| public String toString() { |
| String valeur = " "; |
| for (Iterator<String> iterator = this.keySet().iterator(); iterator |
| .hasNext();) { |
| String key = iterator.next(); |
| if (this.get(key) != null) { |
| valeur += "cle : " + key + " valeur :" + this.get(key) + "\n"; |
| } |
| } |
| return valeur; |
| } |
| /** |
| * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par |
| * cette fonction qui retire les charactères nuls qui font planter |
| * l'affichage, il ne faut pas utiliser get directement |
| * |
| * @param cle |
| * @return la valeur associée à la clé |
| */ |
| public String renvoyerValeurCorrecte(String cle) { |
| if (this.containsKey((cle))) { |
| String valeur = this.get(cle); |
| if (valeur.equals("null") || valeur == null) { |
| return " "; |
| } else { |
| char nullChar = '\u0000'; |
| String sNull = "" + nullChar; |
| valeur = valeur.replaceAll(sNull, ""); |
| return valeur; |
| } |
| } else { |
| return " "; |
| } |
| } |
| /** |
| * Acesseur pour l'id de l'image |
| * |
| * @return l'id de l'image |
| */ |
| public String getId() { |
| return renvoyerValeurCorrecte("id_image"); |
| } |
| /** |
| * Acesseur pour le numero d'ordre de l'image |
| * |
| * @return l'ordre de l'image |
| */ |
| public String getOrdre() { |
| return renvoyerValeurCorrecte("ordre"); |
| } |
| /** |
| * Base de l'url serveur pour les images |
| * |
| * @return url racine pour les images |
| */ |
| public String getVraieBaseUrl() { |
| return Configuration.getImageBaseUrl() ; |
| } |
| /** |
| * Base de l'url serveur pour les images |
| * |
| * @return url racine pour les images |
| */ |
| public String getBaseUrlRedirect() { |
| return Configuration.getImageRedirectUrl() ; |
| } |
| public String getIdAvecPadding() { |
| String id = getId(); |
| int maxZeros = 9 - id.length(); |
| for (int i = 0; i < maxZeros; i++) { |
| id = "0" + id; |
| } |
| return id; |
| } |
| private String getUrlFormat(String format) { |
| String urlImage = ""; |
| if(Configuration.utiliseRedirectionImages()) { |
| String identifiantRedirect = getIdAvecPadding()+format; |
| urlImage = getBaseUrlRedirect()+identifiantRedirect; |
| } else { |
| urlImage = getVraieUrlFormat(format); |
| } |
| return urlImage; |
| } |
| /** |
| * Renvoie le nom de base du fichier image et ses sous dossier |
| * |
| * @return le nom de base du fichier de type (XXX_XXX_XXX), et ses sous |
| * dossier |
| */ |
| public String[] getVraiCheminBaseFichier() { |
| String id = getIdAvecPadding(); |
| String dossierNv1 = id.substring(0, 3); |
| String dossierNv2 = id.substring(3, 6); |
| String fichierNv = id.substring(6, 9); |
| String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv; |
| String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 }; |
| return infosFichier; |
| } |
| private String getVraieUrlFormat(String format) { |
| String[] infosFichier = getVraiCheminBaseFichier(); |
| return getVraieBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/"+format+"/" |
| + infosFichier[0] + "_"+format+".jpg"; |
| } |
| /** |
| * Renvoie le chemin et nom du fichier format original |
| * |
| * @return le chemin du fichier grand original |
| */ |
| public String getUrlFormatOriginal() { |
| return getUrlFormat(Configuration.getFormatOriginal()); |
| } |
| /** |
| * Renvoie le chemin et nom du fichier grand format |
| * |
| * @return le chemin du fichier grand format |
| */ |
| public String getUrlFormatZoom() { |
| return getUrlFormat(Configuration.getFormatZoom()); |
| } |
| /** |
| * Renvoie le chemin et nom du fichier petit format |
| * |
| * @return le chemin du fichier petit format |
| */ |
| public String getUrlFormatGalerie() { |
| return getUrlFormat(Configuration.getFormatGalerie()); |
| } |
| /** |
| * Renvoie le chemin et nom du fichier moyen format |
| * |
| * @return le chemin du fichier moyen format |
| */ |
| public String getUrlFormatListe() { |
| return getUrlFormat(Configuration.getFormatListe()); |
| } |
| /** |
| * Renvoie la taille de l'image |
| * |
| * @return un tableau de deux string contenant la hauteur puis la largeur |
| */ |
| public String[] getTailleImage() { |
| String[] XY = { renvoyerValeurCorrecte("hauteur"), |
| renvoyerValeurCorrecte("largeur") }; |
| return XY; |
| } |
| public String[] getNote() { |
| String[] note = { renvoyerValeurCorrecte("note_qualite") }; |
| return note; |
| } |
| /** |
| * Renvoie la date exif associée à l'image |
| * |
| * @return la date associée à l'image |
| */ |
| public String getDate() { |
| if(renvoyerValeurCorrecte("date_prise_de_vue").equals("00/00/0000")) |
| { |
| return "" ; |
| } |
| return renvoyerValeurCorrecte("date_prise_de_vue"); |
| } |
| /** |
| * Renvoie la ville associée à l'image |
| * |
| * @return la ville iptc |
| */ |
| public Object getIptcCity() { |
| return renvoyerValeurCorrecte(""); |
| } |
| /** |
| * Renvoie le fabricant de l'appareil |
| * |
| * @return le fabricant |
| */ |
| public String getFabriquantAppareil() { |
| return renvoyerValeurCorrecte("appareil_fabricant"); |
| } |
| /** |
| * Renvoie le modele de l'appareil |
| * |
| * @return le modele |
| */ |
| public String getModeleAppareil() { |
| return renvoyerValeurCorrecte("appareil_modele"); |
| } |
| /** |
| * Renvoie un tableau nom / valeur de toutes les metadonnées Iptc |
| * |
| * @return les métadonnées iptc |
| */ |
| public String[][] getMetadonnesIptc() { |
| return getMetadonneesXml("meta_iptc"); |
| } |
| /** |
| * Renvoie un tableau nom / valeur de toutes les metadonnées Exif |
| * |
| * @return les métadonnées Exif |
| */ |
| public String[][] getMetadonnesExif() { |
| return getMetadonneesXml("meta_exif"); |
| } |
| private String[][] getMetadonneesXml(String type) { |
| String[][] metadonnees = {{},{}}; |
| String xml = renvoyerValeurCorrecte(type); |
| String invalidXmlPattern = "[^" |
| + "\\u0009\\u000A\\u000D" |
| + "\\u0020-\\uD7FF" |
| + "\\uE000-\\uFFFD" |
| + "\\u10000-\\u10FFFF" |
| + "]+"; |
| xml = xml.replaceAll(invalidXmlPattern, " "); |
| try { |
| Document d = XMLParser.parse(xml); |
| if(d.hasChildNodes()) { |
| NodeList attributs = d.getFirstChild().getChildNodes(); |
| int taille = attributs.getLength(); |
| metadonnees = new String[taille][2]; |
| for(int i = 0; i < taille; i++) { |
| if(attributs.item(i) != null) { |
| XMLParser.removeWhitespace(attributs.item(i)); |
| attributs.item(i).normalize(); |
| String nomMetaDonneestraduite = VocabulaireMetadonnees.getTraduction(attributs.item(i).getNodeName()); |
| metadonnees[i][0] = nomMetaDonneestraduite; |
| if(attributs.item(i).hasChildNodes()) { |
| Node valeur = attributs.item(i).getFirstChild(); |
| if(valeur.getNodeType() == Node.TEXT_NODE) { |
| metadonnees[i][1] = ((Text)valeur).getData(); |
| } else { |
| metadonnees[i][1] = ""; |
| } |
| } |
| } |
| } |
| } |
| } catch(DOMParseException e) { |
| } |
| return metadonnees; |
| } |
| /** |
| * Renvoie un tableau nom / valeur contenant les infos générales |
| * |
| * @return les infos générales |
| */ |
| public String[][] getInfoGenerales() { |
| String[][] metaGen = new String[2][2]; |
| metaGen[0][0] = "commentaire"; |
| metaGen[0][1] = this.renvoyerValeurCorrecte("commentaire"); |
| metaGen[1][0] = "date_prise_de_vue"; |
| metaGen[1][1] = this.renvoyerValeurCorrecte("date_prise_de_vue"); |
| return metaGen; |
| } |
| /** |
| * Renvoie une string contenant les mots clés séparés par des ',' |
| * |
| * @return les mots clés |
| */ |
| public String getMotsCles() { |
| return renvoyerValeurCorrecte("mots_cles"); |
| } |
| /** |
| * Met à jour le commenentaire et la date |
| * |
| * @param commentaires |
| * le nouveau commentaire |
| * @param date |
| * la nouvelle date |
| */ |
| public void miseAJourInfoGenerales(String commentaires, String date, |
| String note) { |
| put("commentaire", commentaires); |
| put("note_qualite", note); |
| put("date_prise_de_vue", date); |
| } |
| /** |
| * Met à jour les mots clés |
| * |
| * @param motsClesEnCours |
| * la liste de mots clés séparés par des ',' |
| */ |
| public void mettreAjourMotsCles(String motsClesEnCours) { |
| put("mots_cles", motsClesEnCours); |
| } |
| public void mettreAjourObsAssociees(String idsObsAssociees) { |
| put("id_observation", idsObsAssociees); |
| } |
| /** |
| * Accesseur pour le nom original |
| * |
| * @return le nom orginal de l'image |
| */ |
| public String getNomOriginal() { |
| return renvoyerValeurCorrecte("nom_original"); |
| } |
| public String getIdsObsAssociees() { |
| String observationsAssociees = renvoyerValeurCorrecte("id_observation"); |
| observationsAssociees = observationsAssociees.replaceAll("null", ""); |
| return observationsAssociees; |
| } |
| public String[][] obtenirChampsModifiablesImage() { |
| String[][] champs = { |
| {"commentaire", renvoyerValeurCorrecte("commentaire")}, |
| {"note_qualite", renvoyerValeurCorrecte("note_qualite")}, |
| {"date_prise_de_vue",renvoyerValeurCorrecte("date_prise_de_vue")} |
| }; |
| return champs; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ListeImageCarnet.java |
|---|
| New file |
| 0,0 → 1,54 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.HashMap; |
| /** |
| * table de hachage composée d'ImageCarnet, renvoyé par les objets de type DAO |
| * pour les images. La clé est l'identifiant de l'image dans la base de données, |
| * et la valeur un objet de type ImageCarnet. GWT ne supporte pas encore les |
| * type paramètres mais quand il le fera il faudra créer la HashMap avec |
| * <String,ImageCarnet> |
| * |
| * @author aurelien |
| * |
| */ |
| public class ListeImageCarnet extends HashMap<String, ImageCarnet> { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 2715320270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeImageCarnet() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param taille |
| * la taille de la table de hachage |
| */ |
| public ListeImageCarnet(int taille) { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param ic |
| * un tableau d'ImageCarnet |
| */ |
| public ListeImageCarnet(ImageCarnet[] ic) { |
| super(); |
| for (int i = 0; i < ic.length; i++) { |
| if (ic[i] != null && ic[i] instanceof ImageCarnet) { |
| this.put(ic[i].getOrdre(), ic[i]); |
| } |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/Ontologies.java |
|---|
| New file |
| 0,0 → 1,126 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import com.gwtext.client.data.SimpleStore; |
| import com.gwtext.client.data.Store; |
| public class Ontologies { |
| //TODO: extraire toutes ces valeurs dans des fichiers de configuration |
| // ou bien via l'appel d'un web service spécialisé. |
| private static HashMap<String, String> valeursCertitude = null; |
| private static List<InfosReferentielNom> listeReferentielsNoms = null; |
| public static Store getValeursCertitude() { |
| Object[][] valeurs = {{"Certaine","certain"}, |
| {"Douteuse","douteux"}, |
| {"A déterminer","aDeterminer"} |
| }; |
| SimpleStore storeCertitude = new SimpleStore(new String[] {"label","valeur"},valeurs); |
| storeCertitude.load(); |
| return storeCertitude; |
| } |
| public static Store getValeursAbondance() { |
| Object[][] valeurs = { |
| {"5 : recouvrement R > 75%","5"}, |
| {"4 : 50% < R < 75%","4"}, |
| {"3 : 25% < R < 50%","3"}, |
| {"2 : 5% < R < 25%","2"}, |
| {"1 : 1% < R < 5%","1"}, |
| {"+ : recouvrement R < 1%","+"}, |
| {"r : rare (quelques pieds)","r"}, |
| {"i : un seul individu","i"}, |
| {"1-5 individus","1-5"}, |
| {"5-10 individus","5-10"}, |
| {"10-50 individus","10-50"}, |
| {"50-100 individus","50-100"}, |
| {"100-500 individus","100-500"}, |
| {">500 individus",">500"}, |
| {"E : exceptionnel","E"}, |
| {"RR : très rare","RR"}, |
| {"R : rare","R"}, |
| {"AR : assez rare","AR"}, |
| {"PC : peu commun","PC"}, |
| {"AC : assez commun","AC"}, |
| {"C : commun","C"}, |
| {"CC : très commun","CC"} |
| }; |
| SimpleStore storeAbondance = new SimpleStore(new String[] {"label","valeur"},valeurs); |
| storeAbondance.load(); |
| return storeAbondance; |
| } |
| public static String getCorrespondanceCertitude(String cle) { |
| if(valeursCertitude == null) { |
| valeursCertitude = new HashMap<String, String>(); |
| valeursCertitude.put("certain", "Certaine"); |
| valeursCertitude.put("douteux", "Douteuse"); |
| valeursCertitude.put("aDeterminer", "A déterminer"); |
| } |
| String valeur = valeursCertitude.get(cle); |
| return valeur == null ? cle : valeur; |
| } |
| public static Store getValeursReferentiel() { |
| List<InfosReferentielNom> listeReferentiels = Configuration.getReferentielsDispos(); |
| Object[][] valeurs = new Object[listeReferentiels.size()][2]; |
| int i = 0; |
| for (Iterator<InfosReferentielNom> iterator = listeReferentiels.iterator(); iterator |
| .hasNext();) { |
| InfosReferentielNom infosReferentielNom = iterator.next(); |
| String[] valeur = {infosReferentielNom.getIntitule(), infosReferentielNom.getCode()}; |
| valeurs[i] = valeur; |
| i++; |
| } |
| SimpleStore storeReferentiels = new SimpleStore(new String[] {"label","valeur"},valeurs); |
| storeReferentiels.load(); |
| return storeReferentiels; |
| } |
| public static InfosReferentielNom getInfosReferentielNomParCode(String code) { |
| InfosReferentielNom infos = null; |
| List<InfosReferentielNom> listeReferentiels = Configuration.getReferentielsDispos(); |
| for (Iterator<InfosReferentielNom> iterator = listeReferentiels.iterator(); iterator |
| .hasNext();) { |
| InfosReferentielNom infosReferentielNom = iterator.next(); |
| if(infosReferentielNom.getCode().equals(code)) { |
| infos = infosReferentielNom; |
| break; |
| } |
| } |
| return infos; |
| } |
| public static Store getValeursPhenologie() { |
| Object[][] valeurs = { |
| {"00-09: germination, développement des bourgeons", "00-09"}, |
| {"10-19: développement des feuilles", "10-19"}, |
| {"11: par ex, environ 10% des feuilles épanouies", "11"}, |
| {"15: par ex, environ 50% des feuilles épanouies", "15"}, |
| {"20-29: formation de pousses latérales, tallage", "20-29"}, |
| {"30-39: développement des tiges, croissance des rosettes", "30-39"}, |
| {"40-49: développement des organes de propagation végétative", "40-49"}, |
| {"50-59: apparition de l'inflorescence, épiaison", "50-59"}, |
| {"60-69: floraison", "60-69"}, |
| {"61 : par ex, environ 10% des fleurs épanouies", "61"}, |
| {"65 : par ex, environ 50% des fleurs épanouies", "65"}, |
| {"70-79: fructification", "70-79"}, |
| {"80-89: maturité des fruits et des graines", "80-89"}, |
| {"85: par ex, 50% des fruits matures", "85"}, |
| {"90-99: sénescence et dormance", "90-99"}, |
| {"91: par ex, environ 10% des feuilles jaunes", "91"}, |
| {"95: par ex, environ 50% des feuilles jaunes", "95"} |
| }; |
| SimpleStore storeAbondance = new SimpleStore(new String[] {"label","valeur"},valeurs); |
| storeAbondance.load(); |
| return storeAbondance; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ReferentielCommune.java |
|---|
| New file |
| 0,0 → 1,48 |
| package org.tela_botanica.client.modeles.objets; |
| /** |
| * |
| * Classe representant un element du referentiel commune ou localite |
| * |
| */ |
| public class ReferentielCommune { |
| private String commune=null; |
| private String departement=null; |
| private String codeInsee=null; |
| public ReferentielCommune() { |
| } |
| /** |
| * @param commune |
| * @param departement |
| */ |
| public ReferentielCommune(String commune, String code) { |
| this.commune = commune; |
| if(code.length() == 5) { |
| codeInsee = code; |
| departement = code.substring(0,2); |
| } else { |
| departement = code; |
| } |
| } |
| public String getCommune() { |
| return commune; |
| } |
| public String getDepartement() { |
| return departement; |
| } |
| public String getCodeInsee() { |
| return codeInsee; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/DateObservation.java |
|---|
| New file |
| 0,0 → 1,43 |
| package org.tela_botanica.client.modeles.objets; |
| /** |
| * |
| * Classe representant une entite geographique (localite, commune, lieu dit) presente dans la liste des observations |
| * |
| */ |
| public class DateObservation { |
| private String annee=null; |
| private String mois=null; |
| private String jour=null; |
| /** |
| * @param commune |
| * @param departement |
| */ |
| public DateObservation(String date) { |
| String dateTab[] = date.split(" ") ; |
| String dateSpl[] = dateTab[0].split("-") ; |
| annee= dateSpl[0]; |
| mois= dateSpl[1]; |
| jour= dateSpl[2]; |
| } |
| public String getAnnee() { |
| return annee; |
| } |
| public String getMois() { |
| return mois; |
| } |
| public String getJour() { |
| return jour; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ListeReferentielCommune.java |
|---|
| New file |
| 0,0 → 1,53 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.HashMap; |
| /** |
| * table de hachage composée de communes, renvoyé par les objets de type DAO |
| * pour les communes |
| * TODO : utiliser un identifiant commune |
| * La clé est le nom de la commune + l'identifiant du departement de la commune dans la base de données, et la valeur un objet |
| * de type ReferentielCommune |
| * @author david delon |
| * |
| */ |
| public class ListeReferentielCommune extends HashMap<String, ReferentielCommune> { |
| private static final long serialVersionUID = 2714510270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeReferentielCommune() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeReferentielCommune(int taille) |
| { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau d'ImageCarnet |
| */ |
| public ListeReferentielCommune(ReferentielCommune[] com) |
| { |
| super() ; |
| for (int i = 0; i < com.length; i++) |
| { |
| if(com[i] != null && com[i] instanceof ReferentielCommune) |
| { |
| this.put(com[i].getCommune()+com[i].getDepartement(),com[i]); |
| } |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/Observation.java |
|---|
| New file |
| 0,0 → 1,387 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.Map; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.json.client.JSONObject; |
| public class Observation { |
| private String id=null; |
| private String transmis=null; |
| private String nomSaisi=null; |
| private String nomRetenu=null; |
| private String numeroNomenclaturalSaisi=null; |
| private String numeroNomenclaturalRetenu=null; |
| private String numeroTaxonomique=null; |
| private String famille=null; |
| private String localite=null; |
| private String identifiantLocalite=null; |
| private String lieudit=null; |
| private String station=null; |
| private String milieu=null; |
| private String commentaire=null; |
| private String date=null; |
| private String numeroOrdre=null; |
| private String motsCles=null; |
| private String latitude=null; |
| private String longitude=null; |
| private String referentielGeo=null; |
| private String referentielTaxo=null; |
| private String abondance=null; |
| private String certitude=null; |
| private String phenologie=null; |
| private String altitude=null; |
| private Map<String, ChampEtendu> champsEtendus=null; |
| public Observation() { |
| } |
| /** |
| * Une observation telle que stockee dans la base de donnee |
| * |
| * @param transmis |
| * @param nomSaisi |
| * @param nomRetenu |
| * @param numeroNomenclaturalSaisi |
| * @param numeroNomenclaturalRetenu |
| * @param numeroTaxonomique |
| * @param famille |
| * @param localite |
| * @param IdentifiantLocalite |
| * @param lieudit |
| * @param station |
| * @param milieu |
| * @param commentaire |
| * @param date |
| * @param numeroOrdre |
| */ |
| public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclaturalSaisi, String numeroNomenclaturalRetenu, String numeroTaxonomique, String famille, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre) { |
| this.transmis = transmis; |
| this.nomSaisi = nomSaisi; |
| this.nomRetenu = nomRetenu; |
| this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi; |
| this.numeroNomenclaturalRetenu = numeroNomenclaturalRetenu; |
| this.numeroTaxonomique = numeroTaxonomique; |
| this.famille = famille; |
| this.identifiantLocalite = identifiantLocalite; |
| this.lieudit = lieudit; |
| this.station = station; |
| this.milieu = milieu; |
| this.commentaire = commentaire; |
| this.date = date; |
| this.numeroOrdre = numeroOrdre; |
| // Suppresion indication departementale (on pourrait faire mieux !!) |
| if(localite != null) { |
| int pos=localite.indexOf(" (" ); |
| if (pos>=0) { |
| this.localite=localite.substring(0,pos); |
| } |
| else { |
| this.localite=localite; |
| } |
| } |
| this.motsCles = ""; |
| } |
| public Observation(JSONObject observation) { |
| this.transmis = Util.getValeurJsonOuVide(observation, "transmission"); |
| this.identifiantLocalite = Util.getValeurJsonOuVide(observation, "ce_zone_geo"); |
| this.nomSaisi = Util.getValeurJsonOuVide(observation, "nom_sel"); |
| this.nomRetenu = (Util.getValeurJsonOuVide(observation,"nom_ret")); |
| this.numeroNomenclaturalSaisi = Util.getValeurJsonOuVide(observation,"nom_sel_nn"); |
| this.numeroNomenclaturalRetenu = Util.getValeurJsonOuVide(observation,"nom_ret_nn"); |
| this.numeroTaxonomique= Util.getValeurJsonOuVide(observation,"nt"); |
| this.famille = Util.getValeurJsonOuVide(observation,"famille"); |
| this.localite = Util.getValeurJsonOuVide(observation,"zone_geo"); |
| this.lieudit = Util.getValeurJsonOuVide(observation,"lieudit"); |
| this.station= Util.getValeurJsonOuVide(observation,"station"); |
| this.milieu = Util.getValeurJsonOuVide(observation,"milieu"); |
| this.commentaire = Util.getValeurJsonOuVide(observation,"commentaire"); |
| this.date = Util.getValeurJsonOuVide(observation,"date_observation"); |
| this.numeroOrdre = Util.getValeurJsonOuVide(observation,"ordre"); |
| this.id = Util.getValeurJsonOuVide(observation,"id_observation"); |
| this.latitude = Util.getValeurJsonOuVide(observation,"latitude"); |
| this.longitude = Util.getValeurJsonOuVide(observation,"longitude"); |
| this.altitude = Util.getValeurJsonOuVide(observation,"altitude"); |
| this.motsCles = Util.getValeurJsonOuVide(observation,"mots_cles"); |
| this.abondance = Util.getValeurJsonOuVide(observation,"abondance"); |
| this.certitude = Util.getValeurJsonOuVide(observation,"certitude"); |
| this.phenologie = Util.getValeurJsonOuVide(observation,"phenologie"); |
| this.setReferentielTaxo(Util.getValeurJsonOuVide(observation,"nom_referentiel")); |
| this.setChampsEtendus(Util.getMapValeursOuVide(observation, "obs_etendue")); |
| } |
| /** |
| * Une observation saisie ou modifiee |
| * |
| * @param nomSaisi |
| * @param numeroNomenclaturalSaisi |
| * @param localite |
| * @param IdentifiantLocalite |
| * @param lieudit |
| * @param station |
| * @param milieu |
| * @param commentaire |
| * @param date |
| * |
| */ |
| public Observation(String nomSaisi, String numeroNomenclaturalSaisi, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date) { |
| this.nomSaisi = nomSaisi; |
| this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi; |
| this.identifiantLocalite = identifiantLocalite; |
| this.lieudit = lieudit; |
| this.station = station; |
| this.milieu = milieu; |
| this.commentaire = commentaire; |
| this.date = date; |
| // Suppresion indication departementale (on pourrait faire mieux !!) |
| if(localite != null) { |
| int pos=localite.indexOf(" (" ); |
| if (pos>=0) { |
| this.localite=localite.substring(0,pos); |
| } |
| else { |
| this.localite=localite; |
| } |
| } |
| this.motsCles = "" ; |
| } |
| public String getNomSaisi() { |
| return nomSaisi; |
| } |
| public String getNumeroOrdre() { |
| return numeroOrdre; |
| } |
| public String getCommentaire() { |
| return commentaire; |
| } |
| public String getDate() { |
| return date; |
| } |
| public String getFamille() { |
| return famille; |
| } |
| public String getLieudit() { |
| return lieudit; |
| } |
| public String getLocalite() { |
| return localite; |
| } |
| public String getIdentifiantLocalite() { |
| if(identifiantLocalite != null) { |
| identifiantLocalite = identifiantLocalite.replaceAll("\"", ""); |
| } |
| return identifiantLocalite; |
| } |
| public String getMilieu() { |
| return milieu; |
| } |
| public String getNomRetenu() { |
| return nomRetenu; |
| } |
| public String getNumeroNomenclaturalSaisi() { |
| return numeroNomenclaturalSaisi; |
| } |
| public String getNumeroNomenclaturalRetenu() { |
| return numeroNomenclaturalRetenu; |
| } |
| public String getNumeroTaxonomique() { |
| return numeroTaxonomique; |
| } |
| public void setNomRetenu(String nomRetenu) { |
| this.nomRetenu = nomRetenu; |
| } |
| public void setNumeroNomenclaturalSaisi(String numeroNomenclaturalSaisi) { |
| this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi; |
| } |
| public void setNumeroNomenclaturalRetenu(String numeroNomenclaturalRetenu) { |
| this.numeroNomenclaturalRetenu = numeroNomenclaturalRetenu; |
| } |
| public void setNumeroTaxonomique(String numeroTaxonomique) { |
| this.numeroTaxonomique = numeroTaxonomique; |
| } |
| public String getStation() { |
| return station; |
| } |
| public String getTransmis() { |
| return transmis; |
| } |
| public String getMotsCles() { |
| return motsCles; |
| } |
| public String getLatitude() { |
| return this.latitude ; |
| } |
| public String getLongitude() { |
| return this.longitude ; |
| } |
| public String getReferentielGeo() { |
| return this.referentielGeo ; |
| } |
| public String getId() { |
| return this.id; |
| } |
| public String getAbondance() { |
| return this.abondance; |
| } |
| public String getCertitude() { |
| return this.certitude; |
| } |
| public void setMotsCles(String motsCles) { |
| this.motsCles = motsCles; |
| } |
| public void setNumeroOrdre(String numeroOrdre) { |
| this.numeroOrdre = numeroOrdre; |
| } |
| public void setLatitude(String latitude) { |
| this.latitude = latitude; |
| } |
| public void setLongitude(String longitude) { |
| this.longitude = longitude; |
| } |
| public void setReferentielGeo(String refGeo) { |
| this.referentielGeo = refGeo; |
| } |
| public void setId(String id) { |
| this.id = id; |
| } |
| public void setAbondance(String abondance) { |
| this.abondance = abondance; |
| } |
| public void setCertitude(String certitude) { |
| this.certitude = certitude; |
| } |
| public String getReferentielTaxo() { |
| return referentielTaxo; |
| } |
| public String getCodeCourtReferentielTaxo() { |
| String codeRef = ""; |
| if(!getReferentielTaxo().equals("") && getReferentielTaxo().length() >= 5) { |
| codeRef = referentielTaxo.substring(0, 5); |
| } |
| return codeRef; |
| } |
| public void setReferentielTaxo(String referentielTaxo) { |
| this.referentielTaxo = referentielTaxo; |
| } |
| public String getPhenologie() { |
| return phenologie; |
| } |
| public void setPhenologie(String phenologie) { |
| this.phenologie = phenologie; |
| } |
| public String getAltitude() { |
| return altitude; |
| } |
| public void setAltitude(String altitude) { |
| this.altitude = altitude; |
| } |
| public void setValeurChampEtendu(String cle, String valeur, String label) { |
| ChampEtendu champ = new ChampEtendu(cle, label, valeur); |
| champsEtendus.put(cle, champ); |
| } |
| public ChampEtendu getChampEtendu(String cle) { |
| ChampEtendu champ = null; |
| if(champsEtendus.containsKey(cle)) { |
| champ = champsEtendus.get(cle); |
| } |
| return champ; |
| } |
| public String getLabelChampEtendu(String cle) { |
| String valeur = ""; |
| if(champsEtendus.containsKey(cle)) { |
| valeur = champsEtendus.get(cle).getLabel(); |
| } |
| return valeur; |
| } |
| public String getValeurChampEtendu(String cle) { |
| String valeur = ""; |
| if(champsEtendus.containsKey(cle)) { |
| valeur = champsEtendus.get(cle).getValeur(); |
| } |
| return valeur; |
| } |
| public Map<String, ChampEtendu> getChampsEtendus() { |
| return champsEtendus; |
| } |
| public void setChampsEtendus(Map<String, ChampEtendu> champsEtendus) { |
| this.champsEtendus = champsEtendus; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ListeObservation.java |
|---|
| New file |
| 0,0 → 1,60 |
| package org.tela_botanica.client.modeles.objets; |
| import java.util.LinkedHashMap; |
| /** |
| * table de hachage composée d'observation, renvoyé par les objets de type DAO |
| * pour les images. La clé est l'identifiant de l'observation dans la base de |
| * données, et la valeur un objet de type Observation |
| * |
| * L'uitilisation de LinkedHashMap permet de conserver l'ordre d'insertion des |
| * elements à la lecture |
| * |
| * @author david delon |
| * |
| */ |
| public class ListeObservation extends LinkedHashMap<String, Observation> { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 2715320270773281540L; |
| /* |
| * Constructeur sans paramètres |
| */ |
| public ListeObservation() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param taille |
| * la taille de la table de hachage |
| */ |
| public ListeObservation(int taille) { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param ic |
| * un tableau d'ImageCarnet |
| */ |
| public ListeObservation(Observation[] obs) { |
| super(); |
| for (int i = 0; i < obs.length; i++) { |
| if (obs[i] != null && obs[i] instanceof Observation) { |
| this.put(obs[i].getNumeroOrdre(), obs[i]); |
| } |
| } |
| } |
| public void ajouterObservation(Observation obs) { |
| if (obs != null) { |
| this.put(obs.getNumeroOrdre(), obs); |
| } |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/modeles/objets/ChampEtendu.java |
|---|
| New file |
| 0,0 → 1,42 |
| package org.tela_botanica.client.modeles.objets; |
| public class ChampEtendu { |
| private String cle; |
| private String label; |
| private String valeur; |
| public ChampEtendu() { |
| } |
| public ChampEtendu(String cle, String label, String valeur) { |
| this.setCle(cle); |
| this.setLabel(label); |
| this.setValeur(valeur); |
| } |
| public String getCle() { |
| return cle; |
| } |
| public void setCle(String cle) { |
| this.cle = cle; |
| } |
| public String getLabel() { |
| return label; |
| } |
| public void setLabel(String label) { |
| this.label = label; |
| } |
| public String getValeur() { |
| return valeur; |
| } |
| public void setValeur(String valeur) { |
| this.valeur = valeur; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/observation/ObservationMediateur.java |
|---|
| New file |
| 0,0 → 1,1246 |
| package org.tela_botanica.client.observation; |
| // TODO : systematiser les onQuelquechose, appelle depuis les vues |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.InfosReferentielNom; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import org.tela_botanica.client.vues.observation.CartographieObservationVue; |
| import org.tela_botanica.client.vues.observation.FormulaireImportObservationVue; |
| import org.tela_botanica.client.vues.observation.FormulaireSaisieObservationVue; |
| import org.tela_botanica.client.vues.observation.ListeObservationVue; |
| import org.tela_botanica.client.vues.observation.MenuObservationVue; |
| import org.tela_botanica.client.vues.observation.PanneauFiltresObservationVues; |
| import org.tela_botanica.client.vues.observation.indicateurs.ImageGeneriqueVue; |
| import org.tela_botanica.client.vues.observation.indicateurs.InformationRepartitionVue; |
| import org.tela_botanica.client.vues.observation.indicateurs.LienExterneVue; |
| import org.tela_botanica.client.vues.observation.indicateurs.MiniZoomImageVue; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.user.client.History; |
| import com.google.gwt.user.client.Window; |
| 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.data.Record; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| 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; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| /** |
| * Mediateur gérant les interactions entre vues et les echanges de données |
| * C'est un singleton. |
| * @author aurelien |
| * |
| */ |
| public class ObservationMediateur { |
| /** |
| * booleen qui verifie l'unicite de l'instance (donc static) |
| */ |
| private static boolean estInstancie = false ; |
| /** |
| * pointeur sur le médiateur (pour le pattern singleton) |
| */ |
| private static ObservationMediateur thisMediateur = null ; |
| /** Mediateur general de l'application carnet en ligne |
| * |
| * |
| */ |
| private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
| /** |
| * modele de données |
| */ |
| private ObservationModele observationModele = null ; |
| /** |
| * panneau principal des Observation (onglet "observation") |
| */ |
| private final Panel panneauPrincipalObservation = new Panel("Observations"); |
| /** |
| * liste détaillée des Observations |
| */ |
| public ListeObservationVue listeObservation = null ; |
| /** |
| * Saisie des Observations |
| */ |
| private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null; |
| /** |
| * |
| * Import des observations depuis un fichier |
| * |
| */ |
| private FormulaireImportObservationVue formImportObs=null; |
| /** |
| * Cartographie |
| */ |
| private CartographieObservationVue cartoObservationVue = null; |
| /** |
| * booleen explicitant s'il y a une selection en cours |
| */ |
| private boolean selection = false ; |
| /** |
| * panneau conteneur pour le panneau des informations lies à l'observation |
| */ |
| private Panel details = new Panel("Details"); |
| private LienExterneVue liExtVue = null; |
| /** |
| * panneau conteneur pour le panneau des filtres |
| */ |
| private PanneauFiltresObservationVues filtres = null; |
| /** |
| * panneau d'information de repartition sur le nom selectionné |
| * |
| */ |
| private InformationRepartitionVue informationRepartitionVue=null; |
| /** |
| * panneau d'affichage d'une image generique associe au nom selectionne |
| * |
| */ |
| private ImageGeneriqueVue imageGeneriqueVue=null; |
| private MiniZoomImageVue mvz = null ; |
| private boolean importerObservations = false ; |
| private com.gwtext.client.widgets.Window fenetreCarto; |
| public boolean changementTabProg = false; |
| private InfosReferentielNom refTaxSelectionne = null; |
| private Panel centre; |
| /** |
| * constructeur privé (on accède a la classe par la méthode getInstance |
| */ |
| private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur ) |
| { |
| this.carnetEnLigneMediateur=carnetEnLigneMediateur; |
| // on crée un modèle |
| observationModele = ObservationModele.Instance(this); |
| // initialisation du référentiel par défaut |
| setRefTaxSelectionne(Configuration.getReferentielsDispos().get(0)); |
| listeObservation = new ListeObservationVue(this); |
| listeObservation.setTitle("Observations"); |
| // quelques variables de position pour les borderlayouts |
| final BorderLayoutData regionNord = new BorderLayoutData( |
| RegionPosition.NORTH); |
| final BorderLayoutData regionCentre = new BorderLayoutData( |
| RegionPosition.CENTER); |
| regionCentre.setSplit(true); |
| final BorderLayoutData regionEst = new BorderLayoutData( |
| RegionPosition.EAST); |
| regionEst.setSplit(true); |
| final BorderLayoutData regionOuest = new BorderLayoutData( |
| RegionPosition.WEST); |
| regionOuest.setSplit(true); |
| panneauPrincipalObservation.setLayout(new BorderLayout()) ; |
| cartoObservationVue = new CartographieObservationVue(this); |
| cartoObservationVue.setLayout(new FitLayout()); |
| // Le formulaire de saisie / modification d'observation |
| formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this); |
| formulaireSaisieObservationVue.setTitle("Saisie"); |
| formulaireSaisieObservationVue.setTitleCollapse(true); |
| formulaireSaisieObservationVue.setCollapsible(true) ; |
| formulaireSaisieObservationVue.setAutoScroll(true) ; |
| fenetreCarto = new com.gwtext.client.widgets.Window(); |
| fenetreCarto.setConstrain(true); |
| fenetreCarto.setModal(true); |
| fenetreCarto.setCloseAction(com.gwtext.client.widgets.Window.HIDE); |
| fenetreCarto.add(cartoObservationVue); |
| formulaireSaisieObservationVue.addListener( |
| new PanelListenerAdapter() { |
| @Override |
| public void onCollapse(Panel panel) { |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| @Override |
| public void onExpand(Panel panel) { |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| }); |
| centre = new Panel(); |
| centre.setLayout(new BorderLayout()); |
| centre.setAutoScroll(true); |
| centre.setBorder(false); |
| centre.addListener( |
| new PanelListenerAdapter() { |
| @Override |
| public void onCollapse(Panel panel) { |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| @Override |
| public void onExpand(Panel panel) { |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, |
| int adjHeight, int rawWidth, int rawHeight) { |
| formulaireSaisieObservationVue.redimensionnerFormulaire(); |
| listeObservation.doLayout(); |
| } |
| @Override |
| public void onAfterLayout(Container self) { |
| } |
| }); |
| formulaireSaisieObservationVue.setBorder(false); |
| BorderLayoutData listeLayoutData = new BorderLayoutData(RegionPosition.SOUTH); |
| listeLayoutData.setSplit(true); |
| BorderLayoutData formLayoutData = new BorderLayoutData(RegionPosition.CENTER); |
| formLayoutData.setSplit(true); |
| centre.add(listeObservation, listeLayoutData); |
| centre.add(formulaireSaisieObservationVue, formLayoutData); |
| // Redimensionnement global sur collapse/expand |
| details.addListener( |
| new PanelListenerAdapter() { |
| @Override |
| public void onCollapse(Panel panel) { |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| @Override |
| public void onExpand(Panel panel) { |
| String[] selectionListe = listeObservation.getIdSelectionnees(); |
| if(selectionListe.length > 0) { |
| Observation obs = listeObservation.getCacheListeObservation().get(selectionListe[0]); |
| obtenirImageInformationExternes(obs.getCodeCourtReferentielTaxo(), obs.getNumeroNomenclaturalSaisi()); |
| } |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| }); |
| // on initialise le volet qui contient les details |
| details.setWidth("10%"); |
| details.setTitleCollapse(true); |
| details.setCollapsible(true); |
| details.setAutoScroll(true); |
| details.setLayout(new RowLayout()); |
| // Lien vers eflore |
| liExtVue = new LienExterneVue(this); |
| liExtVue.setHeight("20px"); |
| details.add(liExtVue); |
| // Information de repartition |
| informationRepartitionVue=new InformationRepartitionVue(this); |
| details.add(informationRepartitionVue, new RowLayoutData("30%")); |
| // Image generique |
| imageGeneriqueVue=new ImageGeneriqueVue(this); |
| details.add(imageGeneriqueVue, new RowLayoutData("30%")); |
| mvz = new MiniZoomImageVue(this) ; |
| details.add(mvz, new RowLayoutData("34%")) ; |
| // on crée le panneau des filtres |
| filtres = new PanneauFiltresObservationVues(this); |
| // on initialise le volet qui contient les filtres |
| filtres.setWidth("10%"); |
| filtres.setTitleCollapse(true); |
| filtres.setCollapsible(true); |
| filtres.addListener( |
| new PanelListenerAdapter() { |
| @Override |
| public void onCollapse(Panel panel) { |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| @Override |
| public void onExpand(Panel panel) { |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| }); |
| panneauPrincipalObservation.add(details,regionEst); |
| panneauPrincipalObservation.add(filtres,regionOuest); |
| panneauPrincipalObservation.add(centre,regionCentre); |
| } |
| /** |
| * Retourne une instance de manière unique |
| * @return l'instance unique du médiateur |
| */ |
| public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur) |
| { |
| if(!estInstancie || thisMediateur == null) |
| { |
| estInstancie = true ; |
| thisMediateur = new ObservationMediateur(carnetEnLigneMediateur) ; |
| } |
| return thisMediateur ; |
| } |
| public void connecterUtilisateur() { |
| if(importerObservations) { |
| observationModele.importerObservations(); |
| } |
| if(panneauPrincipalObservation == null || !panneauPrincipalObservation.isCreated()) |
| { |
| panneauPrincipalObservation.addListener(new ContainerListenerAdapter() |
| { |
| @Override |
| public void onRender(Component c) |
| { |
| panneauPrincipalObservation.purgeListeners() ; |
| initialiserArbres(); |
| filtres.getRechercheLibreVue().raz(); |
| obtenirNombreObservation(); |
| analyserHistorique(); |
| } |
| }) ; |
| } |
| else |
| { |
| initialiserArbres(); |
| filtres.getRechercheLibreVue().raz(); |
| obtenirNombreObservation(); |
| analyserHistorique(); |
| } |
| } |
| private void initialiserArbres() { |
| getPanneauFiltres().getArbreDateObservationFiltreVue().initialiser(); |
| getPanneauFiltres().getArbreEntiteGeographiqueObservationFiltreVue().initialiser(); |
| getPanneauFiltres().getArbreMotsClesObservationVue().initialiser(); |
| } |
| // ACTIONS a entreprendre lors d'un evenement particulier |
| /** |
| * Lors du raffraichissement de la liste d'observation |
| */ |
| public void onRafraichissementListeObservations() { |
| carnetEnLigneMediateur.donneesObsVersImages(listeObservation.getCacheListeObservation()); |
| observationModele.rafraichirCacheObservation(listeObservation.getCacheListeObservation()); |
| filtres.getArbreMotsClesObservationVue().cocherMotsCles(new String[0]); |
| } |
| /** |
| * |
| * TODO : fonction plus generique, appelle sur un clic ou une selection de ligne, a appeller : SelectionnerObservation |
| * est appelé lors d'un clic de souris sur un enregistrement de la liste le |
| * médiateur gère alors les conséquences |
| * |
| * @param rowIndex |
| * le numéro de ligne selectionné |
| */ |
| public void onClicListeObservation(int rowIndex, String ordreObservation) { |
| Observation obs = obtenirCacheObservation().get(ordreObservation) ; |
| if(GWT.isScript()) { |
| masquerChargementInfosObservations() ; |
| } |
| gererMiseAJourFormulaireObservation(); |
| gererMiseAJourPanneauDetails(obs); |
| } |
| public void gererMiseAJourPanneauDetails(Observation obs) { |
| // Affichage de l'image correspondante |
| if(details.isVisible()) { |
| // Affichage de la carte de repartition correspondante |
| String numeroNomenclaturalSaisiObservation = obs.getNumeroNomenclaturalRetenu(); |
| if(numeroNomenclaturalSaisiObservation != null && !numeroNomenclaturalSaisiObservation.isEmpty()) { |
| observationModele.obtenirImageInformationRepartition(informationRepartitionVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ; |
| observationModele.obtenirImageGenerique(imageGeneriqueVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ; |
| } else { |
| informationRepartitionVue.rafraichir("", false); |
| imageGeneriqueVue.rafraichir("", false); |
| } |
| observationModele.obtenirLiaisonImage(mvz, obs.getId()) ; |
| liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false); |
| } |
| filtres.getArbreMotsClesObservationVue().rafraichir(obs.getMotsCles(), false); |
| } |
| public void gererMiseAJourFormulaireObservation() { |
| String[] ids = listeObservation.getIdSelectionnees(); |
| if(ids.length == 1) { |
| Observation obs = listeObservation.getCacheListeObservation().get(ids[ids.length - 1]); |
| // affichage des détails dans le formulaire d'observation |
| formulaireSaisieObservationVue.rafraichir(obs, false) ; |
| } else { |
| ListeObservation listeObs = new ListeObservation(); |
| for(int i=0; i < ids.length;i++) { |
| Observation obsAjout = observationModele.getCacheObservation().get(ids[i]); |
| listeObs.ajouterObservation(obsAjout); |
| } |
| formulaireSaisieObservationVue.rafraichir(listeObs, false); |
| } |
| } |
| public void obtenirImageInformationExternes(String referentielTaxo, String numeroNomenclaturalSaisiObservation) { |
| if(details.isVisible()) { |
| if(GWT.isScript()) { |
| masquerChargementInfosObservations() ; |
| } |
| liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false); |
| observationModele.obtenirImageInformationRepartition(informationRepartitionVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ; |
| observationModele.obtenirImageGenerique(imageGeneriqueVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ; |
| } |
| } |
| public int getTaillePage() { |
| return listeObservation.getTaillePage(); |
| } |
| public int getPageEnCours() { |
| return listeObservation.getPageEncours(); |
| } |
| // ACCES au Modèle |
| // C du CRUD |
| /** |
| * TODO : afficher un message du type "observation ajouté". |
| * Lance la creation d'une observation |
| * @param obs : l'observation saisie |
| */ |
| public void ajouterObservation(Observation obs) { |
| // On rafraichit la liste d'observation |
| observationModele.ajouterObservation(listeObservation, obs) ; |
| filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ; |
| filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ; |
| } |
| // R du CRUD |
| /** |
| * Demande au modele le nombre d'Observation à afficher |
| * TODO : grouper cette demande avec la demande d'affichage de liste ? |
| */ |
| public void obtenirNombreObservation() { |
| listeObservation.masquerChargement() ; |
| mvz.raz() ; |
| imageGeneriqueVue.raz() ; |
| informationRepartitionVue.raz() ; |
| observationModele.obtenirNombreObservation(listeObservation) ; |
| } |
| /** |
| * Demande au modele le nombre d'Observation à afficher |
| * TODO : grouper cette demande avec la demande d'affichage de liste ? |
| */ |
| public void obtenirDernierePageObservation() { |
| listeObservation.rafraichir(new Observation(),false) ; |
| } |
| public void obtenirListeObservation() { |
| obtenirListeObservation(listeObservation); |
| } |
| /** |
| * Demande au modele le detail des Observations à afficher |
| * TODO : grouper cette demande avec la demande d'affichage de liste ? |
| */ |
| public void obtenirListeObservation(Rafraichissable r) { |
| listeObservation.masquerChargement() ; |
| observationModele.obtenirListeObservation(r,listeObservation.getTaillePage(),listeObservation.getPageEncours()) ; |
| } |
| public void obtenirCacheObservation(Rafraichissable r) { |
| r.rafraichir(observationModele.getCacheObservation(), false) ; |
| } |
| /** |
| * Envoie au modèle une demande pour obtenir l'arbre des localites |
| * |
| * @param r |
| * le raffraichissable qui a demandé la mise à jour |
| */ |
| public void obtenirListeEntiteGeographique() { |
| observationModele.obtenirListeEntiteGeographique(filtres.getArbreEntiteGeographiqueObservationFiltreVue()); |
| } |
| // U du CRUD |
| public void modifierObservation(Observation obs) { |
| // On prend soin de récupérer les mots clés de l'observation |
| Observation obsMod = obtenirCacheObservation().get(obs.getNumeroOrdre()); |
| obs.setMotsCles(obsMod.getMotsCles()); |
| // On rafraichit la liste d'observation |
| observationModele.modifierObservation(listeObservation, obs) ; |
| filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ; |
| filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ; |
| } |
| public void modifierObservationEnMasse(Observation obs) { |
| // On rafraichit la liste d'observation |
| listeObservation.masquerChargement(); |
| observationModele.modifierObservationEnMasse(listeObservation, obs) ; |
| } |
| // D du CRUD |
| /** |
| * TODO : afficher un message du type "observation modifie". |
| * Lance la modification d'une observation |
| * @param obs : l'observation a modifier |
| */ |
| public void supprimerObservation(Rafraichissable r, String numeroOrdre) { |
| if(listeObservation.getSelectionModel().getCount() > 0) |
| { |
| if(Window.confirm("Êtes vous sur de vouloir supprimer cette observation ?")) { |
| observationModele.supprimerObservation(r,numeroOrdre) ; |
| } |
| } |
| } |
| public boolean listeAvoirObservations() { |
| return listeObservation.getStore().getCount() > 0; |
| } |
| // Assistants de saisie |
| /** |
| * |
| * Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne |
| * @param r : la vue demandeuse de donnee |
| * @param critere : les criteres de selection |
| */ |
| public void obtenirListeReferentielCommune(Rafraichissable r, String critere) { |
| observationModele.obtenirListeReferentielCommune(r,critere) ; |
| } |
| // Assistants de saisie |
| /** |
| * |
| * Lance un appel de recherche d'une liste de résultats |
| * correspondant aux criteres de selections pour un référentiel donné |
| * @param r : la vue demandeuse de donnee |
| * @param referentiel : le référentiel demandé |
| * @param critere : les criteres de selection |
| */ |
| public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) { |
| observationModele.obtenirListeReferentielPerso(r, referentiel, critere) ; |
| } |
| /** |
| * |
| * Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne |
| * @param r : la vue demandeuse de donnee |
| * @param critere : les criteres de selection |
| */ |
| public void obtenirListeReferentielNom(Rafraichissable r,String referentiel, String critere) { |
| observationModele.obtenirListeReferentielNom(r, referentiel, critere) ; |
| } |
| // Etat du syteme |
| /** |
| * C'est dans cette fonction que doivent être renvoyé les valeurs des filtres |
| * sous forme de tableau [nom, valeur] |
| * @return Les noms et valeurs des filtres |
| */ |
| public String[][] renvoyerFiltres() |
| { |
| int longueur = 0; |
| String[] filtresEntitesGeo = filtres.getArbreEntiteGeographiqueObservationFiltreVue().renvoyerValeursAFiltrer() ; |
| String chaineNomsFiltresGeo = filtresEntitesGeo[0] ; |
| String chaineValFiltresGeo = filtresEntitesGeo[1] ; |
| String[] filtresDate = filtres.getArbreDateObservationFiltreVue().renvoyerValeursAFiltrer() ; |
| String chaineNomsFiltresDate = filtresDate[0] ; |
| String chaineValFiltresDate = filtresDate[1] ; |
| String[] filtresTaxon = filtres.getRechercheLibreVue().renvoyerValeursAFiltrer(); |
| String[] filtresMotsCles = filtres.getArbreMotsClesObservationVue().renvoyerValeursAFiltrer(); |
| String chaineNomsFiltres = "" ; |
| String chaineValFiltres = "" ; |
| if(!chaineNomsFiltresGeo.trim().equals("") && !chaineValFiltresGeo.trim().equals("")) { |
| chaineNomsFiltres += chaineNomsFiltresGeo+","; |
| chaineValFiltres += chaineValFiltresGeo+","; |
| } |
| if(!chaineNomsFiltresDate.trim().equals("") && !chaineValFiltresDate.trim().equals("")) { |
| chaineNomsFiltres += chaineNomsFiltresDate+","; |
| chaineValFiltres += chaineValFiltresDate+","; |
| } |
| if(!filtresTaxon[0].trim().equals("") && !filtresTaxon[1].trim().equals("")) { |
| chaineNomsFiltres += filtresTaxon[0]+","; |
| chaineValFiltres += filtresTaxon[1]+","; |
| } |
| if(!filtresMotsCles[0].trim().equals("") && !filtresMotsCles[1].trim().equals("")) { |
| chaineNomsFiltres += filtresMotsCles[0]; |
| chaineValFiltres += filtresMotsCles[1]; |
| } |
| String[] nomsFiltres = chaineNomsFiltres.split(",") ; |
| String[] valsFiltres = chaineValFiltres.split(",") ; |
| longueur += nomsFiltres.length; |
| String [][] valeursFiltres = new String[longueur][2] ; |
| int i = 0; |
| if(valsFiltres.length > 0) |
| { |
| for(i = 0 ; i < nomsFiltres.length ; i++) |
| { |
| valeursFiltres[i][0] = nomsFiltres[i] ; |
| if(valsFiltres[i].equals("Inconnue")) |
| { |
| valeursFiltres[i][1] = "NULL" ; |
| } |
| else |
| { |
| valeursFiltres[i][1] = valsFiltres[i] ; |
| } |
| } |
| } |
| listeObservation.afficherFiltres(valeursFiltres) ; |
| return valeursFiltres ; |
| } |
| /** |
| * |
| * @return |
| * |
| */ |
| public Panel getPanneauPrincipalObservation() { |
| return panneauPrincipalObservation; |
| } |
| public void montrerContextMenu(EventObject e) { |
| MenuObservationVue mvo = new MenuObservationVue(this) ; |
| mvo.showAt(e.getXY()) ; |
| } |
| public void doubleClicListeObservation(int rowIndex) { |
| } |
| // Getters |
| public PanneauFiltresObservationVues getPanneauFiltres() { |
| return filtres; |
| } |
| public void masquerChargementInfosObservations() |
| { |
| ExtElement masked = Ext.get(details.getId()); |
| if (details.isVisible() && masked != null) { |
| informationRepartitionVue.raz() ; |
| imageGeneriqueVue.raz() ; |
| masked.mask("Chargement", true); |
| } |
| cartoObservationVue.masquerChargement(true); |
| } |
| public void deMasquerChargementInfosObservations() |
| { |
| ExtElement masked = Ext.get(details.getId()); |
| if (details.isVisible() && masked != null) { |
| masked.unmask() ; |
| } |
| } |
| public void obtenirDatesObservation() { |
| observationModele.obtenirDatesObservation(filtres.getArbreDateObservationFiltreVue()) ; |
| } |
| public void exporterObservations(String format, String colonnes) { |
| observationModele.exporterObservations(format, colonnes) ; |
| } |
| public void exporterObservationsPDF() { |
| if(listeObservation.getIdSelectionnees().length > 300) { |
| // com.google.gwt.user.client |
| Window.alert("Les étiquettes ne peuvent être générées pour plus de 300 observations d'un coup."); |
| return; |
| } |
| // TODO: nombre en fonction des filtres actifs, combien d'éléments seraient envoyés ? |
| if(listeObservation.getIdSelectionnees().length == 0) { |
| //import com.google.gwt.core.client.GWT.log( XXX éléments); |
| } |
| observationModele.exporterObservationsPDF(listeObservation.getIdSelectionnees()); |
| } |
| public void deconnecterUtilisateur() { |
| if(panneauPrincipalObservation == null || panneauPrincipalObservation.isCreated() || !panneauPrincipalObservation.isVisible()) |
| { |
| panneauPrincipalObservation.addListener(new ContainerListenerAdapter() |
| { |
| @Override |
| public void onShow(Component component) |
| { |
| deconnecterUtilisateur(); |
| panneauPrincipalObservation.purgeListeners(); |
| } |
| }); |
| } |
| else |
| { |
| listeObservation.raz() ; |
| formulaireSaisieObservationVue.raz() ; |
| razFiltres(); |
| informationRepartitionVue.raz() ; |
| imageGeneriqueVue.raz() ; |
| mvz.raz() ; |
| } |
| } |
| public void supprimerLiaisonObsImage() { |
| String ordreObs = listeObservation.getIdSelectionnees()[0]; |
| String idObs = observationModele.getIdPourOrdreObs(ordreObs); |
| String idImg = mvz.getIdImage() ; |
| if(Window.confirm("Supprimer le lien entre l'image "+idImg+" et l'observations "+idObs+" ?")) |
| { |
| mvz.supprimerLiaisonImage() ; |
| observationModele.supprimerLiaisonImages(idImg,idObs) ; |
| } |
| } |
| public void supprimerObservations() { |
| if(listeObservation.getIdSelectionnees().length > 0) { |
| if(Window.confirm("Êtes vous sur de vouloir supprimer les observations sélectionnées ?")) { |
| String[] numObs = listeObservation.getIdSelectionnees(); |
| String numObsapl = "" ; |
| for(int i = 0 ; i < numObs.length ; i++) { |
| numObsapl += numObs[i]+"," ; |
| } |
| observationModele.supprimerListeObservation(listeObservation,numObsapl) ; |
| } |
| } |
| else |
| { |
| Window.alert("Aucune observation sélectionnée"); |
| } |
| } |
| public void transmettreObservations(boolean publier) { |
| if(Utilisateur.getInstance().isIdentifie()) { |
| if(listeObservation.getIdSelectionnees().length > 0) { |
| String action = "" ; |
| if(publier) { |
| action = "rendre publiques" ; |
| } |
| else { |
| action = "rendre privées" ; |
| } |
| if(Window.confirm("Êtes vous sur de vouloir "+action+" les observations sélectionnées ?")) { |
| String[] numObs = listeObservation.getIdSelectionnees(); |
| String numObsApl = "" ; |
| for(int i = 0 ; i < numObs.length ; i++) { |
| numObsApl += numObs[i] ; |
| if(i != numObs.length - 1) { |
| numObsApl +="," ; |
| } |
| } |
| observationModele.transmettreListeObservation(listeObservation,numObsApl, publier) ; |
| } |
| } |
| else |
| { |
| Window.alert("Aucune observation sélectionnée"); |
| } |
| } |
| else |
| { |
| if(publier) { |
| if(Window.confirm("La publication des observations nécessite d'être identifié, voulez-vous vous identifier ? (toutes vos observations saisies seront conservées)")) { |
| importerObservations = true ; |
| carnetEnLigneMediateur.afficherDialogueConnexion(); |
| } |
| } |
| } |
| } |
| public void analyserHistorique() { |
| if (History.getToken().length()>0) { |
| final String anum=History.getToken(); |
| observationModele.analyserHistorique(formulaireSaisieObservationVue,anum); |
| } |
| } |
| /** |
| * Appelle le modèle pour mettre à jour la paire mot-clé / identifiant du |
| * mot clé |
| * |
| * @param text |
| * le texte du mot clé |
| * @param id |
| * l'identifiant du mot clé |
| */ |
| public void mettreAjourMotsClesId(String text, String id) { |
| observationModele.mettreAjourMotsClesId(text, id); |
| } |
| public boolean gererDDObsSurMotCle(TreeNode NoeudMotCle, DragData dragData) { |
| if(dragData instanceof GridDragData) { |
| GridDragData gdd = ((GridDragData)dragData); |
| String idMotCle = ((String[])NoeudMotCle.getUserObject())[1]; |
| Record[] obsALier = gdd.getSelections(); |
| String idObsALier[] = new String[obsALier.length]; |
| String idObsALierString = ""; |
| for(int i = 0; i < obsALier.length; i++) { |
| if(i != 0) { |
| idObsALierString += ", "; |
| } |
| idObsALierString += obsALier[i].getAsString("ordre_observation"); |
| if(!observationAvoirMotCle(idMotCle, obsALier[i].getAsString("ordre_observation"))) { |
| idObsALier[i] = obsALier[i].getAsString("ordre_observation"); |
| } else { |
| idObsALier[i] = ""; |
| } |
| } |
| String message = "Lier les observations "; |
| if(idObsALier.length == 1) { |
| message = "Lier l'observation "; |
| } |
| if(Window.confirm(message+idObsALierString+" au projet "+NoeudMotCle.getText()+" ?")) { |
| mettreAjourMotsCles(idMotCle, idObsALier); |
| return true; |
| } else { |
| return false; |
| } |
| } else { |
| return false; |
| } |
| } |
| public void gererDDMotCleSurObs(String idObs, String idMC) { |
| Observation obs = obtenirCacheObservation().get(idObs); |
| if(obs == null) { |
| return; |
| } |
| if(observationAvoirMotCle(idMC, idObs)) { |
| if(Window.confirm("Voulez vous supprimer la liaison entre l'observation et le mot clé ?")) { |
| String nouveauMotsCles = obs.getMotsCles().replace(idMC, ""); |
| nouveauMotsCles = nouveauMotsCles.replace(";;", ";"); |
| obs.setMotsCles(nouveauMotsCles); |
| observationModele.supprimerLiaisonMotCleObservations(listeObservation, obs.getId(), idMC); |
| } |
| } |
| } |
| public String gererOverDDMotCleSurObs(String idObs, String IdMC) { |
| if(observationAvoirMotCle(IdMC, idObs)) { |
| return "x-dd-drop-unlink"; |
| } else { |
| return "x-dd-drop-nodrop"; |
| } |
| } |
| /** |
| * Récupère les identifiants des obs selectionnézs et appelle le modèle |
| * pour qu'il mette à jour les associations mots clés/obs |
| * |
| * @param motsClesEnCours |
| * les mots clés à associer aux images selectionnés séparés par |
| * un ';' |
| * @param arbreMC |
| * l'arbre des mots clés à mettre à jour |
| */ |
| public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) { |
| String[] ids = listeObservation.getIdSelectionnees(); |
| observationModele.mettreAjourMotsCles(motsClesEnCours, idsObsALier); |
| } |
| /** |
| * Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots |
| * clés |
| * |
| * @param n |
| * le noeud à ajouter à l'arbre |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| observationModele.ajouterMotCleDansArbre(n, arbreMC); |
| getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n, false); |
| } |
| /** |
| * Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre |
| * dans l'arbre des mots clés |
| * |
| * @param n |
| * le noeud à supprimer |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| observationModele.supprimerMotCleDansArbre(n, arbreMC); |
| getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n.getId(), false); |
| } |
| /** |
| * Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots |
| * clés |
| * |
| * @param n |
| * le noeud à modifier |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| observationModele.modifierMotCleDansArbre(n, arbreMC); |
| getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n, false); |
| } |
| /** |
| * Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans |
| * l'arbre des mots clés |
| * |
| * @param n |
| * le noeud à déplacer |
| * @param arbreMC |
| * le nouvel arbre de mots clés à mettre à jour |
| */ |
| public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| observationModele.deplacerMotCleDansArbre(n, arbreMC); |
| } |
| public void rafraichirArbreMotsCles(Tree arbreMotsCles) { |
| getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(arbreMotsCles, false); |
| } |
| public boolean observationAvoirMotCle(String idMotCle, String idObs) { |
| Observation obs = obtenirCacheObservation().get(idObs); |
| if(obs == null) { |
| return false; |
| } |
| if(obs.getMotsCles().contains(idMotCle)) { |
| return true; |
| } |
| return false; |
| } |
| public void obtenirArbreMotsCles(Rafraichissable r) { |
| observationModele.obtenirArbreMotsCles(r); |
| } |
| public String[] obtenirTexteMotsCles(String[] idsMotsCles) { |
| String[] tableauMotsClesTexte = new String[idsMotsCles.length]; |
| for(int i=0; i< idsMotsCles.length; i++) { |
| tableauMotsClesTexte[i] = observationModele.obtenirTexteMotCle(idsMotsCles[i]); |
| } |
| return tableauMotsClesTexte; |
| } |
| public ListeObservation obtenirCacheObservation() { |
| return observationModele.getCacheObservation(); |
| } |
| public void donneesExterieures(Object nouvelleDonnees) { |
| if(nouvelleDonnees instanceof Tree) { |
| Tree arbreMotsCles = (Tree)nouvelleDonnees ; |
| observationModele.rafraichirArbreMotsCles(nouvelleDonnees); |
| rafraichirArbreMotsCles(arbreMotsCles); |
| } |
| } |
| public void transmettreDonnees(Object o) { |
| carnetEnLigneMediateur.donneesObsVersImages(o); |
| } |
| public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) { |
| observationModele.obtenirInformationCoord(r, lat, lng); |
| } |
| public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) { |
| observationModele.obtenirInformationCommune(r,nomCommune, codePostal); |
| } |
| public void obtenirInformationCoord(double lat, double lng) { |
| observationModele.obtenirInformationCoord(cartoObservationVue, lat, lng); |
| } |
| public void obtenirInformationCommune(String nomCommune, |
| String codePostal) { |
| observationModele.obtenirInformationCommune(cartoObservationVue,nomCommune, codePostal); |
| } |
| public void rafraichirSaisieCommuneObservation(EntiteGeographiqueObservation infosCommune) { |
| formulaireSaisieObservationVue.rafraichir(infosCommune, false); |
| cacherFenetreCarto(); |
| } |
| private void razFiltres() { |
| filtres.getArbreDateObservationFiltreVue().raz() ; |
| filtres.getArbreEntiteGeographiqueObservationFiltreVue().raz() ; |
| filtres.getArbreMotsClesObservationVue().raz(); |
| filtres.getRechercheLibreVue().raz(); |
| } |
| public void viderFiltre(String nom) { |
| filtres.viderFiltres(nom); |
| obtenirNombreObservation(); |
| } |
| public Component getListeObservation() { |
| return listeObservation; |
| } |
| public void redimensionnerPanneaux(int adjHeight, int adjWidth) { |
| formulaireSaisieObservationVue.setHeight(300); |
| listeObservation.setHeight(adjHeight/2); |
| centre.doLayout(); |
| } |
| public void afficherFormulaireImportObservation() { |
| if (formImportObs==null) { // lazy inst. |
| formImportObs = new FormulaireImportObservationVue(this); |
| } |
| formImportObs.afficher(); |
| } |
| public void setImporterObservationsAnonymes(boolean importerObservations) { |
| this.importerObservations = importerObservations; |
| } |
| private void localiserSurCommuneSelectionnee() { |
| cartoObservationVue.masquerChargement(true); |
| double[] coordsTab = formulaireSaisieObservationVue.coordonneesValides(); |
| if(formulaireSaisieObservationVue.coordonneesValides() != null && !formulaireSaisieObservationVue.getCommune().equals("")) { |
| String nomCommune = formulaireSaisieObservationVue.getCommuneSansDepartement(); |
| String dptCommune = formulaireSaisieObservationVue.getDepartement(); |
| EntiteGeographiqueObservation egeo = new EntiteGeographiqueObservation(dptCommune, nomCommune, "",""); |
| egeo.setLat(coordsTab[0]+""); |
| egeo.setLon(coordsTab[1]+""); |
| cartoObservationVue.rafraichir(egeo, false); |
| } else { |
| if(formulaireSaisieObservationVue.coordonneesValides() != null) { |
| obtenirInformationCoord(coordsTab[0],coordsTab[1]); |
| } else if (formulaireSaisieObservationVue.communeInitialisee()) { |
| String nomCommune = formulaireSaisieObservationVue.getCommune(); |
| String dptCommune = formulaireSaisieObservationVue.getDepartement(); |
| obtenirInformationCommune(nomCommune, dptCommune); |
| } else { |
| double[] coordsCentreFrance = cartoObservationVue.getCoordsCentreFrance(); |
| obtenirInformationCoord(coordsCentreFrance[0], coordsCentreFrance[1]); |
| } |
| } |
| } |
| public void afficherFenetreCarto() { |
| int hauteur = (int)Math.round(Window.getClientHeight()*0.75); |
| int largeur = (int)Math.round(Window.getClientWidth()*0.75); |
| fenetreCarto.setSize(largeur, hauteur); |
| if(!fenetreCarto.isVisible()) { |
| fenetreCarto.show(); |
| } |
| cartoObservationVue.setTailleCarte(hauteur - 20, largeur - 20); |
| } |
| private void cacherFenetreCarto() { |
| if(fenetreCarto.isVisible()) { |
| fenetreCarto.hide(); |
| } |
| } |
| public InfosReferentielNom getRefTaxSelectionne() { |
| return refTaxSelectionne; |
| } |
| public void setRefTaxSelectionne(int index) { |
| refTaxSelectionne = Configuration.getReferentielsDispos().get(index); |
| } |
| public void setRefTaxSelectionne(InfosReferentielNom refTax) { |
| refTaxSelectionne = refTax; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/observation/ObservationModele.java |
|---|
| New file |
| 0,0 → 1,743 |
| package org.tela_botanica.client.observation; |
| //TODO : normaliser les noms de methodes (obtenir, ajouter ...) |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ExportObservationsDAO; |
| import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.InformationCommuneDAO; |
| import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielCommuneAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| public class ObservationModele implements Rafraichissable { |
| /** |
| * Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static) |
| */ |
| private static boolean estInstancie = false ; |
| private static ObservationModele thisModele = null ; |
| /** |
| * La configuration en cours |
| */ |
| private Configuration config = null; |
| /** |
| * Le médiateur associé au modèle |
| */ |
| private ObservationMediateur observationMediateur = null ; |
| /** |
| * La liste des mots clés en cours |
| */ |
| private HashMap<String, String> motsCles = new HashMap<String, String>(0); |
| private Tree arbreMotsCles = new Tree() ; |
| /** |
| * La liste des observations affichées en cours (verifier utilité) |
| */ |
| private ListeObservation cacheObservation = new ListeObservation(0) ; |
| /** |
| * DAO dont le resultat peut etre mis en cache |
| * |
| */ |
| private ListeReferentielNomAsynchroneDAO nomDAO=null; |
| private ListeReferentielCommuneAsynchroneDAO refDAO=null; |
| private ListeReferentielPersoAsynchroneDAO refPersoDAO=null; |
| /** |
| * Retourne une instance de manière unique |
| * @param im le médiateur à associer |
| * @return l'instance du modèle |
| */ |
| static ObservationModele Instance(ObservationMediateur observationMediateur) |
| { |
| // si le modèle n'est pas encore instancié |
| if(!estInstancie) |
| { |
| // on en crée un nouveau |
| estInstancie = true ; |
| thisModele = new ObservationModele(observationMediateur); |
| } |
| return thisModele ; |
| } |
| private ObservationModele(ObservationMediateur observationMediateur) { |
| this.observationMediateur=observationMediateur; |
| config = new Configuration(); |
| } |
| /** |
| * Appelle le DAO asynchrone pour obtenir le nombre d'observation |
| * @param r le rafraichissable auxquel on enverra les données |
| * @param filtrage |
| * @param taillePage |
| */ |
| public void obtenirNombreObservation(Rafraichissable r) { |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres() ; |
| // on rassemble les critères |
| // on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages) |
| NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ; |
| noaDAO.obtenirNombreObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres) ; |
| } |
| public void obtenirListeObservation(Rafraichissable r) { |
| obtenirListeObservation(r,observationMediateur.getTaillePage(),observationMediateur.getPageEnCours()); |
| } |
| /** |
| * Appelle le DAO asynchrone pour obtenir la liste des images |
| * @param r le rafraichissable auxquel on enverra les données |
| * @param taillePage |
| */ |
| public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) { |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres() ; |
| // on rassemble les critères |
| // ensuite on demande la page correspondante avec les mêmes critères |
| String[][] criteres2 = new String[criteres.length+2][2] ; |
| criteres2[0][0] = "limite" ; |
| criteres2[0][1] = ""+taillePage ; |
| criteres2[1][0] = "numero_page" ; |
| criteres2[1][1] = ""+pageEncours ; |
| for(int i = 0 ; i < criteres.length ; i++) |
| { |
| criteres2[i+2][0] = criteres[i][0] ; |
| criteres2[i+2][1] = criteres[i][1] ; |
| } |
| // et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images |
| ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this); |
| loaDAO.obtenirListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres2); |
| } |
| /** |
| * Obtenir une liste de commune |
| * @param r |
| * @param critere |
| */ |
| public void obtenirListeReferentielCommune(Rafraichissable r, String critere) { |
| if (refDAO==null) { |
| refDAO=new ListeReferentielCommuneAsynchroneDAO(this); |
| } |
| refDAO.obtenirListeDonnees(r, critere); |
| } |
| /** |
| * Obtenir une liste de commune |
| * @param r |
| * @param critere |
| */ |
| public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) { |
| if (refPersoDAO==null) { |
| refPersoDAO=new ListeReferentielPersoAsynchroneDAO(this); |
| } |
| refPersoDAO.setRefDemande(referentiel); |
| refPersoDAO.obtenirListeDonnees(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), critere); |
| } |
| /** |
| * Obtenir une liste de nom scientifique de plante |
| * @param r |
| * @param critere |
| */ |
| public void obtenirListeReferentielNom(Rafraichissable r, String referentiel, String critere) { |
| if (nomDAO==null) { |
| nomDAO=new ListeReferentielNomAsynchroneDAO(this); |
| } |
| nomDAO.obtenirListeDonnees(r, referentiel, critere); |
| } |
| /** |
| * |
| * Lance la creation d'une observation |
| * @param r : la vue demandeuse de donnee |
| * @param critere : les criteres de selection |
| */ |
| public void ajouterObservation(Rafraichissable r, Observation obs) { |
| ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this); |
| obsDAO.ajouter(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs); |
| } |
| /** |
| * |
| * Lance la creation d'une observation |
| * @param r : la vue demandeuse de donnee |
| * @param critere : les criteres de selection |
| */ |
| public void modifierObservation(Rafraichissable r, Observation obs) { |
| ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this); |
| obsDAO.modifier(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs); |
| } |
| public void modifierObservationEnMasse( |
| Rafraichissable r, Observation obs) { |
| ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this); |
| liObsDAO.modifierEnMasse(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs); |
| } |
| public void supprimerObservation(Rafraichissable r, String numeroOrdre) { |
| ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ; |
| obsDao.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(),numeroOrdre) ; |
| } |
| /** |
| * Accesseur pour la configuration en cours d'utilisation |
| * |
| * @return la configuration |
| */ |
| public Configuration getConfig() { |
| return config; |
| } |
| /** |
| * Obtenir des informations de repartition relative a un numero nomenclatural |
| * @param r |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirImageInformationRepartition(Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) { |
| ImageInformationRepartitionAsynchroneDAO repDAO= new ImageInformationRepartitionAsynchroneDAO(this); |
| repDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation); |
| } |
| /** |
| * Obtenir une image generique associee a un numero nomenclatural |
| * @param r |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirImageGenerique( Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) { |
| ImageGeneriqueVueAsynchroneDAO imgDAO= new ImageGeneriqueVueAsynchroneDAO(this); |
| imgDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation); |
| } |
| /** |
| * Obtenir la liste de l'ensemble des entites geographiques associes aux observation d'un utilisateur |
| * @param r |
| */ |
| public void obtenirListeEntiteGeographique(Rafraichissable r) { |
| ListeEntiteGeographiqueObservationAsynchroneDAO entDAO = new ListeEntiteGeographiqueObservationAsynchroneDAO(this); |
| entDAO.obtenirListeEntitesGeographiques(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| } |
| public void obtenirDatesObservation( |
| Rafraichissable r) { |
| ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this); |
| ldoDAO.obtenirListeDate(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| } |
| public void obtenirLiaisonImage(Rafraichissable r, |
| String idObservation) { |
| LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ; |
| liaDAO.obtenirLiaisonsObservationsImages(r, idObservation,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()) ; |
| } |
| public void exporterObservations(String format, String groupes) { |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres(); |
| // on rassemble les critères |
| // on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages) |
| ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ; |
| exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres, format, groupes) ; |
| } |
| public void exporterObservationsPDF(String[] ordres) { |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres(); |
| String ids = ""; |
| for (int j = 0; j < ordres.length; j++) { |
| ids += getIdPourOrdreObs(ordres[j]) + ","; |
| } |
| String[] fmt = {"obsids", ids}; |
| String[][] tous_criteres = new String[criteres.length + 1][]; |
| System.arraycopy(criteres, 0, tous_criteres, 0, criteres.length); |
| tous_criteres[tous_criteres.length - 1] = fmt; |
| ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ; |
| exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), tous_criteres, "pdf", "standard") ; |
| } |
| public void supprimerLiaisonImages(String idImg, String idObs) { |
| LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ; |
| lienDAO.supprimerLienImageObservation(idImg, idObs) ; |
| } |
| public void supprimerListeObservation(Rafraichissable r, |
| String numObs) { |
| ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this); |
| lioaDAO.supprimerListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObs); |
| } |
| public void transmettreListeObservation( |
| Rafraichissable r, String numObsapl, boolean publier) { |
| TransmissionObservationAsynchroneDAO toaDAO = new TransmissionObservationAsynchroneDAO(this); |
| toaDAO.transmettreObservations(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObsapl, publier); |
| } |
| public void analyserHistorique(Rafraichissable r,String anum) { |
| NomRetenuAsynchroneDAO nraDAO = new NomRetenuAsynchroneDAO(this); |
| nraDAO.obtenirNomRetenu(r, anum); |
| } |
| public void importerObservations() { |
| ImportObservationAsynchroneDAO ioDAO = new ImportObservationAsynchroneDAO(this); |
| ioDAO.importerObservations(); |
| } |
| public void obtenirArbreMotsCles(Rafraichissable r) { |
| MotsClesAsynchroneDAO mcoDAO = new MotsClesAsynchroneDAO("obs"); |
| mcoDAO.obtenirListeMotsCles(this); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof JSONArray) { |
| // alors on a reçu les informations sur les mots clés |
| JSONArray reponse = (JSONArray) nouvelleDonnees; |
| final int taillemax = reponse.size(); |
| // si le tableau est vide |
| if (taillemax == 0) { |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine_obs"); |
| root.setText("Projets"); |
| String[] usObj = { "Projets", "racine_obs" }; |
| root.setUserObject(usObj); |
| arbreMotsCles.setRootNode(root); |
| } |
| // pour chacun des élements du tableau |
| for (int j = 0; j < taillemax; j++) { |
| // on extrait les élements du tableau |
| if (reponse.get(j).isObject() != null) { |
| JSONObject noeud = (JSONObject) reponse.get(j); |
| String id_noeud = noeud.get("id_mot_cle_obs") |
| .isString().stringValue(); |
| String mot_cle = noeud.get("mot_cle").isString() |
| .stringValue(); |
| String parent = noeud.get("ce_mot_cle_obs_parent").isString() |
| .stringValue(); |
| String[] usObj = { mot_cle, id_noeud }; |
| // et on construit l'arbre à partir de la racine (qui est |
| // toujoursl e premier élément) |
| if (id_noeud.equals("racine_obs")) { |
| TreeNode root = new TreeNode(); |
| root.setId(id_noeud); |
| root.setText(mot_cle); |
| root.setUserObject(usObj); |
| arbreMotsCles.setRootNode(root); |
| } else { |
| // et en ajoutant les noeuds un à un (qui sont renvoyé |
| // dans l'ordre hierarchique de leur niveau |
| // ce qui permet de les traiter séquentiellement) |
| TreeNode node = new TreeNode(); |
| node.setId(id_noeud); |
| node.setText(mot_cle); |
| node.setChecked(false); |
| Node parentNode = arbreMotsCles.getNodeById(parent); |
| node.setUserObject(usObj); |
| parentNode.appendChild(node); |
| } |
| motsCles.put(id_noeud, mot_cle); |
| } |
| } |
| // enfin on met à jour l'arbre des mots clés contenu dans le modèle |
| //rafraichirArbreMotsCles(arbreMotsCles); |
| // et on notifie le médiateur de la mise à jour en lui passant une |
| // copie des données |
| observationMediateur.rafraichirArbreMotsCles(arbreMotsCles); |
| } |
| if(nouvelleDonnees instanceof Observation) { |
| observationMediateur.obtenirNombreObservation(); |
| } |
| } |
| /** |
| * Met à jour l'arbre des mots clés à partir d'un objet |
| * |
| * @param o |
| * le nouvel arbre de mots clés |
| */ |
| public void rafraichirArbreMotsCles(Object o) { |
| arbreMotsCles = (com.gwtext.client.data.Tree) o; |
| } |
| /** |
| * Met à jour la table de correspondance mots clés / ids à partir d'un objet |
| * |
| * @param o |
| * la nouvelle table des mots clés |
| */ |
| @SuppressWarnings("unchecked") |
| public void rafraichirMotsCles(Object o) { |
| if (o instanceof HashMap) { |
| motsCles = (HashMap<String, String>) o; |
| } |
| } |
| /** |
| * Va chercher les mots clés associés à une image dans la liste des images |
| * chargée dans le modèle |
| * |
| * @param r |
| * le rafraichissable auquel on enverra les informations |
| * @param id |
| * l'identifiant de l'image |
| */ |
| public void obtenirMotsClesId(Rafraichissable r, String id) { |
| Observation o = cacheObservation.get(id); |
| String motsClesId = o.getMotsCles(); |
| String[] motsClesIdTab = motsClesId.split(","); |
| r.rafraichir(motsClesIdTab, false); |
| } |
| /** |
| * Met à jour les mots clés associés à une obs et appelle le DAO pour |
| * synchroniser la base de données |
| * |
| * @param ids |
| * les identifiants des observations selectionnées |
| * @param motsClesEnCours |
| * les mots clés à appliquer aux observations |
| */ |
| public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) { |
| String motsCles = ""; |
| String obsAlier = ""; |
| int nbObs = 0; |
| for (int i = 0; i < idsObsALier.length; i++) { |
| if (cacheObservation.containsKey(idsObsALier[i])) { |
| if(!motsClesEnCours.endsWith(";") && !motsClesEnCours.startsWith(";")) { |
| motsCles += ";"; |
| } |
| motsCles += motsClesEnCours; |
| nbObs++; |
| Observation m = cacheObservation.get(idsObsALier[i]); |
| obsAlier += ","+m.getId(); |
| if(m.getMotsCles() != null && !m.getMotsCles().endsWith(";") && !motsCles.startsWith(";")) { |
| motsCles += ";"; |
| } |
| m.setMotsCles(m.getMotsCles()+motsCles); |
| cacheObservation.put(m.getNumeroOrdre(), m); |
| } |
| } |
| while(obsAlier.startsWith(",")) { |
| obsAlier = obsAlier.replaceFirst(",", ""); |
| } |
| if(nbObs > 0) { |
| LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this); |
| lmcDAO.modifier(this,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obsAlier, motsClesEnCours); |
| } |
| } |
| public void supprimerLiaisonMotCleObservations( |
| Rafraichissable r, String idObs, String idMC) { |
| LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this); |
| lmcDAO.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idObs, idMC); |
| } |
| /** |
| * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui |
| * fait la mise à jour de l'arbre des mots clés dans la base |
| * |
| * @param n |
| * le nouveau noeud contenant le mot clé |
| * @param arbreMC |
| * l'arbre des mots cles en cours |
| */ |
| public void ajouterMotCleDansArbre(TreeNode n, |
| com.gwtext.client.data.Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| if (!id.equals("racine_obs")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| parentId = parentUsObj[1]; |
| } else { |
| parentId = "racine_obs"; |
| } |
| rafraichirArbreMotsCles(arbreMC); |
| String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle=" |
| + motCle + "&id=" + id + "&parent=" + parentId; |
| MCDao.ajouterBaseDeDonnees(nouveauMotCle); |
| } |
| /** |
| * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va |
| * supprimer les mots clés associés dans la base |
| * |
| * @param n |
| * le noeud à supprimer |
| * @param arbreMC |
| * l'arbre des mots clés en cours |
| */ |
| public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String id = usObj[1]; |
| rafraichirArbreMotsCles(arbreMC); |
| MCDao.supprimerBaseDeDonnees(id); |
| } |
| /** |
| * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le |
| * DAO qui synchronise la modification dans la base de données |
| * |
| * @param n |
| * le noeud modifié |
| * @param arbreMC |
| * l'arbre des mots clés en cours |
| */ |
| public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| if (!id.equals("racine")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| parentId = parentUsObj[1]; |
| } else { |
| parentId = "racine"; |
| } |
| rafraichirArbreMotsCles(arbreMC); |
| String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent=" |
| + parentId; |
| MCDao.modifierBaseDeDonnees(motCleModifie); |
| } |
| /** |
| * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui |
| * reorganise l'arbre dans la base de donnees suivant le changement |
| * |
| * @param n |
| * le noeud deplace (et son sous arbre associe) |
| * @param arbreMC |
| * l'arbre des mots cles en cours |
| */ |
| public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| if (!id.equals("racine_obs")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| parentId = parentUsObj[1]; |
| } else { |
| parentId = "racine_obs"; |
| } |
| rafraichirArbreMotsCles(arbreMC); |
| String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent=" |
| + parentId; |
| MCDao.deplacerBaseDeDonnees(motCleModifie); |
| } |
| /** |
| * Ajoute un nouveau mot clés à la liste des mots clés locale |
| * |
| * @param text |
| * le mot clé |
| * @param id |
| * l'identifiant du mot clé |
| */ |
| public void mettreAjourMotsClesId(String text, String id) { |
| motsCles.put(id, text); |
| } |
| public String obtenirTexteMotCle(String id) { |
| String correspondanceId = ""; |
| String motCleTexte = motsCles.get(id); |
| if(motCleTexte != null) { |
| correspondanceId = motCleTexte; |
| } |
| return correspondanceId; |
| } |
| public void rafraichirCacheObservation(ListeObservation li) { |
| cacheObservation = li ; |
| } |
| public ListeObservation getCacheObservation() { |
| return cacheObservation ; |
| } |
| public String getIdPourOrdreObs(String ordreObs) { |
| return (cacheObservation.get(ordreObs) != null) ? cacheObservation.get(ordreObs).getId() : null; |
| } |
| public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) { |
| InformationCommuneDAO infocommune = new InformationCommuneDAO(r); |
| infocommune.obtenirInfosCommune(r, nomCommune, codePostal); |
| } |
| public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) { |
| InformationCommuneDAO infocommune = new InformationCommuneDAO(r); |
| infocommune.obtenirCommunePlusProche(r, lng, lat); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/util/FormulaireSaisieChampEtendu.java |
|---|
| New file |
| 0,0 → 1,373 |
| package org.tela_botanica.client.util; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.HorizontalPanel; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.ListenerConfig; |
| 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.SimpleStore; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.widgets.Button; |
| 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.FormPanel; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| @SuppressWarnings("unchecked") |
| public abstract class FormulaireSaisieChampEtendu extends FormPanel implements Rafraichissable { |
| 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; |
| final ComboBox nChamp; |
| final String resultTplRefPerso = "<div class=\"search-item-ref\">{label}</div>"; |
| Button ajouterChampsEtenduEtFermer; |
| Button ajouterChampsEtendu; |
| Button annulerAjouterChampEtendu; |
| String idChamp = null; |
| final ComboBox groupesChampsEtendus; |
| private Timer timer = null; |
| private Map<String, String> cacheClesValeur; |
| private Record rdSelectionne = null; |
| private Record groupeSelectionne = null; |
| private String valeurBrute = ""; |
| public FormulaireSaisieChampEtendu() { |
| super(); |
| setPaddings(3); |
| setBodyBorder(false); |
| HTML indicationSaisieGroupe = new HTML("Vous pouvez ajouter plusieurs champs à la fois correspondant à un groupe "+ |
| "par exemple les champs du projet sauvage de ma rue ou florilèges, ou bien "+ |
| "les champs phytosociolgiques "); |
| indicationSaisieGroupe.addStyleName("aideCreerChampEtendu"); |
| groupesChampsEtendus = new ComboBox(); |
| groupesChampsEtendus.setLabel("Ajouter un groupe de champs"); |
| groupesChampsEtendus.setStore(getGroupesChampsEtendusStore()); |
| groupesChampsEtendus.setDisplayField("label") ; |
| groupesChampsEtendus.setValueField("valeur"); |
| groupesChampsEtendus.setEditable(false); |
| groupesChampsEtendus.setHideTrigger(false); |
| groupesChampsEtendus.setForceSelection(true); |
| groupesChampsEtendus.setCls("champ-separation"); |
| groupesChampsEtendus.setValue(""); |
| if(groupesChampsEtendusSontDefinis()) { |
| add(indicationSaisieGroupe); |
| add(groupesChampsEtendus); |
| } |
| HTML indicationSaisie = new HTML("Saisissez un nom de champ ou choisisez un nom proposé par l'autocomplétion "+ |
| "Si vous choissisez un nom de champ existant vous pourrez profiter d'une autocomplétion "+ |
| "sur les valeur déjà saisies pour ce champ par les autres utilisateurs"); |
| indicationSaisie.addStyleName("aideCreerChampEtendu"); |
| add(indicationSaisie); |
| HorizontalPanel hp = new HorizontalPanel(); |
| hp.setBorderWidth(0); |
| nChamp = new ComboBox("Nom du champ", "nom_champ_etendu"); |
| add(nChamp); |
| ajouterChampsEtenduEtFermer = new Button("Ajouter et fermer"); |
| ajouterChampsEtenduEtFermer.setTooltip("Ajouter un champ étendu ou un groupe de champs et fermer la fenêtre"); |
| ajouterChampsEtendu = new Button("Ajouter"); |
| ajouterChampsEtendu.setTooltip("Ajouter un champ étendu ou un groupe de champ"); |
| annulerAjouterChampEtendu = new Button("Annuler"); |
| annulerAjouterChampEtendu.setTooltip("Fermer la fenêtre sans ajouter de champ"); |
| hp.add(ajouterChampsEtenduEtFermer); |
| hp.add(ajouterChampsEtendu); |
| hp.add(annulerAjouterChampEtendu); |
| add(hp); |
| nChamp.setTpl(resultTplRefPerso); |
| nChamp.setMode(ComboBox.REMOTE); |
| nChamp.setItemSelector("div.search-item-ref"); |
| nChamp.setTypeAhead(false); |
| nChamp.setLoadingText("Recherche..."); |
| nChamp.setHideTrigger(true); |
| nChamp.setValidateOnBlur(false); |
| nChamp.setWidth("250px"); |
| nChamp.focus(); |
| ajouterListeners(); |
| } |
| private void ajouterListeners() { |
| ListenerConfig listenerConfigAutocompletion=new ListenerConfig(); |
| listenerConfigAutocompletion.setDelay(200); |
| listenerConfigAutocompletion.setStopPropagation(false); |
| listenerConfigAutocompletion.setStopEvent(true); |
| nChamp.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_END: |
| 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(rdSelectionne != null) { |
| nChamp.setValue(rdSelectionne.getAsString("label")); |
| idChamp = rdSelectionne.getAsString("cle"); |
| valeurBrute = rdSelectionne.getAsString("label"); |
| } |
| break; |
| case KEY_DOWN: |
| if(nChamp.getValueAsString().isEmpty() && !nChamp.isExpanded()) { |
| obtenirListeValeurs("*"); |
| } |
| break; |
| case KEY_ESCAPE: |
| surAnnulation(); |
| break; |
| default: |
| if(timer != null) { |
| timer.cancel(); |
| } |
| timer = new Timer() { |
| @Override |
| public void run() { |
| obtenirListeValeurs(); |
| } |
| }; |
| timer.schedule(300); |
| valeurBrute = nChamp.getValueAsString(); |
| nChamp.setValue(valeurBrute); |
| } |
| } |
| },listenerConfigAutocompletion); |
| // Listener completion |
| nChamp.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| rdSelectionne = record; |
| } |
| @Override |
| public void onBlur(Field field) { |
| nChamp.setRawValue(valeurBrute); |
| nChamp.collapse(); |
| } |
| }); |
| groupesChampsEtendus.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| groupeSelectionne = record; |
| } |
| }); |
| ajouterChampsEtenduEtFermer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(doitAjouterGroupe()) { |
| surValidationMultiple(renvoyerListeChampsEtendus(groupeSelectionne.getAsString("valeur"))); |
| } else { |
| if(champEtenduEstValide()) { |
| surValidation(validerEtRenvoyerChampEtendu()); |
| } else { |
| Window.alert("Le nom du champ étendu ne peut pas être vide"); |
| } |
| } |
| } |
| }); |
| ajouterChampsEtendu.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(champEtenduEstValide()) { |
| surAjout(validerEtRenvoyerChampEtendu()); |
| raz(); |
| } else { |
| Window.alert("Le nom du champ étendu ne peut pas être vide"); |
| } |
| } |
| }); |
| annulerAjouterChampEtendu.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| surAnnulation(); |
| } |
| }); |
| } |
| private void raz() { |
| timer = null; |
| idChamp = null; |
| nChamp.clearValue(); |
| nChamp.focus(); |
| } |
| private ChampSaisieEtendu validerEtRenvoyerChampEtendu() { |
| String valeurChamp = nChamp.getValueAsString(); |
| String idNouveauChamp = ""; |
| if(!estUnChampSelectionne(valeurChamp)) { |
| Date date = new Date(); |
| // affectation d'un id temporaire qui sera remplacé par l'id auto généré à partir |
| // du label |
| idNouveauChamp = "tempid_"+date.getTime(); |
| } else { |
| idNouveauChamp = idChamp; |
| } |
| ChampSaisieEtendu retour = new ChampSaisieEtendu(valeurChamp, idNouveauChamp); |
| retour.setId(idNouveauChamp); |
| return retour; |
| } |
| private List<ChampSaisieEtendu> renvoyerListeChampsEtendus(String groupe) { |
| List<ChampSaisieEtendu> champsDuGroupe = new ArrayList<ChampSaisieEtendu>(); |
| HashMap<String, String> listeChampsEtendus = Configuration.getGroupesChampsEtendus().get(groupe); |
| for (Iterator<String> iterator = listeChampsEtendus.keySet().iterator(); iterator.hasNext();) { |
| String cle = iterator.next(); |
| String label = listeChampsEtendus.get(cle); |
| ChampSaisieEtendu champ = new ChampSaisieEtendu(label, cle); |
| champsDuGroupe.add(champ); |
| } |
| return champsDuGroupe; |
| } |
| private boolean doitAjouterGroupe() { |
| return groupeSelectionne != null && !groupeSelectionne.getAsString("valeur").equals(""); |
| } |
| private boolean champEtenduEstValide() { |
| String valeurChamp = nChamp.getValueAsString(); |
| return (valeurChamp != null && !valeurChamp.isEmpty()); |
| } |
| private boolean estUnChampSelectionne(String valeur) { |
| return cacheClesValeur.containsValue(valeur); |
| } |
| private void obtenirListeValeurs() { |
| obtenirListeValeurs(nChamp.getValueAsString()); |
| } |
| private void obtenirListeValeurs(String valeur) { |
| ListeReferentielChampsEtendusDAO lrce = new ListeReferentielChampsEtendusDAO(null); |
| lrce.obtenirListeNomsChampsEtendus(this, valeur+"*"); |
| } |
| public abstract void surAjout(ChampSaisieEtendu champ); |
| public abstract void surAjoutMultiple(List<ChampSaisieEtendu> champs); |
| public abstract void surValidation(ChampSaisieEtendu champ); |
| public abstract void surValidationMultiple(List<ChampSaisieEtendu> champs); |
| public abstract void surAnnulation(); |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| int i = 0; |
| HashMap<String, String> clesLabels = (HashMap<String, String>)nouvelleDonnees; |
| cacheClesValeur = clesLabels; |
| Object[][] refData = new Object[clesLabels.keySet().size()][2]; |
| for (Iterator<String> it = clesLabels.keySet().iterator(); it.hasNext();) |
| { |
| String cle = it.next(); |
| String label= clesLabels.get(cle); |
| refData[i][0]= cle; |
| refData[i][1]= label; |
| i++; |
| } |
| FieldDef defCle = new StringFieldDef("cle"); |
| FieldDef defLabel = new StringFieldDef("label"); |
| FieldDef[] defTab = {defCle, defLabel}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(refData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| nChamp.setStore(store); |
| store.load(); |
| } |
| private boolean groupesChampsEtendusSontDefinis() { |
| return Configuration.getGroupesChampsEtendus().size() > 0; |
| } |
| private Store getGroupesChampsEtendusStore() { |
| int i = 1; |
| Map<String, HashMap<String, String>> listeGroupesChampsEtendus = Configuration.getGroupesChampsEtendus(); |
| Object[][] valeurs = new Object[listeGroupesChampsEtendus.size()+1][2]; |
| valeurs[0][0] = "..."; |
| valeurs[0][1] = ""; |
| if(listeGroupesChampsEtendus.size() > 0) { |
| for (Iterator<String> it = listeGroupesChampsEtendus.keySet().iterator(); it.hasNext();) |
| { |
| String cle = it.next(); |
| valeurs[i][0]= cle; |
| valeurs[i][1]= cle; |
| i++; |
| } |
| } |
| SimpleStore store = new SimpleStore(new String[] {"label","valeur"},valeurs); |
| store.load(); |
| return store; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/util/AutoCompletionRefComboBox.java |
|---|
| New file |
| 0,0 → 1,170 |
| package org.tela_botanica.client.util; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.ListenerConfig; |
| 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.form.ComboBox; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| public abstract class AutoCompletionRefComboBox extends ComboBox implements Rafraichissable { |
| // TODO: faire un enum |
| 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; |
| private ObservationMediateur oMediateur = null; |
| private TypesReferentiels typeRef = null; |
| private boolean selectionValeur = false; |
| private boolean estModifie = false; |
| final String resultTplRefPerso = "<div class=\"search-item-ref\">{element_referentiel}</div>"; |
| public AutoCompletionRefComboBox(String label, String nom, ObservationMediateur oMediateur, TypesReferentiels typeRef) { |
| // Accesskey pour debugging |
| super(label,nom); |
| this.oMediateur = oMediateur; |
| this.typeRef = typeRef; |
| setTpl(resultTplRefPerso); |
| setMode(ComboBox.REMOTE); |
| setItemSelector("div.search-item-ref"); |
| setTypeAhead(true); |
| setLoadingText("Recherche..."); |
| setHideTrigger(true); |
| ListenerConfig listenerConfigAutocompletion=new ListenerConfig(); |
| listenerConfigAutocompletion.setDelay(200); |
| listenerConfigAutocompletion.setStopPropagation(false); |
| listenerConfigAutocompletion.setStopEvent(false); |
| addKeyPressListener(new EventCallback() { |
| @Override |
| 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 (selectionValeur) { |
| estModifie= true; |
| selectionValeur=false; |
| onModificationValeur(); |
| } |
| else { |
| onValidationSaisie(); |
| } |
| break; |
| default: |
| estModifie = true; |
| onModificationValeur(); |
| obtenirReferentiel(); |
| } |
| } |
| },listenerConfigAutocompletion); |
| // Listener completion |
| addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| setValue(record.getAsString("element_referentiel")); |
| selectionValeur=true; |
| collapse(); |
| } |
| }); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| ListeReferentielPerso referentielPerso = (ListeReferentielPerso)nouvelleDonnees; |
| int i = 0; |
| Object[][] refData = new Object[referentielPerso.size()][1]; |
| for (Iterator<String> it = referentielPerso.keySet().iterator(); it.hasNext();) |
| { |
| String ref= referentielPerso.get(it.next()); |
| refData[i][0]= ref; |
| i++; |
| } |
| FieldDef defStation = new StringFieldDef("element_referentiel"); |
| FieldDef[] defTab = {defStation}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(refData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| setStore(store); |
| store.load(); |
| } |
| private void obtenirReferentiel() { |
| String valeurChamp = getValue(); |
| if(valeurChamp == null) { |
| valeurChamp = ""; |
| } |
| oMediateur.obtenirListeReferentielPerso(this, typeRef, valeurChamp); |
| } |
| public abstract void onValidationSaisie(); |
| public abstract void onModificationValeur(); |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/util/RequestBuilderWithCredentials.java |
|---|
| New file |
| 0,0 → 1,11 |
| package org.tela_botanica.client.util; |
| import com.google.gwt.http.client.RequestBuilder; |
| public class RequestBuilderWithCredentials extends RequestBuilder { |
| public RequestBuilderWithCredentials(Method httpMethod, String url) { |
| super(httpMethod, url); |
| this.setIncludeCredentials(true); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/util/ChampSaisieEtendu.java |
|---|
| New file |
| 0,0 → 1,237 |
| package org.tela_botanica.client.util; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import com.google.gwt.user.client.Timer; |
| 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.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.Component; |
| import com.gwtext.client.widgets.event.ComponentListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.Field; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| public class ChampSaisieEtendu extends ComboBox implements Rafraichissable { |
| // TODO: faire un enum |
| 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; |
| private boolean selectionValeur = false; |
| private boolean estModifie = false; |
| private String cle = null; |
| private String label = null; |
| private Timer timer = null; |
| final String resultTplRefPerso = "<div class=\"search-item-ref\">{valeur}</div>"; |
| private List<String> cacheValeurs; |
| private Record rdSelectionne = null; |
| private String valeurBrute = ""; |
| public ChampSaisieEtendu(String label, String cle) { |
| // Accesskey pour debugging |
| super(label,cle); |
| this.cle =cle; |
| this.label = label; |
| setTpl(resultTplRefPerso); |
| setMode(ComboBox.REMOTE); |
| setItemSelector("div.search-item-ref"); |
| setTypeAhead(false); |
| setLoadingText("Recherche..."); |
| setHideTrigger(true); |
| setValidateOnBlur(false); |
| ListenerConfig listenerConfigAutocompletion=new ListenerConfig(); |
| listenerConfigAutocompletion.setDelay(200); |
| listenerConfigAutocompletion.setStopPropagation(false); |
| listenerConfigAutocompletion.setStopEvent(false); |
| initStoreVide(); |
| if(Configuration.saisieChampsEtendusActivee()) { |
| addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| 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(rdSelectionne != null) { |
| setValue(rdSelectionne.getAsString("valeur")); |
| selectionValeur=true; |
| valeurBrute = rdSelectionne.getAsString("valeur"); |
| } |
| break; |
| case KEY_DOWN: |
| if(getValueAsString().isEmpty() && !isExpanded()) { |
| obtenirListeValeurs("*"); |
| } |
| break; |
| default: |
| if(timer != null) { |
| timer.cancel(); |
| } |
| timer = new Timer() { |
| @Override |
| public void run() { |
| obtenirListeValeurs(); |
| } |
| }; |
| timer.schedule(300); |
| valeurBrute = getValueAsString(); |
| setValue(valeurBrute); |
| } |
| } |
| },listenerConfigAutocompletion); |
| } |
| addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| rdSelectionne = record; |
| setRawValue(rdSelectionne.getAsString("valeur")); |
| } |
| @Override |
| public void onBlur(Field field) { |
| if(rdSelectionne != null && !rdSelectionne.getAsString("valeur").equals(valeurBrute)) { |
| setRawValue(valeurBrute); |
| } |
| } |
| }); |
| this.addListener(new ComponentListenerAdapter() { |
| @Override |
| public void onRender(Component component) { |
| setLargeurChamp(); |
| } |
| }); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| @SuppressWarnings("unchecked") |
| ArrayList<String> valeurs = (ArrayList<String>)nouvelleDonnees; |
| cacheValeurs = valeurs; |
| int i = 0; |
| Object[][] refData = new Object[valeurs.size()][1]; |
| for (Iterator<String> it = valeurs.iterator(); it.hasNext();) |
| { |
| refData[i][0]= it.next(); |
| i++; |
| } |
| FieldDef defValeur = new StringFieldDef("valeur"); |
| FieldDef[] defTab = {defValeur}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(refData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store = new Store(dataProxy,reader); |
| setStore(store); |
| store.load(); |
| } |
| private void obtenirListeValeurs() { |
| String valeurChamp = getValue(); |
| obtenirListeValeurs(valeurChamp); |
| } |
| private void obtenirListeValeurs(String valeurChamp) { |
| if(valeurChamp == null) { |
| valeurChamp = ""; |
| } else { |
| valeurChamp += "*"; |
| } |
| ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null); |
| lrceDao.obtenirListeValeursChampEtendu(this, cle, valeurChamp); |
| } |
| public void setLargeurChamp() { |
| // Correction un peu moche pour améliorer l'affichage du champ |
| String idElementEnfant = Ext.get(("x-form-el-"+cle)).getFirstChild().getId(); |
| Ext.get(idElementEnfant).setWidth("90%", false); |
| Ext.get(cle).setWidth("100%", false); |
| } |
| private void initStoreVide() { |
| Object[][] refData = new Object[0][1]; |
| FieldDef defValeur = new StringFieldDef("valeur"); |
| FieldDef[] defTab = {defValeur}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(refData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store = new Store(dataProxy,reader); |
| setStore(store); |
| store.load(); |
| } |
| @Override |
| public void setValue(String valeur) { |
| valeurBrute = valeur; |
| super.setValue(valeur); |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/client/util/Util.java |
|---|
| New file |
| 0,0 → 1,304 |
| package org.tela_botanica.client.util; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| import org.tela_botanica.client.modeles.objets.ChampEtendu; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONString; |
| public class Util { |
| public Util() { |
| } |
| public static String getValeurJsonOuVide(JSONObject jo, String index) { |
| return jsonNonNull(jo, index) ? ((JSONString)jo.get(index)).stringValue() : ""; |
| } |
| public static Map<String, ChampEtendu> getMapValeursOuVide(JSONObject jo, String index) { |
| Map<String, ChampEtendu> mapValeurs = new HashMap<String, ChampEtendu>(); |
| if(jo.get(index) != null && jo.get(index).isArray() != null) { |
| JSONArray tabJo = jo.get(index).isArray(); |
| for (int i = 0; i < tabJo.size(); i++) { |
| JSONObject champJson = tabJo.get(i).isObject(); |
| String cle = champJson.get("cle").isString().stringValue(); |
| String label = champJson.get("label").isString().stringValue(); |
| String valeur = champJson.get("valeur").isString().stringValue(); |
| ChampEtendu champ = new ChampEtendu(cle, label, valeur); |
| mapValeurs.put(cle, champ); |
| } |
| } |
| return mapValeurs; |
| } |
| public static String convertirChampsEtendusEnChaineRequete(Map<String, ChampEtendu> map) { |
| String json = ""; |
| if (map != null && !map.isEmpty()) { |
| JSONArray jsonArr = new JSONArray(); |
| int i = 0; |
| for (Map.Entry<String, ChampEtendu> entry: map.entrySet()) { |
| jsonArr.set(i, convertirChampEtenduEnJson(entry.getValue())); |
| i++; |
| } |
| json = jsonArr.toString(); |
| } |
| return json; |
| } |
| public static JSONObject convertirChampEtenduEnJson(ChampEtendu champEtendu) { |
| JSONObject jsonObj = new JSONObject(); |
| jsonObj.put("cle", new JSONString(champEtendu.getCle())); |
| jsonObj.put("label", new JSONString(champEtendu.getLabel())); |
| jsonObj.put("valeur", new JSONString(champEtendu.getValeur())); |
| return jsonObj; |
| } |
| public static boolean jsonNonNull(JSONObject jo, String index) { |
| return (jo != null && |
| jo.get(index) != null && |
| jo.get(index).isNull() == null |
| ); |
| } |
| public static String formaterLieu(Observation obs, String modeleLieu) { |
| 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(); |
| if(idLoc.length() > 2) { |
| idLoc = idLoc.substring(0,2); |
| } |
| 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); |
| } |
| lieuModele = lieuModele.trim(); |
| lieuModele = lieuModele.replaceAll(",$",""); |
| lieuModele = lieuModele.replaceAll(",^$",", "); |
| return lieuModele; |
| } |
| public static String obtenirDepartementAPartirChaineCommune(String departement, String commune) { |
| String dep = ""; |
| if(departement == null) { |
| departement = ""; |
| } |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.split(" "); |
| if(depCom.length > 1) { |
| dep = depCom[1].replace('(', ' '); |
| } else { |
| dep = ""; |
| } |
| } else { |
| dep = departement; |
| } |
| 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 ; |
| } |
| if(departement.length() == 4) { |
| departement = "0"+departement; |
| } |
| departement = departement.substring(0,2); |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| return departement; |
| } |
| public static String supprimerNumDepartementChaineLocalite(String chaineLocaliteComplete) { |
| return chaineLocaliteComplete.replaceAll(" \\([0-9]*\\)", ""); |
| } |
| public static String convertirChaineZoneGeoVersDepartement(String chaineZoneGeo) { |
| return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("") && chaineZoneGeo.replaceAll("INSEE-C:", "").length() >= 2) ? |
| chaineZoneGeo.replaceAll("INSEE-C:", "").substring(0, 2) : |
| chaineZoneGeo; |
| } |
| public static String convertirChaineZoneGeoVersCodeInsee(String chaineZoneGeo) { |
| return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("")) ? chaineZoneGeo.replaceAll("INSEE-C:", ""): chaineZoneGeo; |
| } |
| /*** |
| * Fusionne les éléments d'un tableau en une chaîne |
| * @param delim : la chaîne de séparation |
| * @param args : la tableau |
| * @return la chaîne fusionnée |
| */ |
| public static String implode(String delim, String[] args){ |
| StringBuffer sb = new StringBuffer(); |
| int lgArgs = args.length; |
| for(int i = 0; i < lgArgs; i++){ |
| if (i > 0) { |
| sb.append(delim); |
| } |
| sb.append(args[i]); |
| } |
| return sb.toString(); |
| } |
| public static boolean filtreValide(String[] filtre) { |
| return (filtre.length == 2 && |
| filtre[0] != null && |
| !filtre[0].equals("") && |
| filtre[1] != null && |
| !filtre[1].equals("")); |
| } |
| public static 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 "Inconnu" ; |
| } |
| } |
| public static String remplacerSautsDeligneMalEncodes(String chaineAvecSautsDeLignesMalEncodes) { |
| String chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesMalEncodes.replace('\\','%'); |
| chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replaceAll("%n","%"); |
| chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replace('%','\n'); |
| return chaineAvecSautsDeLignesBienEncodes; |
| } |
| public static boolean verifierDateFormatCel(String dateAVerifier) { |
| String dateRemplacee = remplacerSeparateursDateFormatCel(dateAVerifier); |
| String[] tabDate = dateRemplacee.split("/"); |
| boolean retour = false; |
| if(tabDate.length == 3) { |
| //TODO: faire un parsing de date qui fonctionne mieux car |
| // on peut saisir un 31 novembre par exemple |
| // mais l'api date de java est mal gérée par gwt |
| try { |
| int jour = Integer.parseInt(tabDate[0]); |
| int mois = Integer.parseInt(tabDate[1]); |
| int annee = Integer.parseInt(tabDate[2]); |
| if(jour <= 31 && mois <= 12 && tabDate[2].length() == 4) { |
| retour = true; |
| } |
| } catch (Exception e) { |
| } |
| } |
| return retour; |
| } |
| public static String remplacerSeparateursDateFormatCel(String date) { |
| String dateRemplacee = date.replaceAll("-", "/"); |
| return dateRemplacee; |
| } |
| public static boolean estZero(String s) { |
| boolean estZero = false; |
| try { |
| Double dou = Double.parseDouble(s); |
| estZero = (dou == 0); |
| } catch(NumberFormatException e) { |
| } |
| return estZero; |
| } |
| public static String formaterNombre(String s) { |
| s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", ""); |
| return s; |
| } |
| } |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/public |
|---|
| New file |
| Property changes: |
| Added: svn:ignore |
| +* |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/cel-test.gwt.xml |
|---|
| New file |
| 0,0 → 1,10 |
| <module rename-to="org.tela_botanica.cel2"> |
| <!-- |
| http://stackoverflow.com/questions/1011863/how-do-i-speed-up-the-gwt-compiler |
| http://code.google.com/p/google-web-toolkit/source/browse/trunk/user/src/com/google/gwt/useragent/UserAgent.gwt.xml |
| http://www.gwtproject.org/doc/latest/DevGuideOrganizingProjects.html#DevGuideModuleXml |
| --> |
| <inherits name="org.tela_botanica.cel2" /> |
| <set-property name="user.agent" value="gecko1_8" /> |
| <set-property name="locale" value="default" /> |
| </module> |
| /tags/v1.8-debroussailleuse/src/org/tela_botanica/cel2.gwt.xml |
|---|
| New file |
| 0,0 → 1,25 |
| <module> |
| <!-- Inherit the core Web Toolkit stuff. --> |
| <inherits name='com.google.gwt.user.User'/> |
| <!-- Inherit the default GWT style sheet. You can change --> |
| <!-- the theme of your GWT application by uncommenting --> |
| <!-- any one of the following lines. --> |
| <inherits name='com.google.gwt.user.theme.standard.Standard'/> |
| <!-- <inherits name='com.google.gwt.user.theme.chrome.Chrome'/> --> |
| <!-- <inherits name='com.google.gwt.user.theme.dark.Dark'/> --> |
| <!-- Other module inherits --> |
| <!-- Parsing JSON --> |
| <inherits name='com.google.gwt.json.JSON' /> |
| <!-- cartes --> |
| <inherits name="com.google.gwt.maps.GoogleMaps" /> |
| <inherits name='com.gwtext.GwtExt'/> |
| <inherits name='com.gwtextux.GwtExtUx' /> |
| <!-- Specify the app entry point class. --> |
| <entry-point class='org.tela_botanica.client.cel2'/> |
| </module> |